diff --git a/json-p/merge/pom.xml b/json-p/merge/pom.xml new file mode 100644 index 0000000..b3c7cbc --- /dev/null +++ b/json-p/merge/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + org.javaee8 + json-p + 1.0-SNAPSHOT + + org.javaee8.jsonp + merge + jar + Java EE 8 Samples: JSON-P - Merge + \ No newline at end of file diff --git a/json-p/merge/src/test/java/org/javaee8/jsonp/merge/JsonpMergeTest.java b/json-p/merge/src/test/java/org/javaee8/jsonp/merge/JsonpMergeTest.java new file mode 100644 index 0000000..ba1660b --- /dev/null +++ b/json-p/merge/src/test/java/org/javaee8/jsonp/merge/JsonpMergeTest.java @@ -0,0 +1,177 @@ +package org.javaee8.jsonp.merge; + +import javax.json.Json; +import javax.json.JsonMergePatch; +import javax.json.JsonObject; +import javax.json.JsonValue; +import org.jboss.arquillian.container.test.api.Deployment; +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import static org.junit.Assert.assertTrue; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * Class that tests and demonstrates the JSON-P 1.1 Merge Operations. + * @author Andrew Pielage + */ +@RunWith(Arquillian.class) +public class JsonpMergeTest { + + // Create a JsonObject with some values to be used in each test + private static final JsonObject json = Json.createObjectBuilder() + .add("Wibbly", "Wobbly") + .add("Replaced", false) + .add("Lexicon", Json.createArrayBuilder() + .add("Wibbles") + .add("Wobbles") + .build()) + .add("Nested", Json.createObjectBuilder() + .add("Birdie", "Wordie") + .add("Bestiary", Json.createArrayBuilder() + .add("Drowner") + .add("Werewolf") + .add("Chimera") + .build()) + .build()) + .build(); + + @Deployment + public static JavaArchive createDeployment() { + // Create a JavaArchive to deploy + JavaArchive jar = ShrinkWrap.create(JavaArchive.class); + + // Print out directory contents + System.out.println(jar.toString(true)); + + // Return Arquillian Test Archive for application server + return jar; + } + + /** + * Test that the JSON Merge operation replaces values as intended. + */ + @Test + public void replaceTest() { + // Create a JSON object that we'll merge into the class variable, replacing object members and array values + JsonObject jsonToMerge = Json.createObjectBuilder() + .add("Wibbly", "Bibbly") + .add("Replaced", "Yes") + .add("Lexicon", Json.createArrayBuilder() + .add("Wibbles") + .add("Bibbles") + .build()) + .add("Nested", Json.createObjectBuilder() + .add("Bestiary", Json.createArrayBuilder() + .add("Slyzard") + .add("Dragon") + .add("Ekimmara") + .build()) + .build()) + .build(); + + // Create a merge patch and apply it + JsonMergePatch mergePatch = Json.createMergePatch(jsonToMerge); + JsonValue mergedJson = mergePatch.apply(json); + + // Print out to more easily see what we've done + System.out.println("JsonpMergeTest.replaceTest: Before Merge: " + json); + System.out.println("JsonpMergeTest.replaceTest: JSON to Merge: " + jsonToMerge); + System.out.println("JsonpMergeTest.replaceTest: After Merge: " + mergedJson); + + // Test that everything is as it should be + JsonObject mergedJsonObject = mergedJson.asJsonObject(); + assertTrue("Merged JSON didn't merge correctly!", mergedJsonObject.getString("Wibbly").equals("Bibbly")); + assertTrue("Merged JSON didn't merge correctly!", mergedJsonObject.getString("Replaced").equals("Yes")); + assertTrue("JSON Array didn't merge correctly!", + mergedJsonObject.getJsonArray("Lexicon").getString(0).equals("Wibbles") + && mergedJsonObject.getJsonArray("Lexicon").getString(1).equals("Bibbles")); + assertTrue("Nested JSON didn't merge correctly!", + mergedJsonObject.getJsonObject("Nested").getString("Birdie").equals("Wordie")); + assertTrue("Nested JSON Array didn't merge correctly!", + mergedJsonObject.getJsonObject("Nested").getJsonArray("Bestiary").getString(0).equals("Slyzard") + && mergedJsonObject.getJsonObject("Nested").getJsonArray("Bestiary").getString(1).equals("Dragon") + && mergedJsonObject.getJsonObject("Nested").getJsonArray("Bestiary").getString(2).equals("Ekimmara")); + } + + /** + * Test that the JSON Merge operation adds values as intended. + */ + @Test + public void addTest() { + // Create a JSON object that we'll merge into the class variable, adding object members and array values + JsonObject jsonToMerge = Json.createObjectBuilder() + .add("Bibbly", "Bobbly") + .add("Lexicon", Json.createArrayBuilder() + .add("Wibbles") + .add("Wobbles") + .add("Bibbles") + .add("Bobbles") + .build()) + .build(); + + // Create a merge patch and apply it + JsonMergePatch mergePatch = Json.createMergePatch(jsonToMerge); + JsonValue mergedJson = mergePatch.apply(json); + + // Print out to more easily see what we've done + System.out.println("JsonpMergeTest.addTest: Before Merge: " + json); + System.out.println("JsonpMergeTest.addTest: JSON to Merge: " + jsonToMerge); + System.out.println("JsonpMergeTest.addTest: After Merge: " + mergedJson); + + // Test that everything is as it should be + JsonObject mergedJsonObject = mergedJson.asJsonObject(); + assertTrue("Merged JSON didn't merge correctly!", mergedJsonObject.getString("Wibbly").equals("Wobbly")); + assertTrue("Merged JSON didn't merge correctly!", mergedJsonObject.getString("Bibbly").equals("Bobbly")); + assertTrue("Merged JSON didn't merge correctly!", !mergedJsonObject.getBoolean("Replaced")); + assertTrue("JSON Array didn't merge correctly!", + mergedJsonObject.getJsonArray("Lexicon").getString(0).equals("Wibbles") + && mergedJsonObject.getJsonArray("Lexicon").getString(1).equals("Wobbles") + && mergedJsonObject.getJsonArray("Lexicon").getString(2).equals("Bibbles") + && mergedJsonObject.getJsonArray("Lexicon").getString(3).equals("Bobbles")); + assertTrue("Nested JSON didn't merge correctly!", + mergedJsonObject.getJsonObject("Nested").getString("Birdie").equals("Wordie")); + assertTrue("Nested JSON Array didn't merge correctly!", + mergedJsonObject.getJsonObject("Nested").getJsonArray("Bestiary").getString(0).equals("Drowner") + && mergedJsonObject.getJsonObject("Nested").getJsonArray("Bestiary").getString(1).equals("Werewolf") + && mergedJsonObject.getJsonObject("Nested").getJsonArray("Bestiary").getString(2).equals("Chimera")); + } + + /** + * Test that the JSON Merge operation removes values as intended. + */ + @Test + public void removeTest() { + // Create a JSON object that we'll merge into the class variable, removing object members and array values + JsonObject jsonToMerge = Json.createObjectBuilder() + .addNull("Wibbly") + .add("Lexicon", Json.createArrayBuilder() + .add("Wibbles") + .build()) + .add("Nested", Json.createObjectBuilder() + .addNull("Bestiary") + .build()) + .build(); + + // Create a merge patch and apply it + JsonMergePatch mergePatch = Json.createMergePatch(jsonToMerge); + JsonValue mergedJson = mergePatch.apply(json); + + // Print out to more easily see what we've done + System.out.println("JsonpMergeTest.removeTest: Before Merge: " + json); + System.out.println("JsonpMergeTest.removeTest: JSON to Merge: " + jsonToMerge); + System.out.println("JsonpMergeTest.removeTest: After Merge: " + mergedJson); + + // Test that everything is as it should be + JsonObject mergedJsonObject = mergedJson.asJsonObject(); + assertTrue("Merged JSON didn't merge correctly!", !mergedJsonObject.containsKey("Wibbly")); + assertTrue("Merged JSON didn't merge correctly!", !mergedJsonObject.getBoolean("Replaced")); + assertTrue("JSON Array didn't merge correctly!", + mergedJsonObject.getJsonArray("Lexicon").getString(0).equals("Wibbles")); + assertTrue("Nested JSON didn't merge correctly!", + mergedJsonObject.getJsonObject("Nested").getString("Birdie").equals("Wordie")); + assertTrue("Nested JSON Array didn't merge correctly!", + !mergedJsonObject.getJsonObject("Nested").containsKey("Bestiary")); + } +} diff --git a/json-p/patch/pom.xml b/json-p/patch/pom.xml new file mode 100644 index 0000000..3e131c8 --- /dev/null +++ b/json-p/patch/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + org.javaee8 + json-p + 1.0-SNAPSHOT + + org.javaee8.jsonp + patch + jar + Java EE 8 Samples: JSON-P - Patch + \ No newline at end of file diff --git a/json-p/patch/src/test/java/org/javaee8/jsonp/patch/JsonpPatchTest.java b/json-p/patch/src/test/java/org/javaee8/jsonp/patch/JsonpPatchTest.java new file mode 100644 index 0000000..3acf085 --- /dev/null +++ b/json-p/patch/src/test/java/org/javaee8/jsonp/patch/JsonpPatchTest.java @@ -0,0 +1,219 @@ +package org.javaee8.jsonp.patch; + +import javax.json.Json; +import javax.json.JsonException; +import javax.json.JsonObject; +import javax.json.JsonPatch; +import org.jboss.arquillian.container.test.api.Deployment; +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import org.junit.Assert; +import static org.junit.Assert.assertTrue; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * Class that tests and demonstrates the JSON-P 1.1 Patch Operations. + * @author Andrew Pielage + */ +@RunWith(Arquillian.class) +public class JsonpPatchTest { + + // Create a JsonObject with some values to be used in each test + private static final JsonObject json = Json.createObjectBuilder() + .add("Wibbly", "Wobbly") + .add("Replaced", false) + .add("Lexicon", Json.createArrayBuilder() + .add("Wibbles") + .add("Wobbles") + .build()) + .add("Nested", Json.createObjectBuilder() + .add("Birdie", "Wordie") + .add("Bestiary", Json.createArrayBuilder() + .add("Drowner") + .add("Werewolf") + .add("Chimera") + .build()) + .build()) + .build(); + + @Deployment + public static JavaArchive createDeployment() { + // Create a JavaArchive to deploy + JavaArchive jar = ShrinkWrap.create(JavaArchive.class); + + // Print out directory contents + System.out.println(jar.toString(true)); + + // Return Arquillian Test Archive for application server + return jar; + } + + /** + * Test that the JSON Patch add operation works as intended. + */ + @Test + public void addTest() { + // Create a patch that adds some object members, replaces the value of an already existing object member, and + // adds some extra elements to an array + JsonPatch patch = Json.createPatchBuilder() + .add("/Timey", "Wimey") + .add("/Replaced", true) + .add("/FunnyReference", true) + .add("/FunScore", 100) + .add("/Lexicon/2", "Toddles") + .add("/Lexicon/2", "Tiddles") + .build(); + + // Apply the patch + JsonObject patchedJson = patch.apply(json); + + // Print out to more easily see what we've done + System.out.println("JsonpPatchTest.addTest: Before Patch: " + json); + System.out.println("JsonpPatchTest.addTest: After Patch: " + patchedJson); + + // Test that everything is as it should be + assertTrue("Patched JSON doesn't match!", patchedJson.getString("Wibbly").equals("Wobbly")); + assertTrue("Patched JSON doesn't match!", patchedJson.getString("Timey").equals("Wimey")); + assertTrue("Patched JSON doesn't match!", patchedJson.getBoolean("FunnyReference")); + assertTrue("Patched JSON doesn't match!", patchedJson.getInt("FunScore") == 100); + assertTrue("Patched JSON doesn't match!", patchedJson.getBoolean("Replaced")); + assertTrue("Patched JSON doesn't match!", patchedJson.getJsonArray("Lexicon").getString(0) + .equals("Wibbles")); + assertTrue("Patched JSON doesn't match!", patchedJson.getJsonArray("Lexicon").getString(1) + .equals("Wobbles")); + assertTrue("Patched JSON doesn't match!", patchedJson.getJsonArray("Lexicon").getString(2) + .equals("Tiddles")); + assertTrue("Patched JSON doesn't match!", patchedJson.getJsonArray("Lexicon").getString(3) + .equals("Toddles")); + } + + /** + * Test that the JSON Patch remove operation works as intended. + */ + @Test + public void removeTest() { + // Create a patch that removes an object member and an array element + JsonPatch patch = Json.createPatchBuilder() + .remove("/Replaced") + .remove("/Lexicon/1") + .build(); + + // Apply the patch + JsonObject patchedJson = patch.apply(json); + + // Print out to more easily see what we've done + System.out.println("JsonpPatchTest.removeTest: Before Patch: " + json); + System.out.println("JsonpPatchTest.removeTest: After Patch: " + patchedJson); + + assertTrue("Patched JSON still contains object member!", !patchedJson.containsKey("Replaced")); + assertTrue("Patched JSON still contains object member!", ((patchedJson.getJsonArray("Lexicon").size() == 1) + && (patchedJson.getJsonArray("Lexicon").getString(0).equals("Wibbles")))); + } + + /** + * Test that the JSON Patch replace operation works as intended. + */ + @Test + public void replaceTest() { + // Create a patch that replaces an object member and an array element + JsonPatch patch = Json.createPatchBuilder() + .replace("/Replaced", true) + .replace("/Lexicon/0", "Tiddles") + .replace("/Lexicon/1", "Toddles") + .build(); + + // Apply the patch + JsonObject patchedJson = patch.apply(json); + + // Print out to more easily see what we've done + System.out.println("JsonpPatchTest.replaceTest: Before Patch: " + json); + System.out.println("JsonpPatchTest.replaceTest: After Patch: " + patchedJson); + + assertTrue("Patched JSON still contains original value!", patchedJson.getBoolean("Replaced")); + assertTrue("Patched JSON still contains original values!", + ((patchedJson.getJsonArray("Lexicon").getString(0).equals("Tiddles")) + && (patchedJson.getJsonArray("Lexicon").getString(1).equals("Toddles")))); + } + + /** + * Test that the JSON Patch move operation works as intended. + */ + @Test + public void moveTest() { + // Create a patch that moves an object member, moves an array element, and reorders an array + JsonPatch patch = Json.createPatchBuilder() + .move("/Nested/Tibbly", "/Wibbly") + .move("/Nested/Bestiary/2", "/Lexicon/1") + .move("/Nested/Bestiary/3", "/Nested/Bestiary/0") + .build(); + + // Apply the patch + JsonObject patchedJson = patch.apply(json); + + // Print out to more easily see what we've done + System.out.println("JsonpPatchTest.moveTest: Before Patch: " + json); + System.out.println("JsonpPatchTest.moveTest: After Patch: " + patchedJson); + + assertTrue("Patched JSON hasn't moved value!", (!patchedJson.containsKey("Wibbly") + && patchedJson.getJsonObject("Nested").getString("Tibbly").equals("Wobbly"))); + assertTrue("Patched JSON hasn't moved value!", ((patchedJson.getJsonArray("Lexicon").size() == 1)) + && (patchedJson.getJsonObject("Nested").getJsonArray("Bestiary").getString(2).equals("Chimera")) + && (patchedJson.getJsonObject("Nested").getJsonArray("Bestiary").getString(0).equals("Werewolf"))); + } + + /** + * Test that the JSON Patch copy operation works as intended. + */ + @Test + public void copyTest() { + // Create a patch that copies an object member and an array element + JsonPatch patch = Json.createPatchBuilder() + .copy("/Nested/Tobbly", "/Wibbly") + .copy("/Nested/Bestiary/2", "/Lexicon/0") + .build(); + + // Apply the patch + JsonObject patchedJson = patch.apply(json); + + // Print out to more easily see what we've done + System.out.println("JsonpPatchTest.copyTest: Before Patch: " + json); + System.out.println("JsonpPatchTest.copyTest: After Patch: " + patchedJson); + + assertTrue("Patched JSON hasn't moved value!", (patchedJson.containsKey("Wibbly") + && patchedJson.getJsonObject("Nested").getString("Tobbly").equals("Wobbly"))); + assertTrue("Patched JSON hasn't moved value!", ((patchedJson.getJsonArray("Lexicon").size() == 2)) + && (patchedJson.getJsonObject("Nested").getJsonArray("Bestiary").getString(2).equals("Wibbles"))); + } + + /** + * Test that the JSON Patch test operation works as intended. + */ + @Test + public void testTest() { + // Create a patch that should test positive + JsonPatch patch = Json.createPatchBuilder() + .test("/Wibbly", "Wobbly") + .test("/Lexicon/0", "Wibbles") + .build(); + + // Apply the patch + JsonObject patchedJson = patch.apply(json); + + // Create a patch that should fail + patch = Json.createPatchBuilder() + .test("/Wibbly", "Tobbly") + .build(); + + try { + patchedJson = patch.apply(json); + } catch (JsonException ex) { + return; + } + + Assert.fail("Should have caught a JsonException and exited!"); + } + + // TODO: Ignore unrecognised elements; Adding to a non-existent target; Adding a nested member object; Error Handling +} diff --git a/json-p/pointer/pom.xml b/json-p/pointer/pom.xml new file mode 100644 index 0000000..d90b97e --- /dev/null +++ b/json-p/pointer/pom.xml @@ -0,0 +1,13 @@ + + + 4.0.0 + + org.javaee8 + json-p + 1.0-SNAPSHOT + + org.javaee8.jsonp + pointer + jar + Java EE 8 Samples: JSON-P - Pointer + \ No newline at end of file diff --git a/json-p/pointer/src/test/java/org/javaee8/jsonp/pointer/JsonpPointerTest.java b/json-p/pointer/src/test/java/org/javaee8/jsonp/pointer/JsonpPointerTest.java new file mode 100644 index 0000000..20377bf --- /dev/null +++ b/json-p/pointer/src/test/java/org/javaee8/jsonp/pointer/JsonpPointerTest.java @@ -0,0 +1,169 @@ +package org.javaee8.jsonp.pointer; + +import java.math.BigDecimal; +import javax.json.Json; +import javax.json.JsonMergePatch; +import javax.json.JsonObject; +import javax.json.JsonPointer; +import javax.json.JsonValue; +import org.jboss.arquillian.container.test.api.Deployment; +import org.jboss.arquillian.junit.Arquillian; +import org.jboss.shrinkwrap.api.ShrinkWrap; +import org.jboss.shrinkwrap.api.spec.JavaArchive; +import static org.junit.Assert.assertTrue; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * Class that tests and demonstrates the JSON-P 1.1 Pointer Operations. + * @author Andrew Pielage + */ +@RunWith(Arquillian.class) +public class JsonpPointerTest { + + // Create a JsonObject with some values to be used in each test + private static final JsonObject json = Json.createObjectBuilder() + .add("Wibbly", "Wobbly") + .add("Replaced", false) + .add("Lexicon", Json.createArrayBuilder() + .add("Wibbles") + .add("Wobbles") + .build()) + .add("Nested", Json.createObjectBuilder() + .add("Birdie", "Wordie") + .add("Bestiary", Json.createArrayBuilder() + .add("Drowner") + .add("Werewolf") + .add("Chimera") + .build()) + .build()) + .build(); + + @Deployment + public static JavaArchive createDeployment() { + // Create a JavaArchive to deploy + JavaArchive jar = ShrinkWrap.create(JavaArchive.class); + + // Print out directory contents + System.out.println(jar.toString(true)); + + // Return Arquillian Test Archive for application server + return jar; + } + + /** + * Test that the JSON Pointers resolve to the correct values as. + */ + @Test + public void resolveTest() { + // Create pointers + JsonPointer objectPointer = Json.createPointer(""); + JsonPointer objectMemberPointer = Json.createPointer("/Wibbly"); + JsonPointer arrayPointer = Json.createPointer("/Lexicon"); + JsonPointer arrayElementPointer = Json.createPointer("/Lexicon/0"); + JsonPointer nestedObjectPointer = Json.createPointer("/Nested"); + JsonPointer nestedObjectMemberPointer = Json.createPointer("/Nested/Birdie"); + JsonPointer nestedArrayPointer = Json.createPointer("/Nested/Bestiary"); + JsonPointer nestedArrayElementPointer = Json.createPointer("/Nested/Bestiary/1"); + + // Check pointers return the correct values + assertTrue("objectPointer doesn't resolve correctly!", objectPointer.getValue(json).equals(json)); + assertTrue("objectMemberPointer doesn't resolve correctly!", + objectMemberPointer.getValue(json).toString().equals("\"Wobbly\"")); + assertTrue("arrayPointer doesn't resolve correctly!", + arrayPointer.getValue(json).equals(json.getJsonArray("Lexicon"))); + assertTrue("arrayElementPointer doesn't resolve correctly!", + arrayElementPointer.getValue(json).toString().equals("\"Wibbles\"")); + assertTrue("nestedObjectPointer doesn't resolve correctly!", + nestedObjectPointer.getValue(json).equals(json.getJsonObject("Nested"))); + assertTrue("nestedObjectMemberPointer doesn't resolve correctly!", + nestedObjectMemberPointer.getValue(json).toString().equals("\"Wordie\"")); + assertTrue("nestedArrayPointer doesn't resolve correctly!", + nestedArrayPointer.getValue(json).equals(json.getJsonObject("Nested").getJsonArray("Bestiary"))); + assertTrue("nestedArrayElementPointer doesn't resolve correctly!", + nestedArrayElementPointer.getValue(json).toString().equals("\"Werewolf\"")); + + // Check alternative notation + assertTrue("objectMemberPointer doesn't resolve correctly!", json.getValue("/Wibbly").toString().equals("\"Wobbly\"")); + assertTrue("objectMemberPointer doesn't resolve correctly!", + json.getValue("/Nested/Bestiary/2").toString().equals("\"Chimera\"")); + } + + /** + * Test that the JSON Pointer add operation works as expected. + */ + @Test + public void addTest() { + // Create pointers + JsonPointer objectMemberPointer = Json.createPointer("/Giggly"); + JsonPointer arrayElementPointer = Json.createPointer("/Lexicon/0"); + JsonPointer nestedObjectMemberPointer = Json.createPointer("/Nested/Purdie"); + JsonPointer nestedArrayElementPointer = Json.createPointer("/Nested/Bestiary/1"); + + // Perform an add operation on each pointer + JsonObject modifiedJson = objectMemberPointer.add(json, Json.createValue("Goggly")); + modifiedJson = arrayElementPointer.add(modifiedJson, Json.createValue("Giggles")); + modifiedJson = nestedObjectMemberPointer.add(modifiedJson, Json.createValue("Furdie")); + modifiedJson = nestedArrayElementPointer.add(modifiedJson, Json.createValue("Wraith")); + + // Check that they've been added + assertTrue("Object member not added!", modifiedJson.containsKey("Giggly") + && modifiedJson.getString("Giggly").equals("Goggly")); + assertTrue("Array element not added!", modifiedJson.getJsonArray("Lexicon").size() == 3 + && modifiedJson.getJsonArray("Lexicon").getString(0).equals("Giggles")); + assertTrue("Nested object member not added!", modifiedJson.getJsonObject("Nested").containsKey("Purdie") + && modifiedJson.getJsonObject("Nested").getString("Purdie").equals("Furdie")); + assertTrue("Nested array element not added!", + modifiedJson.getJsonObject("Nested").getJsonArray("Bestiary").size() == 4 + && modifiedJson.getJsonObject("Nested").getJsonArray("Bestiary").getString(1).equals("Wraith")); + } + + /** + * Test that the JSON Pointer remove operation works as expected. + */ + @Test + public void removeTest() { + // Create pointers + JsonPointer objectMemberPointer = Json.createPointer("/Wibbly"); + JsonPointer arrayElementPointer = Json.createPointer("/Lexicon/0"); + JsonPointer nestedObjectMemberPointer = Json.createPointer("/Nested/Birdie"); + JsonPointer nestedArrayPointer = Json.createPointer("/Nested/Bestiary"); + + // Perform a remove operation using each pointer + JsonObject modifiedJson = objectMemberPointer.remove(json); + modifiedJson = arrayElementPointer.remove(modifiedJson); + modifiedJson = nestedObjectMemberPointer.remove(modifiedJson); + modifiedJson = nestedArrayPointer.remove(modifiedJson); + + // Check that they've been removed + assertTrue("Object member not removed!", !modifiedJson.containsKey("Wibbly")); + assertTrue("Array element not removed!", modifiedJson.getJsonArray("Lexicon").size() == 1 + && !modifiedJson.getJsonArray("Lexicon").getString(0).equals("Drowner")); + assertTrue("Nested object member not removed!", !modifiedJson.getJsonObject("Nested").containsKey("Birdie")); + assertTrue("Nested array not removed!", !modifiedJson.getJsonObject("Nested").containsKey("Bestiary")); + } + + /** + * Test that the JSON Pointer replace operation works as expected. + */ + @Test + public void replaceTest() { + // Create pointers + JsonPointer objectMemberPointer = Json.createPointer("/Wibbly"); + JsonPointer arrayElementPointer = Json.createPointer("/Lexicon/0"); + JsonPointer nestedObjectMemberPointer = Json.createPointer("/Nested/Birdie"); + + // Perform a replace operation using each pointer + JsonObject modifiedJson = objectMemberPointer.replace(json, Json.createValue("Bobbly")); + modifiedJson = arrayElementPointer.replace(modifiedJson, Json.createValue("Tiddles")); + modifiedJson = nestedObjectMemberPointer.replace(modifiedJson, Json.createValue("Bubbly")); + + // Check that they've been replaced + assertTrue("Object member not added!", modifiedJson.containsKey("Wibbly") + && modifiedJson.getString("Wibbly").equals("Bobbly")); + assertTrue("Array element not added!", modifiedJson.getJsonArray("Lexicon").size() == 2 + && modifiedJson.getJsonArray("Lexicon").getString(0).equals("Tiddles")); + assertTrue("Nested object member not added!", modifiedJson.getJsonObject("Nested").containsKey("Birdie") + && modifiedJson.getJsonObject("Nested").getString("Birdie").equals("Bubbly")); + } +} diff --git a/json-p/pom.xml b/json-p/pom.xml new file mode 100644 index 0000000..6c1b943 --- /dev/null +++ b/json-p/pom.xml @@ -0,0 +1,45 @@ + + + 4.0.0 + + org.javaee8 + samples-parent + 1.0-SNAPSHOT + + + json-p + pom + Java EE 8 Samples: JSON-P + + + patch + pointer + merge + + + + 1.1 + + + + + org.javaee8 + test-utils + ${project.version} + + + javax.json + javax.json-api + ${json.version} + provided + + + + org.glassfish + javax.json + ${json.version} + provided + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml index 721c0ef..2f638ca 100644 --- a/pom.xml +++ b/pom.xml @@ -98,7 +98,8 @@ cdi jpa jsonb - validation + validation + json-p