Make it possible to correctly assert on path to null value.

json-path-assert/README.md

@@ -83,7 +83,7 @@ Use typed matchers for specific JSON representations, if needed
 
 ---
 
-CAUTION: regarding the use of indefinite paths
+### Regarding the use of indefinite paths
 
 When using indefinite path expressions (e.g with wildcards '*'), the result will yield a list. Possibly an _empty_ list if no matching entries were found. If you want to assert that the list will actually contain something, make sure to express this explicitly, e.g checking for the size of the list.
 
@@ -101,3 +101,25 @@ When using indefinite path expressions (e.g with wildcards '*'), the result will
     
     // However, checking for the existence of an array works fine, as is
     assertThat(json, hasJsonPath("$.not_here[*]"));
+
+---
+
+### Regarding the use of null in JSON
+
+'null' is a valid JSON value. If such a value exist, the path is still considered to be a valid path.
+
+    // Given a JSON like this:
+    { "none": null }
+    
+    // All of these will succeed, since '$.none' is a valid path
+    assertThat(json, hasJsonPath("$.none"));
+    assertThat(json, isJson(withJsonPath("$.none")));
+    assertThat(json, hasJsonPath("$.none", nullValue()));
+    assertThat(json, isJson(withJsonPath("$.none", nullValue())));
+    
+    // But all of these will fail, since '$.not_there' is not a valid path
+    assertThat(json, hasJsonPath("$.not_there"));
+    assertThat(json, isJson(withJsonPath("$.not_there")));
+    assertThat(json, hasJsonPath("$.not_there", anything()));
+    assertThat(json, isJson(withJsonPath("$.not_there", anything())));
+

json-path-assert/src/main/java/com/jayway/jsonpath/matchers/JsonPathMatchers.java

