✨ Add Snapshot.ignore(String... jsonPaths) method

Author: Fredrik Teschke

pom.xml

@@ -86,6 +86,11 @@
             <artifactId>slf4j-api</artifactId>
             <version>1.7.25</version>
         </dependency>
+        <dependency>
+            <groupId>com.jayway.jsonpath</groupId>
+            <artifactId>json-path</artifactId>
+            <version>2.4.0</version>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ -1,13 +1,21 @@
 package io.github.jsonSnapshot;
 
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.jayway.jsonpath.DocumentContext;
+import com.jayway.jsonpath.JsonPath;
+import com.jayway.jsonpath.spi.json.GsonJsonProvider;
 import org.assertj.core.util.diff.DiffUtils;
 import org.assertj.core.util.diff.Patch;
 
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.List;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 public class Snapshot {
 
@@ -19,6 +27,10 @@ public class Snapshot {
 
     private Function<Object, String> jsonFunction;
 
+    private final Gson gsonForIgnoringPaths = new GsonBuilder().create();
+
+    private final List<String> pathsToIgnore = new ArrayList<>();
+
     private Object[] current;
 
     Snapshot(SnapshotFile snapshotFile, Class clazz, Method method, Function<Object, String> jsonFunction, Object... current) {
@@ -69,11 +81,38 @@ private String getRawSnapshot(Collection<String> rawSnapshots) {
         return null;
     }
 
+    private Object ignorePaths(Object input) {
+        DocumentContext context = JsonPath.using(new GsonJsonProvider()).parse(gsonForIgnoringPaths.toJsonTree(input));
+        this.pathsToIgnore.forEach(path -> context.delete(path));
+        String root = "$";
+        return context.read(root);
+    }
+
+    private Object[] getCurrentWithoutIgnoredPaths() {
+        if (pathsToIgnore.isEmpty() || current == null) {
+            return current;
+        }
+
+        return Arrays.asList(current).stream()
+            .map(this::ignorePaths)
+            .collect(Collectors.toList())
+            .toArray();
+    }
+
     private String takeSnapshot() {
-        return getSnapshotName() + jsonFunction.apply(current);
+        return getSnapshotName() + jsonFunction.apply(getCurrentWithoutIgnoredPaths());
     }
 
     public String getSnapshotName() {
         return clazz.getName() + "." + method.getName() + "=";
     }
+
+    /**
+     * Ignore fields when comparing object and snapshot.
+     * @param jsonPathsToIgnore A list of paths to ignore in <a href="https://github.com/json-path/JsonPath">JsonPath</a> syntax.
+     */
+    public Snapshot ignoring(String... jsonPathsToIgnore) {
+        this.pathsToIgnore.addAll(Arrays.asList(jsonPathsToIgnore));
+        return this;
+    }
 }

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

@@ -76,4 +76,28 @@ public void shouldThrowStackOverflowError() {
 
         expect(fakeObject1).toMatchSnapshot();
     }
+
+    @Test
+    public void shouldMatchSnapshotAndIgnoreTopLevelFieldMethod() {
+        expect(FakeObject.builder().id("anyId6").value(6).name("anyName6").build())
+                .ignoring("value")
+                .toMatchSnapshot();
+    }
+
+    @Test
+    public void shouldMatchSnapshotAndIgnoreSeveralNestedFieldsMethod() {
+        FakeObject grandChild = FakeObject.builder().id("grandChild7").value(7).build();
+        FakeObject child = FakeObject.builder().id("child7").value(7).fakeObject(grandChild).build();
+        expect(FakeObject.builder().id("anyId7").value(7).name("anyName7").fakeObject(child).build())
+                .ignoring("value", "fakeObject.id", "fakeObject.fakeObject")
+                .toMatchSnapshot();
+    }
+
+    @Test
+    public void shouldMatchSnapshotAndIgnoreEverythingMethod() {
+        FakeObject child = FakeObject.builder().id("child8").value(8).build();
+        expect(FakeObject.builder().id("anyId8").value(8).name("anyName8").fakeObject(child).build())
+                .ignoring("$..*")
+                .toMatchSnapshot();
+    }
 }

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

@@ -1,3 +1,27 @@
+io.github.jsonSnapshot.SnapshotIntegrationTest.shouldMatchSnapshotAndIgnoreEverythingMethod=[
+  {}
+]
+
+
+io.github.jsonSnapshot.SnapshotIntegrationTest.shouldMatchSnapshotAndIgnoreSeveralNestedFieldsMethod=[
+  {
+    "id": "anyId7",
+    "name": "anyName7",
+    "fakeObject": {
+      "value": 7
+    }
+  }
+]
+
+
+io.github.jsonSnapshot.SnapshotIntegrationTest.shouldMatchSnapshotAndIgnoreTopLevelFieldMethod=[
+  {
+    "id": "anyId6",
+    "name": "anyName6"
+  }
+]
+
+
 io.github.jsonSnapshot.SnapshotIntegrationTest.shouldMatchSnapshotFour=[
   {
     "id": "anyId4",

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

@@ -1,6 +1,8 @@
 package io.github.jsonSnapshot;
 
 import com.google.gson.GsonBuilder;
+import com.google.gson.JsonParser;
+import com.jayway.jsonpath.PathNotFoundException;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -10,6 +12,7 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.util.Collections;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -28,13 +31,17 @@ public class SnapshotTest {
 
     private Snapshot snapshot;
 
+    private Snapshot createSnapshot(Object... current) throws NoSuchMethodException {
+        return new Snapshot(snapshotFile, String.class,
+                String.class.getDeclaredMethod("toString"),
+                (object) -> new GsonBuilder().setPrettyPrinting().create().toJson(object),current);
+    }
+
 
     @Before
     public void setUp() throws NoSuchMethodException, IOException {
         snapshotFile = new SnapshotFile(DEFAULT_CONFIG.getFilePath(), "anyFilePath");
-        snapshot = new Snapshot(snapshotFile, String.class,
-                String.class.getDeclaredMethod("toString"),
-                (object) -> new GsonBuilder().setPrettyPrinting().create().toJson(object),"anyObject");
+        snapshot = createSnapshot("anyObject");
     }
 
     @After
@@ -60,4 +67,39 @@ public void shouldMatchSnapshotWithException() {
         snapshot.toMatchSnapshot();
     }
 
+    @Test
+    public void shouldNotFailOnEmptyIgnoredPathList() {
+        snapshot.ignoring().toMatchSnapshot();
+        assertThat(snapshotFile.getRawSnapshots()).isEqualTo(Stream.of(SNAPSHOT).collect(Collectors.toCollection(TreeSet::new)));
+    }
+
+    @Test(expected = PathNotFoundException.class)
+    public void shouldFailWhenTryingToIgnoreChildOfPrimitiveJsonObject() {
+        snapshot.ignoring("anyObject_is_a_json_string_and_can_not_have_children").toMatchSnapshot();
+    }
+
+    @Test
+    public void shouldIgnoreTopLevelAndNestedFields() throws NoSuchMethodException {
+        Object object = new JsonParser().parse("{\n" +
+                "  \"notIgnored\": \"notIgnored\",\n" +
+                "  \"ignoredInParent\": \"ignored\",\n" +
+                "  \"child\": {\n" +
+                "    \"ignoredInParent\": \"notIgnored\",\n" +
+                "    \"ignoredInChild\": \"ignored\"\n" +
+                "  }\n" +
+                "}");
+        Snapshot snapshot = createSnapshot(object);
+
+        snapshot.ignoring("ignoredInParent", "child.ignoredInChild").toMatchSnapshot();
+        String expectedSnapshot = "java.lang.String.toString=[\n" +
+                "  {\n" +
+                "    \"notIgnored\": \"notIgnored\",\n" +
+                "    \"child\": {\n" +
+                "      \"ignoredInParent\": \"notIgnored\"\n" +
+                "    }\n" +
+                "  }\n" +
+                "]";
+        assertThat(snapshotFile.getRawSnapshots()).isEqualTo(Collections.singleton(expectedSnapshot));
+    }
+
 }