Fix tests logic to get method from stack and backward compatibility

Author: andrebonna

README.md

@@ -18,7 +18,7 @@ Based on [facebook's Jest framework](https://facebook.github.io/jest/docs/en/sna
 
 
 
-#### How to install using [Maven](https://mvnrepository.com/artifact/io.github.json-snapshot/json-snapshot/1.0.16)
+#### How to install using [Maven](https://mvnrepository.com/artifact/io.github.json-snapshot/json-snapshot/1.0.17)
 
 
 
@@ -28,7 +28,7 @@ Add to your pom.xml dependencies section:
 <dependency>
     <groupId>io.github.json-snapshot</groupId>
     <artifactId>json-snapshot</artifactId>
-    <version>1.0.16</version>
+    <version>1.0.17</version>
 </dependency>
 ```
 

pom.xml

@@ -5,7 +5,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>io.github.json-snapshot</groupId>
   <artifactId>json-snapshot</artifactId>
-  <version>1.0.16</version>
+  <version>1.0.17</version>
   <packaging>jar</packaging>
 
   <name>json-snapshot</name>

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

@@ -162,7 +162,10 @@ private static void validateExpectCall(Snapshot snapshot) {
 
   private static Method getMethod(Class<?> clazz, String methodName) {
     try {
-      return clazz.getDeclaredMethod(methodName);
+      return Stream.of(clazz.getDeclaredMethods())
+          .filter(method -> method.getName().equals(methodName))
+          .findFirst()
+          .orElseThrow(() -> new NoSuchMethodException("Not Found"));
     } catch (NoSuchMethodException e) {
       return Optional.ofNullable(clazz.getSuperclass())
           .map(superclass -> getMethod(superclass, methodName))

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

@@ -47,11 +47,12 @@ private static <T> HashMap<String, List<LinkedHashMap<String, Object>>> process(
       SnapshotCaptor[] snapshotCaptors) {
     HashMap<String, List<LinkedHashMap<String, Object>>> result = new HashMap<>();
     try {
-      Parameter[] parameters = object.getClass().getMethod(methodName, classes).getParameters();
+      Parameter[] parameters =
+          object.getClass().getDeclaredMethod(methodName, classes).getParameters();
 
       object
           .getClass()
-          .getMethod(methodName, classes)
+          .getDeclaredMethod(methodName, classes)
           .invoke(
               verify(object, atLeastOnce()),
               captors.stream().map(ArgumentCaptor::capture).toArray());

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

@@ -0,0 +1,100 @@
+package io.github.jsonSnapshot;
+
+import static io.github.jsonSnapshot.SnapshotMatcher.*;
+import static io.github.jsonSnapshot.SnapshotUtils.extractArgs;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class BackwardCompatilbleTest {
+
+  @Mock private FakeObject fakeObject;
+
+  @BeforeClass
+  public static void beforeAll() {
+    start();
+  }
+
+  @AfterClass
+  public static void afterAll() {
+    validateSnapshots();
+  }
+
+  @Test // Snapshot any object
+  public void shouldShowSnapshotExample() {
+    expect("<any type of object>").toMatchSnapshot();
+  }
+
+  @Test // Snapshot arguments passed to mocked object (from Mockito library)
+  public void shouldExtractArgsFromMethod() {
+    fakeObject.fakeMethod("test1", 1L, Arrays.asList("listTest1"));
+    fakeObject.fakeMethod("test2", 2L, Arrays.asList("listTest1", "listTest2"));
+
+    expect(
+            extractArgs(
+                fakeObject,
+                "fakeMethod",
+                new SnapshotCaptor(String.class),
+                new SnapshotCaptor(Long.class),
+                new SnapshotCaptor(List.class)))
+        .toMatchSnapshot();
+  }
+
+  @Test // Snapshot arguments passed to mocked object support ignore of fields
+  public void shouldExtractArgsFromFakeMethodWithComplexObject() {
+    FakeObject fake = new FakeObject();
+    fake.setId("idMock");
+    fake.setName("nameMock");
+
+    // With Ignore
+    fakeObject.fakeMethodWithComplexObject(fake);
+    Object fakeMethodWithComplexObjectWithIgnore =
+        extractArgs(
+            fakeObject,
+            "fakeMethodWithComplexObject",
+            new SnapshotCaptor(Object.class, FakeObject.class, "name"));
+
+    Mockito.reset(fakeObject);
+
+    // Without Ignore of fields
+    fakeObject.fakeMethodWithComplexObject(fake);
+    Object fakeMethodWithComplexObjectWithoutIgnore =
+        extractArgs(
+            fakeObject,
+            "fakeMethodWithComplexObject",
+            new SnapshotCaptor(Object.class, FakeObject.class));
+
+    expect(fakeMethodWithComplexObjectWithIgnore, fakeMethodWithComplexObjectWithoutIgnore)
+        .toMatchSnapshot();
+  }
+
+  class FakeObject {
+
+    private String id;
+
+    private Integer value;
+
+    private String name;
+
+    void fakeMethod(String fakeName, Long fakeNumber, List<String> fakeList) {}
+
+    void fakeMethodWithComplexObject(Object fakeObj) {}
+
+    void setId(String id) {
+      this.id = id;
+    }
+
+    void setName(String name) {
+      this.name = name;
+    }
+  }
+}

src/test/java/io/github/jsonSnapshot/BackwardCompatilbleTest.snap

@@ -0,0 +1,49 @@
+io.github.jsonSnapshot.BackwardCompatilbleTest.shouldExtractArgsFromFakeMethodWithComplexObject=[
+  {
+    "FakeObject.fakeMethodWithComplexObject": [
+      {
+        "arg0": {
+          "id": "idMock"
+        }
+      }
+    ]
+  },
+  {
+    "FakeObject.fakeMethodWithComplexObject": [
+      {
+        "arg0": {
+          "id": "idMock",
+          "name": "nameMock"
+        }
+      }
+    ]
+  }
+]
+
+
+io.github.jsonSnapshot.BackwardCompatilbleTest.shouldExtractArgsFromMethod=[
+  {
+    "FakeObject.fakeMethod": [
+      {
+        "arg0": "test1",
+        "arg1": 1,
+        "arg2": [
+          "listTest1"
+        ]
+      },
+      {
+        "arg0": "test2",
+        "arg1": 2,
+        "arg2": [
+          "listTest1",
+          "listTest2"
+        ]
+      }
+    ]
+  }
+]
+
+
+io.github.jsonSnapshot.BackwardCompatilbleTest.shouldShowSnapshotExample=[
+  "<any type of object>"
+]

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

@@ -0,0 +1,29 @@
+package io.github.jsonSnapshot;
+
+import static io.github.jsonSnapshot.SnapshotMatcher.expect;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+class PrivateCalledMethodTest {
+
+  @BeforeAll
+  static void beforeAll() {
+    SnapshotMatcher.start();
+  }
+
+  @AfterAll
+  static void afterAll() {
+    SnapshotMatcher.validateSnapshots();
+  }
+
+  @Test
+  void testName() {
+    testBasedOnArgs("testContent");
+  }
+
+  private void testBasedOnArgs(String arg) {
+    expect(arg).toMatchSnapshot();
+  }
+}

src/test/java/io/github/jsonSnapshot/PrivateCalledMethodTest.snap

@@ -0,0 +1,3 @@
+io.github.jsonSnapshot.PrivateCalledMethodTest.testName=[
+  "testContent"
+]