@@ -19,7 +19,7 @@ public class JsonPathMatchers {
 
     public static Matcher<? super Object> hasJsonPath(String jsonPath) {
         return describedAs("has json path %0",
-                hasJsonPath(jsonPath, not(nullValue())),
+                isJson(withJsonPath(jsonPath)),
                 jsonPath);
     }
 
@@ -53,7 +53,7 @@ public class JsonPathMatchers {
 
     public static Matcher<? super ReadContext> withJsonPath(JsonPath jsonPath) {
         return describedAs("with json path %0",
-                withJsonPath(jsonPath, not(nullValue())),
+                withJsonPath(jsonPath, anything()),
                 jsonPath.getPath());
     }
 

json-path-assert/src/main/java/com/jayway/jsonpath/matchers/WithoutJsonPath.java

@@ -6,8 +6,6 @@ import com.jayway.jsonpath.ReadContext;
 import org.hamcrest.Description;
 import org.hamcrest.TypeSafeDiagnosingMatcher;
 
-import static org.hamcrest.Matchers.empty;
-
 public class WithoutJsonPath extends TypeSafeDiagnosingMatcher<ReadContext> {
     private final JsonPath jsonPath;
 
@@ -23,7 +21,7 @@ public class WithoutJsonPath extends TypeSafeDiagnosingMatcher<ReadContext> {
                     .appendText(jsonPath.getPath())
                     .appendText(" was evaluated to ")
                     .appendValue(value);
-            return value == null || empty().matches(value);
+            return false;
         } catch (JsonPathException e) {
             return true;
         }

json-path-assert/src/test/java/com/jayway/jsonpath/matchers/HasNoJsonPathTest.java

@@ -0,0 +1,30 @@
+package com.jayway.jsonpath.matchers;
+
+import org.junit.Test;
+
+import static com.jayway.jsonpath.matchers.JsonPathMatchers.hasNoJsonPath;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.assertThat;
+
+public class HasNoJsonPathTest {
+    private static final String JSON_STRING = "{" +
+            "\"name\": \"Jessie\"" +
+            "}";
+
+    @Test
+    public void shouldMatchMissingJsonPath() {
+        assertThat(JSON_STRING, hasNoJsonPath("$.not_there"));
+    }
+
+    @Test
+    public void shouldNotMatchExistingJsonPath() {
+        assertThat(JSON_STRING, not(hasNoJsonPath("$.name")));
+    }
+
+    @Test
+    public void shouldBeDescriptive() {
+        assertThat(hasNoJsonPath("$.name"),
+                hasToString(equalTo("is json without json path \"$['name']\"")));
+    }
+
+}

json-path-assert/src/test/java/com/jayway/jsonpath/matchers/IsJsonTest.java

@@ -20,8 +20,11 @@ import static org.hamcrest.Matchers.*;
 import static org.junit.Assert.assertThat;
 
 public class IsJsonTest {
+    private static final String VALID_JSON = resource("example.json");
+    private static final String INVALID_JSON = "{ invalid-json }";
     private static final String BOOKS_JSON_STRING = resource("books.json");
     private static final File BOOKS_JSON_FILE = resourceAsFile("books.json");
+    private static final Object BOOKS_JSON_PARSED = parseJson(BOOKS_JSON_STRING);
 
     @BeforeClass
     public static void setupStrictJsonParsing() {
@@ -33,16 +36,52 @@ public class IsJsonTest {
         Configuration.setDefaults(null);
     }
 
+    @Test
+    public void shouldMatchOnEmptyJsonObject() {
+        assertThat("{}", isJson());
+    }
+
+    @Test
+    public void shouldMatchOnJsonObject() {
+        assertThat("{ \"hi\" : \"there\" }", isJson());
+    }
+
+    @Test
+    public void shouldMatchOnEmptyJsonArray() {
+        assertThat("[]", isJson());
+    }
+
+    @Test
+    public void shouldMatchOnJsonArray() {
+        assertThat("[\"hi\", \"there\"]", isJson());
+    }
+
+    @Test
+    public void shouldMatchValidJson() {
+        assertThat(VALID_JSON, isJson());
+        assertThat(BOOKS_JSON_STRING, isJson());
+    }
+
+    @Test
+    public void shouldNotMatchInvalidJson() {
+        assertThat(INVALID_JSON, not(isJson()));
+        assertThat(new Object(), not(isJson()));
+        assertThat(new Object[]{}, not(isJson()));
+        assertThat("hi there", not(isJson()));
+        assertThat(new Integer(42), not(isJson()));
+        assertThat(Boolean.TRUE, not(isJson()));
+        assertThat(false, not(isJson()));
+        assertThat(null, not(isJson()));
+    }
+
     @Test
     public void shouldMatchJsonObjectEvaluatedToTrue() {
-        Object parsedJson = parseJson(BOOKS_JSON_STRING);
+        assertThat(BOOKS_JSON_PARSED, isJson(withPathEvaluatedTo(true)));
-        assertThat(parsedJson, isJson(withPathEvaluatedTo(true)));
     }
 
     @Test
     public void shouldNotMatchJsonObjectEvaluatedToFalse() {
-        Object parsedJson = parseJson(BOOKS_JSON_STRING);
+        assertThat(BOOKS_JSON_PARSED, not(isJson(withPathEvaluatedTo(false))));
-        assertThat(parsedJson, not(isJson(withPathEvaluatedTo(false))));
     }
 
     @Test
@@ -65,6 +104,12 @@ public class IsJsonTest {
         assertThat(BOOKS_JSON_FILE, not(isJson(withPathEvaluatedTo(false))));
     }
 
+    @Test
+    public void shouldNotMatchNonExistingJsonFile() {
+        File nonExistingFile = new File("missing-file");
+        assertThat(nonExistingFile, not(isJson()));
+    }
+
     @Test
     public void shouldBeDescriptive() {
         Matcher<Object> matcher = isJson(withPathEvaluatedTo(true));

json-path-assert/src/test/java/com/jayway/jsonpath/matchers/JsonPathMatchersTest.java

@@ -7,7 +7,8 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.File;
-import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 
 import static com.jayway.jsonpath.matchers.JsonPathMatchers.*;
 import static com.jayway.jsonpath.matchers.helpers.ResourceHelpers.resource;
@@ -16,8 +17,6 @@ import static org.hamcrest.Matchers.*;
 import static org.junit.Assert.assertThat;
 
 public class JsonPathMatchersTest {
-
-    private static final String VALID_JSON = resource("example.json");
     private static final String BOOKS_JSON = resource("books.json");
     private static final String INVALID_JSON = "{ invalid-json }";
     private static final File BOOKS_JSON_FILE = resourceAsFile("books.json");
@@ -34,139 +33,164 @@ public class JsonPathMatchersTest {
     }
 
     @Test
-    public void shouldMatchOnEmptyJsonObject() {
+    public void shouldMatchJsonPathToStringValue() {
-        assertThat("{}", isJson());
+        final String json = "{\"name\": \"Jessie\"}";
-    }
 
-    @Test
+        assertThat(json, hasJsonPath("$.name"));
-    public void shouldMatchOnJsonObject() {
+        assertThat(json, isJson(withJsonPath("$.name")));
-        assertThat("{ \"hi\" : \"there\" }", isJson());
+        assertThat(json, hasJsonPath("$.name", equalTo("Jessie")));
+        assertThat(json, isJson(withJsonPath("$.name", equalTo("Jessie"))));
+
+        assertThat(json, not(hasJsonPath("$.name", equalTo("John"))));
+        assertThat(json, not(isJson(withJsonPath("$.name", equalTo("John")))));
     }
 
     @Test
-    public void shouldMatchOnEmptyJsonArray() {
+    public void shouldMatchJsonPathToIntegerValue() {
-        assertThat("[]", isJson());
+        final String json = "{\"number\": 10}";
+
+        assertThat(json, hasJsonPath("$.number"));
+        assertThat(json, isJson(withJsonPath("$.number")));
+        assertThat(json, hasJsonPath("$.number", equalTo(10)));
+        assertThat(json, isJson(withJsonPath("$.number", equalTo(10))));
+
+        assertThat(json, not(hasJsonPath("$.number", equalTo(3))));
+        assertThat(json, not(isJson(withJsonPath("$.number", equalTo(3)))));
     }
 
     @Test
-    public void shouldMatchOnJsonArray() {
+    public void shouldMatchJsonPathToDoubleValue() {
-        assertThat("[\"hi\", \"there\"]", isJson());
+        final String json = "{\"price\": 19.95}";
+
+        assertThat(json, hasJsonPath("$.price"));
+        assertThat(json, isJson(withJsonPath("$.price")));
+        assertThat(json, hasJsonPath("$.price", equalTo(19.95)));
+        assertThat(json, isJson(withJsonPath("$.price", equalTo(19.95))));
+
+        assertThat(json, not(hasJsonPath("$.price", equalTo(3.3))));
+        assertThat(json, not(isJson(withJsonPath("$.price", equalTo(42)))));
     }
 
     @Test
-    public void shouldMatchValidJson() {
+    public void shouldMatchJsonPathToBooleanValue() {
-        assertThat(VALID_JSON, isJson());
+        final String json = "{\"flag\": false}";
-        assertThat(BOOKS_JSON, isJson());
+
+        assertThat(json, hasJsonPath("$.flag"));
+        assertThat(json, isJson(withJsonPath("$.flag")));
+        assertThat(json, hasJsonPath("$.flag", equalTo(false)));
+        assertThat(json, isJson(withJsonPath("$.flag", equalTo(false))));
+
+        assertThat(json, not(hasJsonPath("$.flag", equalTo(true))));
+        assertThat(json, not(isJson(withJsonPath("$.flag", equalTo(true)))));
     }
 
     @Test
-    public void shouldNotMatchInvalidJson() {
+    public void shouldMatchJsonPathToJsonObject() {
-        assertThat(INVALID_JSON, not(isJson()));
+        final String json = "{\"object\": { \"name\":\"Oscar\"}}";
-        assertThat(new Object(), not(isJson()));
+
-        assertThat(new Object[]{}, not(isJson()));
+        assertThat(json, hasJsonPath("$.object"));
-        assertThat("hi there", not(isJson()));
+        assertThat(json, isJson(withJsonPath("$.object")));
-        assertThat(new Integer(42), not(isJson()));
+        assertThat(json, hasJsonPath("$.object", instanceOf(Map.class)));
-        assertThat(Boolean.TRUE, not(isJson()));
+        assertThat(json, isJson(withJsonPath("$.object", instanceOf(Map.class))));
-        assertThat(false, not(isJson()));
+
-        assertThat(null, not(isJson()));
+        assertThat(json, not(hasJsonPath("$.object", instanceOf(List.class))));
+        assertThat(json, not(isJson(withJsonPath("$.object", instanceOf(List.class)))));
     }
 
     @Test
-    public void shouldMatchExistingJsonPath() {
+    public void shouldMatchJsonPathToEmptyJsonObject() {
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.name"));        // string
+        final String json = "{\"empty_object\": {}}";
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.switch"));      // boolean
+
-        assertThat(BOOKS_JSON, hasJsonPath("$.expensive"));         // number
+        assertThat(json, hasJsonPath("$.empty_object"));
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.bicycle"));     // object
+        assertThat(json, isJson(withJsonPath("$.empty_object")));
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.truck"));       // empty object
+        assertThat(json, hasJsonPath("$.empty_object", instanceOf(Map.class)));
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.book"));        // non-empty array
+        assertThat(json, isJson(withJsonPath("$.empty_object", instanceOf(Map.class))));
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.book[*]"));     // non-empty array
+
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.magazine"));    // empty array
+        assertThat(json, not(hasJsonPath("$.empty_object", instanceOf(List.class))));
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.magazine[*]")); // empty array
+        assertThat(json, not(isJson(withJsonPath("$.empty_object", instanceOf(List.class)))));
     }
 
     @Test
-    public void shouldMatchExistingJsonPathAlternative() {
+    public void shouldMatchJsonPathToJsonArray() {
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.store.name")));        // string
+        final String json = "{\"list\": [ \"one\",\"two\",\"three\"]}";
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.store.switch")));      // boolean
+
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.expensive")));         // number
+        assertThat(json, hasJsonPath("$.list"));
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.store.bicycle")));     // object
+        assertThat(json, hasJsonPath("$.list[*]"));
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.store.truck")));       // empty object
+        assertThat(json, isJson(withJsonPath("$.list")));
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.store.book")));        // non-empty array
+        assertThat(json, isJson(withJsonPath("$.list[*]")));
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.store.book[*]")));     // non-empty array
+        assertThat(json, hasJsonPath("$.list", contains("one", "two", "three")));
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.store.magazine")));    // empty array
+        assertThat(json, isJson(withJsonPath("$.list", hasItem("two"))));
-        assertThat(BOOKS_JSON, isJson(withJsonPath("$.store.magazine[*]"))); // empty array
+
+        assertThat(json, not(hasJsonPath("$.list", hasSize(2))));
+        assertThat(json, not(isJson(withJsonPath("$.list", contains("four")))));
     }
 
     @Test
-    public void shouldNotMatchNonExistentArrays() {
+    public void shouldMatchJsonPathToEmptyJsonArray() {
-        assertThat(BOOKS_JSON, not(hasJsonPath("$.store.not_here[*]")));
+        final String json = "{\"empty_list\": []}";
+
+        assertThat(json, hasJsonPath("$.empty_list"));
+        assertThat(json, hasJsonPath("$.empty_list[*]"));
+        assertThat(json, isJson(withJsonPath("$.empty_list")));
+        assertThat(json, isJson(withJsonPath("$.empty_list[*]")));
+        assertThat(json, hasJsonPath("$.empty_list", empty()));
+        assertThat(json, isJson(withJsonPath("$.empty_list", hasSize(0))));
+
+        assertThat(json, not(hasJsonPath("$.empty_list", hasSize(2))));
+        assertThat(json, not(isJson(withJsonPath("$.empty_list", contains("four")))));
     }
 
     @Test
     public void willMatchIndefiniteJsonPathsEvaluatedToEmptyLists() {
-        // This is just a test to demonstrate that wildcard paths
+        // This is just a test to demonstrate that indefinite paths
         // will always match, regardless of result. This is because
-        // the evaluation of these expressions will at least return
+        // the evaluation of these expressions will return lists,
-        // an empty list.
+        // even though they may be empty.
         String json = "{\"items\": []}";
-        assertThat(json, hasJsonPath("$.items[*]"));
         assertThat(json, hasJsonPath("$.items[*].name"));
+        assertThat(json, hasJsonPath("$.items[*]"));
         assertThat(json, hasJsonPath("$.items[*]", hasSize(0)));
     }
 
     @Test
-    public void shouldNotMatchInvalidJsonWithPath() {
+    public void shouldMatchJsonPathToNullValue() {
-        assertThat(INVALID_JSON, not(hasJsonPath("$.path")));
+        final String json = "{\"none\": null}";
-        assertThat(new Object(), not(hasJsonPath("$.path")));
-        assertThat("{}", not(hasJsonPath("$.path")));
-        assertThat(null, not(hasJsonPath("$.path")));
-    }
 
-    @Test
+        assertThat(json, hasJsonPath("$.none"));
-    public void shouldNotMatchInvalidJsonWithPathAndValue() {
+        assertThat(json, isJson(withJsonPath("$.none")));
-        assertThat(INVALID_JSON, not(hasJsonPath("$.path", anything())));
+        assertThat(json, hasJsonPath("$.none", nullValue()));
-        assertThat(new Object(), not(hasJsonPath("$.path", anything())));
+        assertThat(json, isJson(withJsonPath("$.none", nullValue())));
-        assertThat(null, not(hasJsonPath("$.message", anything())));
-    }
 
-    @Test
+        assertThat(json, not(hasJsonPath("$.none", equalTo("something"))));
-    public void shouldNotMatchNonExistingJsonPath() {
+        assertThat(json, not(isJson(withJsonPath("$.none", empty()))));
-        assertThat(BOOKS_JSON, not(hasJsonPath("$.not_there")));
-        assertThat(BOOKS_JSON, not(hasJsonPath("$.store.not_there")));
-        assertThat(BOOKS_JSON, not(hasJsonPath("$.store.book[1].isbn")));
-        assertThat(BOOKS_JSON, not(hasJsonPath("$.store.book[5].title")));
     }
 
     @Test
-    public void shouldNotMatchNonExistingJsonPathAlternative() {
+    public void shouldNotMatchNonExistingJsonPath() {
-        assertThat(BOOKS_JSON, not(isJson(withJsonPath("$.not_there"))));
+        final String json = "{}";
-        assertThat(BOOKS_JSON, not(isJson(withJsonPath(("$.store.not_there")))));
-        assertThat(BOOKS_JSON, not(isJson(withJsonPath(("$.store.book[1].isbn")))));
-        assertThat(BOOKS_JSON, not(isJson(withJsonPath("$.store.book[5].title"))));
-    }
-
-    @Test
-    public void shouldMatchJsonPathWithStringValue() {
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.name", equalTo("Little Shop")));
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.book[2].title", equalTo("Moby Dick")));
-    }
 
-    @Test
+        assertThat(json, not(hasJsonPath("$.not_there")));
-    public void shouldMatchJsonPathWithIntegerValue() {
+        assertThat(json, not(hasJsonPath("$.not_there", anything())));
-        assertThat(BOOKS_JSON, hasJsonPath("$.expensive", equalTo(10)));
+        assertThat(json, not(hasJsonPath("$.not_there[*]")));
+        assertThat(json, not(hasJsonPath("$.not_there[*]", anything())));
+        assertThat(json, not(isJson(withJsonPath("$.not_there"))));
+        assertThat(json, not(isJson(withJsonPath("$.not_there", anything()))));
+        assertThat(json, not(isJson(withJsonPath("$.not_there[*]"))));
+        assertThat(json, not(isJson(withJsonPath("$.not_there[*]", anything()))));
     }
 
     @Test
-    public void shouldMatchJsonPathWithDoubleValue() {
+    public void shouldNotMatchInvalidJsonWithPath() {
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.bicycle.price", equalTo(19.95)));
+        assertThat(INVALID_JSON, not(hasJsonPath("$.path")));
+        assertThat(new Object(), not(hasJsonPath("$.path")));
+        assertThat(null, not(hasJsonPath("$.path")));
     }
 
     @Test
-    public void shouldMatchJsonPathWithCollectionValue() {
+    public void shouldNotMatchInvalidJsonWithPathAndValue() {
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.book[*].author", instanceOf(Collection.class)));
+        assertThat(INVALID_JSON, not(hasJsonPath("$.path", anything())));
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.book[*].author", hasSize(4)));
+        assertThat(new Object(), not(hasJsonPath("$.path", anything())));
-        assertThat(BOOKS_JSON, hasJsonPath("$.store.book[*].author", hasItem("Evelyn Waugh")));
+        assertThat(null, not(hasJsonPath("$.message", anything())));
-        assertThat(BOOKS_JSON, hasJsonPath("$..book[2].title", hasItem("Moby Dick")));
     }
 
     @Test
@@ -185,14 +209,4 @@ public class JsonPathMatchersTest {
         Object json = Configuration.defaultConfiguration().jsonProvider().parse(BOOKS_JSON);
         assertThat(json, hasJsonPath("$.store.name", equalTo("Little Shop")));
     }
-
-    @Test
-    public void shouldMatchMissingJsonPath() {
-        assertThat(BOOKS_JSON, hasNoJsonPath("$.not_there"));
-    }
-
-    @Test
-    public void shouldNotMatchExistingJsonPath() {
-        assertThat(BOOKS_JSON, not(hasNoJsonPath("$.store.name")));
-    }
 }

json-path-assert/src/test/java/com/jayway/jsonpath/matchers/WithJsonPathTest.java

@@ -13,7 +13,6 @@ import java.util.List;
 
 import static com.jayway.jsonpath.JsonPath.compile;
 import static com.jayway.jsonpath.matchers.JsonPathMatchers.withJsonPath;
-import static com.jayway.jsonpath.matchers.JsonPathMatchers.withoutJsonPath;
 import static com.jayway.jsonpath.matchers.helpers.ResourceHelpers.resource;
 import static org.hamcrest.Matchers.*;
 import static org.junit.Assert.assertThat;
@@ -51,26 +50,6 @@ public class WithJsonPathTest {
         assertThat(BOOKS_JSON, not(withJsonPath("$.store.book[1].not_there")));
     }
 
-    @Test
-    public void shouldMatchNonExistingJsonPath() {
-        assertThat(BOOKS_JSON, withoutJsonPath(compile("$.not_there")));
-    }
-
-    @Test
-    public void shouldMatchNonExistingStringJsonPath() {
-        assertThat(BOOKS_JSON, withoutJsonPath("$.not_there"));
-    }
-
-    @Test
-    public void shouldNotMatchExistingCompiledJsonPath() {
-        assertThat(BOOKS_JSON, not(withoutJsonPath(compile("$.store.name"))));
-    }
-
-    @Test
-    public void shouldNotMatchExistingStringJsonPath() {
-        assertThat(BOOKS_JSON, not(withoutJsonPath("$.store.name")));
-    }
-
     @Test
     public void shouldMatchJsonPathEvaluatedToStringValue() {
         assertThat(BOOKS_JSON, withJsonPath(compile("$.store.bicycle.color"), equalTo("red")));

json-path-assert/src/test/java/com/jayway/jsonpath/matchers/WithoutJsonPathTest.java

@@ -0,0 +1,44 @@
+package com.jayway.jsonpath.matchers;
+
+import com.jayway.jsonpath.JsonPath;
+import com.jayway.jsonpath.ReadContext;
+import org.junit.Test;
+
+import static com.jayway.jsonpath.JsonPath.compile;
+import static com.jayway.jsonpath.matchers.JsonPathMatchers.withoutJsonPath;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.assertThat;
+
+public class WithoutJsonPathTest {
+    private static final String JSON_STRING = "{" +
+            "\"name\": \"Jessie\"," +
+            "\"flag\": false," +
+            "\"empty_array\": []," +
+            "\"empty_object\": {}," +
+            "\"none\": null" +
+            "}";
+    private static final ReadContext JSON = JsonPath.parse(JSON_STRING);
+
+    @Test
+    public void shouldMatchNonExistingJsonPath() {
+        assertThat(JSON, withoutJsonPath(compile("$.not_there")));
+        assertThat(JSON, withoutJsonPath("$.not_there"));
+    }
+
+    @Test
+    public void shouldNotMatchExistingJsonPath() {
+        assertThat(JSON, not(withoutJsonPath(compile("$.name"))));
+        assertThat(JSON, not(withoutJsonPath("$.name")));
+        assertThat(JSON, not(withoutJsonPath("$.flag")));
+        assertThat(JSON, not(withoutJsonPath("$.empty_array")));
+        assertThat(JSON, not(withoutJsonPath("$.empty_object")));
+        assertThat(JSON, not(withoutJsonPath("$.none")));
+    }
+
+    @Test
+    public void shouldBeDescriptive() {
+        assertThat(withoutJsonPath("$.name"),
+                hasToString(equalTo("without json path \"$['name']\"")));
+    }
+
+}

json-path-assert/src/test/resources/books.json

@@ -1,6 +1,7 @@
 {
   "store": {
     "name": "Little Shop",
+    "none": null,
     "switch": true,
     "magazine": [],
     "truck": {},