Merge pull request #14 from grimsa/bugfix/12

[JUnit5] support package-private test methods + minor refactoring

Author: andrebonna

src/main/java/io/github/jsonSnapshot/SnapshotMatcher.java

@@ -20,9 +20,11 @@
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class SnapshotMatcher {
 
@@ -80,19 +82,15 @@ public static void validateSnapshots() {
     public static Snapshot expect(Object firstObject, Object... others) {
 
         if (clazz == null) {
-            throw new SnapshotMatchException("SnapshotTester not yet started! Start it on @BeforeClass with SnapshotMatcher.start()");
-        }
-        try {
-            Object[] objects = mergeObjects(firstObject, others);
-            StackTraceElement stackElement = findStackElement();
-            Method method = getMethod(stackElement, clazz);
-            Snapshot snapshot = new Snapshot(snapshotFile, clazz, method, jsonFunction, objects);
-            validateExpectCall(snapshot);
-            calledSnapshots.add(snapshot);
-            return snapshot;
-        } catch (ClassNotFoundException e) {
-            throw new SnapshotMatchException(e.getMessage());
+            throw new SnapshotMatchException("SnapshotTester not yet started! Start it on @BeforeClass/@BeforeAll with SnapshotMatcher.start()");
         }
+        Object[] objects = mergeObjects(firstObject, others);
+        StackTraceElement stackElement = findStackElement();
+        Method method = getMethod(clazz, stackElement.getMethodName());
+        Snapshot snapshot = new Snapshot(snapshotFile, clazz, method, jsonFunction, objects);
+        validateExpectCall(snapshot);
+        calledSnapshots.add(snapshot);
+        return snapshot;
     }
 
     static Function<Object, String> defaultJsonFunction() {
@@ -144,46 +142,39 @@ private static void validateExpectCall(Snapshot snapshot) {
         }
     }
 
-    private static Method getMethod(StackTraceElement testClass, Class clazz) {
-        Method method;
+    private static Method getMethod(Class<?> clazz, String methodName) {
         try {
-            method = clazz.getMethod(testClass.getMethodName());
+            return clazz.getDeclaredMethod(methodName);
         } catch (NoSuchMethodException e) {
-            throw new SnapshotMatchException("Please annotate your test method with @Test and make it without any parameters!");
+            return Optional.ofNullable(clazz.getSuperclass())
+                    .map(superclass -> getMethod(superclass, methodName))
+                    .orElseThrow(() -> new SnapshotMatchException("Could not find method " + methodName + " on class " + clazz
+                            + "\nPlease annotate your test method with @Test and make it without any parameters!"));
         }
-        return method;
     }
 
-    private static StackTraceElement findStackElement() throws ClassNotFoundException {
+    private static StackTraceElement findStackElement() {
         StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
-
-        int i = 1; // Start after stackTrace
-        while (i < stackTraceElements.length &&
-                SnapshotMatcher.class.equals(Class.forName(stackTraceElements[i].getClassName()))) { //TODO
-            i++;
+        int elementsToSkip = 1; // Start after stackTrace
+        while (SnapshotMatcher.class.getName().equals(stackTraceElements[elementsToSkip].getClassName())) {
+            elementsToSkip++;
         }
 
-        for (int j = i; j < stackTraceElements.length; j++) {
-
-            try {
-                Class clazz = Class.forName(stackTraceElements[j].getClassName());
-                Method method = clazz.getMethod(stackTraceElements[j].getMethodName());
-
-                // Navigate into stack until Test class/method level
-                if (method.isAnnotationPresent(Test.class) || method.isAnnotationPresent(BeforeClass.class) ||
-                        method.isAnnotationPresent(org.junit.jupiter.api.Test.class) || method.isAnnotationPresent(BeforeAll.class)) {
-                    i = j;
-                    break;
-                }
-            }
-            catch(NoSuchMethodException ignored) {
-
-            }
-        }
+        return Stream.of(stackTraceElements)
+                .skip(elementsToSkip)
+                .filter(stackTraceElement -> hasTestAnnotation(getMethod(getClass(stackTraceElement.getClassName()), stackTraceElement.getMethodName())))
+                .findFirst()
+                .orElseThrow(() -> new SnapshotMatchException("Could not locate a method with one of supported test annotations"));
+    }
 
-        return stackTraceElements[i];
+    private static boolean hasTestAnnotation(Method method) {
+        return method.isAnnotationPresent(Test.class)
+                || method.isAnnotationPresent(BeforeClass.class)
+                || method.isAnnotationPresent(org.junit.jupiter.api.Test.class)
+                || method.isAnnotationPresent(BeforeAll.class);
     }
 
+
     private static Object[] mergeObjects(Object firstObject, Object[] others) {
         Object[] objects = new Object[1];
         objects[0] = firstObject;
@@ -192,4 +183,12 @@ private static Object[] mergeObjects(Object firstObject, Object[] others) {
         }
         return objects;
     }
+
+    private static Class<?> getClass(String className) {
+        try {
+            return Class.forName(className);
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
 }

src/test/java/io/github/jsonSnapshot/SnapshotIntegrationTest.java

@@ -13,37 +13,37 @@
 public class SnapshotIntegrationTest {
 
     @BeforeAll
-    public static void beforeAll() {
+    static void beforeAll() {
         start();
     }
 
     @AfterAll
-    public static void afterAll() {
+    static void afterAll() {
         validateSnapshots();
     }
 
     @Test
-    public void shouldMatchSnapshotOne() {
+    void shouldMatchSnapshotOne() {
         expect(FakeObject.builder().id("anyId1").value(1).name("anyName1").build()).toMatchSnapshot();
     }
 
     @Test
-    public void shouldMatchSnapshotTwo() {
+    void shouldMatchSnapshotTwo() {
         expect(FakeObject.builder().id("anyId2").value(2).name("anyName2").build()).toMatchSnapshot();
     }
 
     @Test
-    public void shouldMatchSnapshotThree() {
+    void shouldMatchSnapshotThree() {
         expect(FakeObject.builder().id("anyId3").value(3).name("anyName3").build()).toMatchSnapshot();
     }
 
     @Test
-    public void shouldMatchSnapshotFour() {
+    void shouldMatchSnapshotFour() {
         expect(FakeObject.builder().id("anyId4").value(4).name("any\n\n\nName4").build()).toMatchSnapshot();
     }
 
     @Test
-    public void shouldMatchSnapshotInsidePrivateMethod() {
+    void shouldMatchSnapshotInsidePrivateMethod() {
         matchInsidePrivate();
     }
 
@@ -52,13 +52,13 @@ private void matchInsidePrivate() {
     }
 
     @Test
-    public void shouldThrowSnapshotMatchException() {
+    void shouldThrowSnapshotMatchException() {
         assertThrows(SnapshotMatchException.class, expect(FakeObject.builder().id("anyId5").value(6).name("anyName5").build())::toMatchSnapshot, "Error on: \n" +
                 "io.github.jsonSnapshot.SnapshotIntegrationTest.shouldThrowSnapshotMatchException=[");
     }
 
     @Test
-    public void shouldThrowStackOverflowError() {
+    void shouldThrowStackOverflowError() {
         // Create cycle JSON
         FakeObject fakeObject1 = FakeObject.builder().id("anyId1").value(1).name("anyName1").build();
         FakeObject fakeObject2 = FakeObject.builder().id("anyId2").value(2).name("anyName2").build();