entry :
104 | modifiedMembers.entrySet()) {
105 | jgen.writeFieldName(entry.getKey());
106 | entry.getValue().serialize(jgen, provider);
107 | }
108 |
109 | jgen.writeEndObject();
110 | }
111 |
112 | @Override
113 | public void serializeWithType(final JsonGenerator jgen,
114 | final SerializerProvider provider,
115 | final TypeSerializer typeSer) throws IOException {
116 | serialize(jgen, provider);
117 | }
118 | }
119 |
--------------------------------------------------------------------------------
/src/main/java/com/gravity9/jsonpatch/mergepatch/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | /**
21 | * JSON Merge Patch implementation
22 | *
23 | * This is a complete implementation of RFC 7386 (JSON Merge Patch).
25 | *
26 | *
27 | * You may want to use this instead of a "pure" (aka RFC 6902) JSON Patch if
28 | * you want to do simple patching of JSON Objects, where this implementation
29 | * really shines. For instance, if you want to replace a value for one
30 | * property {@code p} with JSON String {@code "bar"}, a JSON Patch will read:
31 | *
32 | *
33 | *
34 | * [
35 | * { "op": "replace", "path": "/p", "value": "bar" }
36 | * ]
37 | *
38 | *
39 | * whereas the equivalent JSON Merge Patch will be:
40 | *
41 | *
42 | * { "p": "bar"}
43 | *
44 | *
45 | * Note that this is recursive; therefore, this:
46 | *
47 | *
48 | * { "a": { "b": "c" } }
49 | *
50 | *
51 | * will replace (or add, if not present) the value at JSON Pointer {@code
52 | * /a/b} with JSON String {@code "c"}.
53 | *
54 | * HOWEVER: while this seems attractive, there are a few traps. One
55 | * of them is that, when a value of an object member in a JSON Merge Patch is
56 | * a JSON null, the target will see the equivalent member removed; there
57 | * is no way to specify that a value should be set with a JSON null value (JSON
58 | * Patch allows for this).
59 | *
60 | * The RFC defines a pseudo code for how a JSON Merge Patch is applied; this
61 | * function is replicated in the javadoc for {@link
62 | * com.gravity9.jsonpatch.mergepatch.JsonMergePatch}, so you are encouraged to
63 | * read the javadoc for this class, and the RFC itself.
64 | */
65 | package com.gravity9.jsonpatch.mergepatch;
--------------------------------------------------------------------------------
/src/main/java/com/gravity9/jsonpatch/package-info.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | /**
21 | * Implementation of JSON Patch
22 | *
23 | * As its name implies, JSON Patch is a mechanism designed to modify JSON
24 | * documents. It consists of a series of operations to apply in order to the
25 | * source JSON document until all operations are applied or an error has been
26 | * encountered.
27 | *
28 | * The main class is {@link com.gravity9.jsonpatch.JsonPatch}.
29 | *
30 | * Note that at this moment, the only way to build a patch is from a JSON
31 | * representation (as a {@link com.fasterxml.jackson.databind.JsonNode}).
32 | */
33 | package com.gravity9.jsonpatch;
34 |
--------------------------------------------------------------------------------
/src/main/resources/META-INF/LGPL-3.0.txt:
--------------------------------------------------------------------------------
1 | GNU LESSER GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 |
9 | This version of the GNU Lesser General Public License incorporates
10 | the terms and conditions of version 3 of the GNU General Public
11 | License, supplemented by the additional permissions listed below.
12 |
13 | 0. Additional Definitions.
14 |
15 | As used herein, "this License" refers to version 3 of the GNU Lesser
16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
17 | General Public License.
18 |
19 | "The Library" refers to a covered work governed by this License,
20 | other than an Application or a Combined Work as defined below.
21 |
22 | An "Application" is any work that makes use of an interface provided
23 | by the Library, but which is not otherwise based on the Library.
24 | Defining a subclass of a class defined by the Library is deemed a mode
25 | of using an interface provided by the Library.
26 |
27 | A "Combined Work" is a work produced by combining or linking an
28 | Application with the Library. The particular version of the Library
29 | with which the Combined Work was made is also called the "Linked
30 | Version".
31 |
32 | The "Minimal Corresponding Source" for a Combined Work means the
33 | Corresponding Source for the Combined Work, excluding any source code
34 | for portions of the Combined Work that, considered in isolation, are
35 | based on the Application, and not on the Linked Version.
36 |
37 | The "Corresponding Application Code" for a Combined Work means the
38 | object code and/or source code for the Application, including any data
39 | and utility programs needed for reproducing the Combined Work from the
40 | Application, but excluding the System Libraries of the Combined Work.
41 |
42 | 1. Exception to Section 3 of the GNU GPL.
43 |
44 | You may convey a covered work under sections 3 and 4 of this License
45 | without being bound by section 3 of the GNU GPL.
46 |
47 | 2. Conveying Modified Versions.
48 |
49 | If you modify a copy of the Library, and, in your modifications, a
50 | facility refers to a function or data to be supplied by an Application
51 | that uses the facility (other than as an argument passed when the
52 | facility is invoked), then you may convey a copy of the modified
53 | version:
54 |
55 | a) under this License, provided that you make a good faith effort to
56 | ensure that, in the event an Application does not supply the
57 | function or data, the facility still operates, and performs
58 | whatever part of its purpose remains meaningful, or
59 |
60 | b) under the GNU GPL, with none of the additional permissions of
61 | this License applicable to that copy.
62 |
63 | 3. Object Code Incorporating Material from Library Header Files.
64 |
65 | The object code form of an Application may incorporate material from
66 | a header file that is part of the Library. You may convey such object
67 | code under terms of your choice, provided that, if the incorporated
68 | material is not limited to numerical parameters, data structure
69 | layouts and accessors, or small macros, inline functions and templates
70 | (ten or fewer lines in length), you do both of the following:
71 |
72 | a) Give prominent notice with each copy of the object code that the
73 | Library is used in it and that the Library and its use are
74 | covered by this License.
75 |
76 | b) Accompany the object code with a copy of the GNU GPL and this license
77 | document.
78 |
79 | 4. Combined Works.
80 |
81 | You may convey a Combined Work under terms of your choice that,
82 | taken together, effectively do not restrict modification of the
83 | portions of the Library contained in the Combined Work and reverse
84 | engineering for debugging such modifications, if you also do each of
85 | the following:
86 |
87 | a) Give prominent notice with each copy of the Combined Work that
88 | the Library is used in it and that the Library and its use are
89 | covered by this License.
90 |
91 | b) Accompany the Combined Work with a copy of the GNU GPL and this license
92 | document.
93 |
94 | c) For a Combined Work that displays copyright notices during
95 | execution, include the copyright notice for the Library among
96 | these notices, as well as a reference directing the user to the
97 | copies of the GNU GPL and this license document.
98 |
99 | d) Do one of the following:
100 |
101 | 0) Convey the Minimal Corresponding Source under the terms of this
102 | License, and the Corresponding Application Code in a form
103 | suitable for, and under terms that permit, the user to
104 | recombine or relink the Application with a modified version of
105 | the Linked Version to produce a modified Combined Work, in the
106 | manner specified by section 6 of the GNU GPL for conveying
107 | Corresponding Source.
108 |
109 | 1) Use a suitable shared library mechanism for linking with the
110 | Library. A suitable mechanism is one that (a) uses at run time
111 | a copy of the Library already present on the user's computer
112 | system, and (b) will operate properly with a modified version
113 | of the Library that is interface-compatible with the Linked
114 | Version.
115 |
116 | e) Provide Installation Information, but only if you would otherwise
117 | be required to provide such information under section 6 of the
118 | GNU GPL, and only to the extent that such information is
119 | necessary to install and execute a modified version of the
120 | Combined Work produced by recombining or relinking the
121 | Application with a modified version of the Linked Version. (If
122 | you use option 4d0, the Installation Information must accompany
123 | the Minimal Corresponding Source and Corresponding Application
124 | Code. If you use option 4d1, you must provide the Installation
125 | Information in the manner specified by section 6 of the GNU GPL
126 | for conveying Corresponding Source.)
127 |
128 | 5. Combined Libraries.
129 |
130 | You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 |
136 | a) Accompany the combined library with a copy of the same work based
137 | on the Library, uncombined with any other library facilities,
138 | conveyed under the terms of this License.
139 |
140 | b) Give prominent notice with the combined library that part of it
141 | is a work based on the Library, and explaining where to find the
142 | accompanying uncombined form of the same work.
143 |
144 | 6. Revised Versions of the GNU Lesser General Public License.
145 |
146 | The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 |
151 | Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 |
161 | If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.
166 |
167 |
--------------------------------------------------------------------------------
/src/main/resources/META-INF/LICENSE:
--------------------------------------------------------------------------------
1 | This software is dual-licensed under:
2 |
3 | - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
4 | later version;
5 | - the Apache Software License (ASL) version 2.0.
6 |
7 | The text of both licenses is included (under the names LGPL-3.0.txt and
8 | ASL-2.0.txt respectively).
9 |
10 | Direct link to the sources:
11 |
12 | - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
13 | - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
14 |
15 |
--------------------------------------------------------------------------------
/src/main/resources/com/gravity9/jsonpatch/messages.properties:
--------------------------------------------------------------------------------
1 | #
2 | # Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | #
4 | # This software is dual-licensed under:
5 | #
6 | # - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | # later version;
8 | # - the Apache Software License (ASL) version 2.0.
9 | #
10 | # The text of this file and of both licenses is available at the root of this
11 | # project or, if you have the jar distribution, in directory META-INF/, under
12 | # the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | #
14 | # Direct link to the sources:
15 | #
16 | # - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | # - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | #
19 |
20 | common.nullArgument=argument cannot be null
21 | jsonPatch.deserFailed=unable to deserialize JSON input
22 | jsonPatch.nullInput=input cannot be null
23 | jsonPatch.nullValue=value cannot be null
24 | jsonPatch.notAnIndex=reference token is not an array index
25 | jsonPatch.noSuchIndex=no such index in target array
26 | jsonPatch.parentNotContainer=parent of path to add to is not a container
27 | jsonPatch.valueTestFailure=value differs from expectations
28 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/AddOperationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import java.io.IOException;
23 |
24 | public final class AddOperationTest extends JsonPatchOperationTest {
25 |
26 | public AddOperationTest()
27 | throws IOException {
28 | super("add");
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/CopyOperationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import java.io.IOException;
23 |
24 | public final class CopyOperationTest extends JsonPatchOperationTest {
25 |
26 | public CopyOperationTest()
27 | throws IOException {
28 | super("copy");
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/JsonPatchOperationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import com.fasterxml.jackson.databind.JsonNode;
23 | import com.fasterxml.jackson.databind.ObjectReader;
24 | import com.github.fge.jackson.JacksonUtils;
25 | import com.github.fge.jackson.JsonLoader;
26 | import com.google.common.collect.Lists;
27 | import java.io.IOException;
28 | import java.util.Iterator;
29 | import java.util.List;
30 |
31 | import com.gravity9.jsonpatch.jackson.JsonNumEquals;
32 | import org.testng.annotations.DataProvider;
33 | import org.testng.annotations.Test;
34 |
35 | import static org.testng.Assert.assertEquals;
36 | import static org.testng.Assert.assertNotSame;
37 | import static org.testng.Assert.assertTrue;
38 | import static org.testng.Assert.fail;
39 |
40 | @Test
41 | public abstract class JsonPatchOperationTest {
42 |
43 | private static final JsonNumEquals EQUIVALENCE
44 | = JsonNumEquals.getInstance();
45 |
46 | private final JsonNode errors;
47 | private final JsonNode ops;
48 | private final ObjectReader reader;
49 |
50 | protected JsonPatchOperationTest(final String prefix)
51 | throws IOException {
52 | final String resource = "/jsonpatch/" + prefix + ".json";
53 | final JsonNode node = JsonLoader.fromResource(resource);
54 | errors = node.get("errors");
55 | ops = node.get("ops");
56 | reader = JacksonUtils.getReader().forType(JsonPatchOperation.class);
57 | }
58 |
59 | @DataProvider
60 | public final Iterator getErrors() {
61 | final List list = Lists.newArrayList();
62 |
63 | for (final JsonNode node : errors)
64 | list.add(new Object[]{
65 | node.get("op"),
66 | node.get("node"),
67 | node.get("message").textValue()
68 | });
69 |
70 | return list.iterator();
71 | }
72 |
73 | @Test(dataProvider = "getErrors")
74 | public final void errorsAreCorrectlyReported(final JsonNode patch,
75 | final JsonNode node, final String message)
76 | throws IOException {
77 | final JsonPatchOperation op = reader.readValue(patch);
78 |
79 | try {
80 | op.apply(node);
81 | fail("No exception thrown!!");
82 | } catch (Exception e) {
83 | assertEquals(e.getMessage(), message);
84 | }
85 | }
86 |
87 | @DataProvider
88 | public final Iterator getOps() {
89 | final List list = Lists.newArrayList();
90 |
91 | for (final JsonNode node : ops)
92 | list.add(new Object[]{
93 | node.get("op"),
94 | node.get("node"),
95 | node.get("expected")
96 | });
97 |
98 | return list.iterator();
99 | }
100 |
101 | @Test(dataProvider = "getOps")
102 | public final void operationsYieldExpectedResults(final JsonNode patch,
103 | final JsonNode node, final JsonNode expected)
104 | throws IOException, JsonPatchException {
105 | final JsonPatchOperation op = reader.readValue(patch);
106 | final JsonNode actual = op.apply(node);
107 |
108 | assertTrue(EQUIVALENCE.equivalent(actual, expected),
109 | "patched node differs from expectations: expected " + expected
110 | + " but found " + actual);
111 | if (EQUIVALENCE.equivalent(node, actual) && node.isContainerNode())
112 | assertNotSame(node, actual,
113 | "operation didn't make a copy of the input node");
114 | }
115 | }
116 |
117 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/JsonPatchTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import com.fasterxml.jackson.databind.JsonNode;
23 | import com.fasterxml.jackson.databind.node.JsonNodeFactory;
24 | import com.github.fge.jackson.JacksonUtils;
25 | import com.github.fge.msgsimple.bundle.MessageBundle;
26 | import com.github.fge.msgsimple.load.MessageBundles;
27 | import com.google.common.collect.ImmutableList;
28 | import java.io.IOException;
29 | import org.mockito.ArgumentCaptor;
30 | import org.testng.annotations.BeforeMethod;
31 | import org.testng.annotations.Test;
32 |
33 | import static org.mockito.Mockito.any;
34 | import static org.mockito.Mockito.mock;
35 | import static org.mockito.Mockito.only;
36 | import static org.mockito.Mockito.same;
37 | import static org.mockito.Mockito.verify;
38 | import static org.mockito.Mockito.verifyZeroInteractions;
39 | import static org.mockito.Mockito.when;
40 | import static org.testng.Assert.assertEquals;
41 | import static org.testng.Assert.assertSame;
42 | import static org.testng.Assert.fail;
43 |
44 | public final class JsonPatchTest {
45 |
46 | private static final MessageBundle BUNDLE
47 | = MessageBundles.getBundle(JsonPatchMessages.class);
48 |
49 | private static final JsonNodeFactory FACTORY = JacksonUtils.nodeFactory();
50 |
51 | private JsonPatchOperation op1;
52 | private JsonPatchOperation op2;
53 |
54 | @BeforeMethod
55 | public void init() {
56 | op1 = mock(JsonPatchOperation.class);
57 | op2 = mock(JsonPatchOperation.class);
58 | }
59 |
60 | @Test
61 | public void nullInputsDuringBuildAreRejected()
62 | throws IOException {
63 | try {
64 | JsonPatch.fromJson(null);
65 | fail("No exception thrown!!");
66 | } catch (NullPointerException e) {
67 | assertEquals(e.getMessage(), BUNDLE.getMessage(
68 | "jsonPatch.nullInput"));
69 | }
70 | }
71 |
72 | @Test
73 | public void cannotPatchNull()
74 | throws JsonPatchException {
75 | final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2));
76 |
77 | try {
78 | patch.apply(null);
79 | fail("No exception thrown!!");
80 | } catch (NullPointerException e) {
81 | assertEquals(e.getMessage(), BUNDLE.getMessage(
82 | "jsonPatch.nullInput"));
83 | }
84 | }
85 |
86 | @Test
87 | public void operationsAreCalledInOrder()
88 | throws JsonPatchException {
89 | final JsonNode node1 = FACTORY.textNode("hello");
90 | final JsonNode node2 = FACTORY.textNode("world");
91 |
92 | when(op1.apply(node1)).thenReturn(node2);
93 |
94 | final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2));
95 |
96 | final ArgumentCaptor captor
97 | = ArgumentCaptor.forClass(JsonNode.class);
98 |
99 | patch.apply(node1);
100 | verify(op1, only()).apply(same(node1));
101 | verify(op2, only()).apply(captor.capture());
102 |
103 | assertSame(captor.getValue(), node2);
104 | }
105 |
106 | @Test
107 | public void whenOneOperationFailsNextOperationIsNotCalled()
108 | throws JsonPatchException {
109 | final String message = "foo";
110 | when(op1.apply(any(JsonNode.class)))
111 | .thenThrow(new JsonPatchException(message));
112 |
113 | final JsonPatch patch = new JsonPatch(ImmutableList.of(op1, op2));
114 |
115 | try {
116 | patch.apply(FACTORY.nullNode());
117 | fail("No exception thrown!!");
118 | } catch (JsonPatchException e) {
119 | assertEquals(e.getMessage(), message);
120 | }
121 |
122 | verifyZeroInteractions(op2);
123 | }
124 | }
125 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/JsonPatchTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import com.fasterxml.jackson.databind.JsonNode;
23 | import com.github.fge.jackson.JsonLoader;
24 | import com.google.common.collect.Lists;
25 | import java.io.IOException;
26 | import java.util.Iterator;
27 | import java.util.List;
28 | import org.testng.annotations.DataProvider;
29 | import org.testng.annotations.Test;
30 |
31 | import static org.testng.Assert.assertTrue;
32 | import static org.testng.Assert.fail;
33 |
34 | public final class JsonPatchTests {
35 |
36 | private final JsonNode testNode;
37 |
38 | public JsonPatchTests()
39 | throws IOException {
40 | testNode = JsonLoader.fromResource("/jsonpatch/testsuite.json");
41 | }
42 |
43 | @DataProvider
44 | public Iterator getTests()
45 | throws IOException {
46 | final List list = Lists.newArrayList();
47 |
48 | boolean valid;
49 | JsonPatch patch;
50 | JsonNode source, expected;
51 |
52 | for (final JsonNode element : testNode) {
53 | if (!element.has("patch"))
54 | continue;
55 | patch = JsonPatch.fromJson(element.get("patch"));
56 | source = element.get("doc");
57 | expected = element.get("expected");
58 | if (expected == null)
59 | expected = source;
60 | valid = !element.has("error");
61 | list.add(new Object[]{source, patch, expected, valid});
62 | }
63 |
64 | return list.iterator();
65 | }
66 |
67 | @Test(dataProvider = "getTests")
68 | public void testsFromTestSuitePass(final JsonNode source,
69 | final JsonPatch patch, final JsonNode expected, final boolean valid) {
70 | try {
71 | final JsonNode actual = patch.apply(source);
72 | if (!valid)
73 | fail("Test was expected to fail!!");
74 | // Have to do that... TestNG tries to be too smart with regards
75 | // to iterable collections...
76 | assertTrue(actual.equals(expected));
77 | } catch (Exception ignored) {
78 | if (valid)
79 | fail("Test was expected to succeed!!");
80 | }
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/JsonPathParserTest.java:
--------------------------------------------------------------------------------
1 | package com.gravity9.jsonpatch;
2 |
3 | import org.testng.annotations.DataProvider;
4 | import org.testng.annotations.Test;
5 |
6 | import static org.testng.Assert.assertEquals;
7 |
8 | public class JsonPathParserTest {
9 |
10 | @DataProvider
11 | public static Object[][] jsonPointerToJsonPathTestCases() {
12 | return new Object[][] {
13 | {"/productPrice/prodPriceAlteration", "$.productPrice.prodPriceAlteration"},
14 | {"/productPrice/1/prodPriceAlteration", "$.productPrice.[1].prodPriceAlteration"},
15 | {"/productPrice/prodPriceAlteration/1", "$.productPrice.prodPriceAlteration.[1]"},
16 | {"/2/1/-", "$.[2].[1].-"}
17 | };
18 | }
19 |
20 | @Test(dataProvider = "jsonPointerToJsonPathTestCases")
21 | public void shouldConvertPointerToJsonPath(String jsonPointerExpression, String expectedJsonPath) throws JsonPatchException {
22 | String result = JsonPathParser.parsePathToJsonPath(jsonPointerExpression);
23 | assertEquals(result, expectedJsonPath);
24 | }
25 |
26 | @Test
27 | public void shouldLeaveJsonPathStatementsUntouched() throws JsonPatchException {
28 | String filterQuery = "$.arrayPath[?(@.innerArray[?(@.nestedVal=='as')] empty false)].innerArray[?(@.nestedVal=='df')].name";
29 | String expected = "$.arrayPath[?(@.innerArray[?(@.nestedVal=='as')] empty false)].innerArray[?(@.nestedVal=='df')].name";
30 | String result = JsonPathParser.parsePathToJsonPath(filterQuery);
31 | assertEquals(result, expected);
32 | }
33 |
34 | @Test(expectedExceptions = JsonPatchException.class, expectedExceptionsMessageRegExp = "Invalid path, `//` is not allowed in JsonPointer expressions.")
35 | public void shouldThrowExceptionWhenDoubleSlashesInJsonPointerPath() throws JsonPatchException {
36 | String filterQuery = "/characteristic/0//age";
37 | JsonPathParser.parsePathToJsonPath(filterQuery);
38 | }
39 |
40 | @Test(expectedExceptions = JsonPatchException.class)
41 | public void shouldThrowExceptionWhenQuestionMarkInJsonPointerPath() throws JsonPatchException {
42 | String filterQuery = "/characteristic/0/age?";
43 | JsonPathParser.parsePathToJsonPath(filterQuery);
44 | }
45 | }
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/MoveOperationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import java.io.IOException;
23 |
24 | public final class MoveOperationTest extends JsonPatchOperationTest {
25 |
26 | public MoveOperationTest()
27 | throws IOException {
28 | super("move");
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/PathParserTest.java:
--------------------------------------------------------------------------------
1 | package com.gravity9.jsonpatch;
2 |
3 | import org.testng.annotations.DataProvider;
4 | import org.testng.annotations.Test;
5 |
6 | import static org.testng.Assert.assertEquals;
7 |
8 | public class PathParserTest {
9 |
10 | @DataProvider
11 | public static Object[][] pathToParse() {
12 | return new Object[][] {
13 | {"/user/1/name", "$['user'][1]", "name"},
14 | {"/user/name", "$['user']", "name"},
15 | {"$.user[1].name", "$['user'][1]", "name"},
16 | {"$['user'][1]['name']", "$['user'][1]", "name"},
17 | {"$['user'][1].name", "$['user'][1]", "name"},
18 | {"$[?(@.book[?(@.ratingScore == '111')] empty false)].title", "$[?(@.book[?(@.ratingScore == '111')] empty false)]", "title"},
19 | {"$..book[-1:].title", "$..['book'][-1:]", "title"},
20 | {"$..book[1:2].title", "$..['book'][1:2]", "title"},
21 | {"$..book[1:].title", "$..['book'][1:]", "title"},
22 | {"$..book[:5].title", "$..['book'][:5]", "title"},
23 | {"$..book[*].title", "$..['book'][*]", "title"},
24 | {"$.user[0].name[", "$['user'][0]", "name"},
25 | {"$.user['0'].name[", "$['user']['0']", "name"},
26 | {"/id", "$", "id"},
27 | {"$.id", "$", "id"},
28 | {"$['id']", "$", "id"},
29 | {"$[?(@.contactMedium[?(@.characteristic.contactType == 'primary' && @.characteristic.emailAddress)] empty true)].contactMedium.-", "$[?(@.contactMedium[?(@.characteristic.contactType == 'primary' && @.characteristic.emailAddress)] empty true)]['contactMedium']", "-"}
30 | };
31 | }
32 |
33 | @Test(dataProvider = "pathToParse")
34 | void should_parse_path(String path, String expectedPathToParent, String expectedNewNodeName) throws JsonPatchException {
35 | // when
36 | PathDetails result = PathParser.getParentPathAndNewNodeName(path);
37 |
38 | // then
39 | assertEquals(result.getPathToParent(), expectedPathToParent);
40 | assertEquals(result.getNewNodeName(), expectedNewNodeName);
41 | }
42 |
43 |
44 | // This notation is not supported by JsonPath PathCompiler.compile
45 | @Test(expectedExceptions = JsonPatchException.class)
46 | void should_throw_exception_with_double_dots_and_length() throws JsonPatchException {
47 | // given
48 | String path = "$..book[(@.length-1)].title";
49 |
50 | // when
51 | PathParser.getParentPathAndNewNodeName(path);
52 | }
53 |
54 | @Test(expectedExceptions = JsonPatchException.class)
55 | void should_throw_json_patch_exception_when_invalid_json_path_provided() throws JsonPatchException {
56 | // given
57 | final String invalidPath = "$.user[[]][.name";
58 |
59 | // when
60 | PathParser.getParentPathAndNewNodeName(invalidPath);
61 | }
62 | }
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/RemoveOperationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import com.fasterxml.jackson.databind.JsonNode;
23 | import com.github.fge.jackson.JacksonUtils;
24 | import java.io.IOException;
25 | import org.testng.annotations.Test;
26 |
27 | import static org.testng.Assert.assertTrue;
28 |
29 | public final class RemoveOperationTest extends JsonPatchOperationTest {
30 |
31 | public RemoveOperationTest()
32 | throws IOException {
33 | super("remove");
34 | }
35 |
36 | @Test
37 | public void removingRootReturnsMissingNode()
38 | throws JsonPatchException {
39 | final JsonNode node = JacksonUtils.nodeFactory().nullNode();
40 | final JsonPatchOperation op = new RemoveOperation("");
41 | final JsonNode ret = op.apply(node);
42 | assertTrue(ret.isMissingNode());
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/ReplaceOperationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import java.io.IOException;
23 |
24 | public final class ReplaceOperationTest extends JsonPatchOperationTest {
25 |
26 | public ReplaceOperationTest()
27 | throws IOException {
28 | super("replace");
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/TestOperationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch;
21 |
22 | import com.fasterxml.jackson.databind.JsonNode;
23 | import com.fasterxml.jackson.databind.ObjectMapper;
24 | import org.testng.annotations.Test;
25 |
26 | import java.io.IOException;
27 |
28 | public final class TestOperationTest extends JsonPatchOperationTest {
29 |
30 | private static final TestDomain DOMAIN_TO_PATCH = new TestDomain(2022.4321f);
31 | private static final String testOperation = "[{\"op\":\"test\",\"path\":\"/myValue\",\"value\":2022.4321}]";
32 |
33 | public TestOperationTest()
34 | throws IOException {
35 | super("test");
36 | }
37 |
38 | @Test
39 | void testPatchValueIsDoubleDomainValueIsFloat() throws Exception {
40 | JsonPatch jsonPatch = new ObjectMapper().readValue(testOperation, JsonPatch.class);
41 |
42 | JsonNode jsonNode = new ObjectMapper().valueToTree(DOMAIN_TO_PATCH);
43 |
44 | jsonPatch.apply(jsonNode);
45 | }
46 |
47 | @SuppressWarnings("UnusedMethod")
48 | private static class TestDomain {
49 |
50 | private Float myValue;
51 |
52 | public TestDomain(Float myValue) {
53 | this.myValue = myValue;
54 | }
55 |
56 | public Float getMyValue() {
57 | return myValue;
58 | }
59 |
60 | public void setMyValue(Float myValue) {
61 | this.myValue = myValue;
62 | }
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/diff/JsonDiffTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.diff;
21 |
22 | import com.fasterxml.jackson.core.JsonProcessingException;
23 | import com.fasterxml.jackson.databind.JsonNode;
24 | import com.fasterxml.jackson.databind.ObjectMapper;
25 | import com.github.fge.jackson.JsonLoader;
26 | import com.google.common.collect.Lists;
27 | import com.gravity9.jsonpatch.JsonPatch;
28 | import com.gravity9.jsonpatch.JsonPatchException;
29 | import java.io.IOException;
30 | import java.util.ArrayList;
31 | import java.util.Iterator;
32 | import java.util.List;
33 |
34 | import com.gravity9.jsonpatch.jackson.JsonNumEquals;
35 | import org.testng.annotations.DataProvider;
36 | import org.testng.annotations.Test;
37 |
38 | import static org.assertj.core.api.Assertions.assertThat;
39 | import static org.assertj.core.api.Assertions.assertThatThrownBy;
40 |
41 | public final class JsonDiffTest {
42 |
43 | private static final JsonNumEquals EQUIVALENCE = JsonNumEquals.getInstance();
44 |
45 | private final JsonNode testData;
46 |
47 | public JsonDiffTest()
48 | throws IOException {
49 | final String resource = "/jsonpatch/diff/diff.json";
50 | testData = JsonLoader.fromResource(resource);
51 | }
52 |
53 | @DataProvider
54 | public Iterator getPatchesOnly() {
55 | final List list = Lists.newArrayList();
56 |
57 | for (final JsonNode node : testData)
58 | if (!node.has("ignoreFields")) {
59 | list.add(new Object[]{node.get("first"), node.get("second")});
60 | }
61 |
62 | return list.iterator();
63 | }
64 |
65 | @Test(dataProvider = "getPatchesOnly")
66 | public void generatedPatchAppliesCleanly(final JsonNode first,
67 | final JsonNode second)
68 | throws JsonPatchException {
69 | final JsonPatch patch = JsonDiff.asJsonPatch(first, second);
70 | final JsonNode actual = patch.apply(first);
71 |
72 | assertThat(EQUIVALENCE.equivalent(second, actual)).overridingErrorMessage(
73 | "Generated patch failed to apply\nexpected: %s\nactual: %s",
74 | second, actual
75 | ).isTrue();
76 | }
77 |
78 | @DataProvider
79 | public Iterator getLiteralPatches() {
80 | final List list = Lists.newArrayList();
81 |
82 | for (final JsonNode node : testData) {
83 | if (!node.has("patch") || node.has("ignoreFields"))
84 | continue;
85 | list.add(new Object[]{
86 | node.get("message").textValue(), node.get("first"),
87 | node.get("second"), node.get("patch")
88 | });
89 | }
90 |
91 | return list.iterator();
92 | }
93 |
94 | @Test(
95 | dataProvider = "getLiteralPatches",
96 | dependsOnMethods = "generatedPatchAppliesCleanly"
97 | )
98 | public void generatedPatchesAreWhatIsExpected(final String message,
99 | final JsonNode first, final JsonNode second, final JsonNode expected) throws JsonPatchException {
100 | final JsonNode actual = JsonDiff.asJson(first, second);
101 |
102 | assertThat(EQUIVALENCE.equivalent(expected, actual)).overridingErrorMessage(
103 | "patch is not what was expected\nscenario: %s\n"
104 | + "expected: %s\nactual: %s\n", message, expected, actual
105 | ).isTrue();
106 | }
107 |
108 | @DataProvider
109 | public Iterator getDiffsWithIgnoredFields() {
110 | final List list = Lists.newArrayList();
111 |
112 | for (final JsonNode node : testData) {
113 | if (node.has("ignoreFields")) {
114 | list.add(new Object[]{
115 | node.get("message").textValue(), node.get("first"),
116 | node.get("second"), node.get("patch"), node.get("ignoreFields")
117 | });
118 | }
119 | }
120 |
121 | return list.iterator();
122 | }
123 |
124 | @Test(
125 | dataProvider = "getDiffsWithIgnoredFields"
126 | )
127 | public void generatedPatchesIgnoreFields(final String message,
128 | final JsonNode first, final JsonNode second, final JsonNode expected,
129 | final JsonNode ignoreFields) throws JsonPatchException {
130 |
131 | final List ignoreFieldsList = new ArrayList<>();
132 | final Iterator ignoreFieldsIterator = ignoreFields.elements();
133 | while (ignoreFieldsIterator.hasNext()) {
134 | ignoreFieldsList.add(ignoreFieldsIterator.next().textValue());
135 | }
136 |
137 | final JsonNode actual = JsonDiff.asJsonIgnoringFields(first, second, ignoreFieldsList);
138 |
139 | assertThat(EQUIVALENCE.equivalent(expected, actual)).overridingErrorMessage(
140 | "patch is not what was expected\nscenario: %s\n"
141 | + "expected: %s\nactual: %s\n", message, expected, actual
142 | ).isTrue();
143 | }
144 |
145 | @DataProvider
146 | public Iterator getInvalidIgnoreFieldsExpressions() {
147 | final List list = Lists.newArrayList();
148 | list.add(new Object[]{
149 | "$.a[(@.length-1)]", "Could not parse token starting at position 3. Expected ?, ', 0-9, * "
150 | });
151 | list.add(new Object[]{
152 | "/a/?", "Invalid path, `?` are not allowed in JsonPointer expressions."
153 | });
154 | return list.iterator();
155 | }
156 |
157 | @Test(
158 | dataProvider = "getInvalidIgnoreFieldsExpressions"
159 | )
160 | public void shouldNotPerformDiffWhenIgnoreFieldsContainsInvalidExpression(String ignoreFieldsExpression, String expectedExceptionMessage) throws JsonProcessingException {
161 | // given
162 | JsonNode source = new ObjectMapper().readTree("{\"a\": \"1\"}");
163 | JsonNode target = new ObjectMapper().readTree("{\"a\": \"1\"}");
164 | List ignoreFields = new ArrayList<>();
165 | ignoreFields.add(ignoreFieldsExpression);
166 |
167 | // when
168 | assertThatThrownBy(() -> JsonDiff.asJsonIgnoringFields(source, target, ignoreFields))
169 | .isExactlyInstanceOf(JsonPatchException.class)
170 | .hasMessageStartingWith(expectedExceptionMessage);
171 |
172 | assertThatThrownBy(() -> JsonDiff.asJsonPatchIgnoringFields(source, target, ignoreFields))
173 | .isExactlyInstanceOf(JsonPatchException.class)
174 | .hasMessageStartingWith(expectedExceptionMessage);
175 | }
176 | }
177 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/diff/UnchangedTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.diff;
21 |
22 | import com.fasterxml.jackson.core.type.TypeReference;
23 | import com.fasterxml.jackson.databind.JsonNode;
24 | import com.fasterxml.jackson.databind.ObjectMapper;
25 | import com.github.fge.jackson.JacksonUtils;
26 | import com.github.fge.jackson.JsonLoader;
27 | import com.github.fge.jackson.jsonpointer.JsonPointer;
28 | import com.google.common.collect.Lists;
29 | import java.io.IOException;
30 | import java.util.Iterator;
31 | import java.util.List;
32 | import java.util.Map;
33 | import org.testng.annotations.DataProvider;
34 | import org.testng.annotations.Test;
35 |
36 | import static org.testng.Assert.assertEquals;
37 |
38 | public final class UnchangedTest {
39 |
40 | private static final ObjectMapper MAPPER = JacksonUtils.newMapper();
41 | private static final TypeReference> TYPE_REF
42 | = new TypeReference>() {
43 | };
44 |
45 | private final JsonNode testData;
46 |
47 | public UnchangedTest()
48 | throws IOException {
49 | final String resource = "/jsonpatch/diff/unchanged.json";
50 | testData = JsonLoader.fromResource(resource);
51 | }
52 |
53 | @DataProvider
54 | public Iterator getTestData()
55 | throws IOException {
56 | final List list = Lists.newArrayList();
57 |
58 | for (final JsonNode node : testData)
59 | list.add(new Object[]{node.get("first"), node.get("second"),
60 | MAPPER.readValue(node.get("unchanged").traverse(), TYPE_REF)});
61 |
62 | return list.iterator();
63 | }
64 |
65 | @Test(dataProvider = "getTestData")
66 | public void computeUnchangedValuesWorks(final JsonNode first,
67 | final JsonNode second, final Map expected) {
68 | final Map actual
69 | = JsonDiff.getUnchangedValues(first, second);
70 |
71 | assertEquals(actual, expected);
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/mergepatch/NonObjectMergePatchTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.mergepatch;
21 |
22 | import com.fasterxml.jackson.databind.JsonNode;
23 | import com.fasterxml.jackson.databind.node.JsonNodeFactory;
24 | import com.github.fge.jackson.JsonLoader;
25 | import com.github.fge.msgsimple.bundle.MessageBundle;
26 | import com.github.fge.msgsimple.load.MessageBundles;
27 | import com.google.common.collect.Lists;
28 | import com.gravity9.jsonpatch.JsonPatchException;
29 | import com.gravity9.jsonpatch.JsonPatchMessages;
30 | import java.io.IOException;
31 | import java.util.Iterator;
32 | import java.util.List;
33 |
34 | import com.gravity9.jsonpatch.jackson.JsonNumEquals;
35 | import org.testng.annotations.DataProvider;
36 | import org.testng.annotations.Test;
37 |
38 | import static org.testng.Assert.assertEquals;
39 | import static org.testng.Assert.assertTrue;
40 | import static org.testng.Assert.fail;
41 |
42 | public final class NonObjectMergePatchTest {
43 |
44 | private static final JsonNumEquals EQUIVALENCE = JsonNumEquals.getInstance();
45 | private static final MessageBundle BUNDLE
46 | = MessageBundles.getBundle(JsonPatchMessages.class);
47 |
48 | private final JsonNode testData;
49 |
50 | public NonObjectMergePatchTest()
51 | throws IOException {
52 | final String resource = "/jsonpatch/mergepatch/patch-nonobject.json";
53 | testData = JsonLoader.fromResource(resource);
54 | }
55 |
56 | @Test
57 | public void patchYellsOnNullInput()
58 | throws JsonPatchException {
59 | try {
60 | JsonMergePatch.fromJson(JsonNodeFactory.instance.arrayNode())
61 | .apply(null);
62 | fail("No exception thrown!");
63 | } catch (NullPointerException e) {
64 | assertEquals(e.getMessage(),
65 | BUNDLE.getMessage("jsonPatch.nullValue"));
66 | }
67 | }
68 |
69 | @DataProvider
70 | public Iterator getData() {
71 | final List list = Lists.newArrayList();
72 |
73 | for (final JsonNode node : testData)
74 | list.add(new Object[]{node.get("patch"), node.get("victim")});
75 |
76 | return list.iterator();
77 | }
78 |
79 | @Test(dataProvider = "getData")
80 | public void patchingWorksAsExpected(final JsonNode input,
81 | final JsonNode victim)
82 | throws JsonPatchException {
83 | final JsonMergePatch patch = JsonMergePatch.fromJson(input);
84 | final JsonNode patched = patch.apply(victim);
85 |
86 | assertTrue(EQUIVALENCE.equivalent(input, patched));
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/mergepatch/ObjectMergePatchTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.mergepatch;
21 |
22 | import com.fasterxml.jackson.databind.JsonNode;
23 | import com.fasterxml.jackson.databind.node.JsonNodeFactory;
24 | import com.github.fge.jackson.JsonLoader;
25 | import com.github.fge.msgsimple.bundle.MessageBundle;
26 | import com.github.fge.msgsimple.load.MessageBundles;
27 | import com.google.common.collect.Lists;
28 | import com.gravity9.jsonpatch.JsonPatchException;
29 | import com.gravity9.jsonpatch.JsonPatchMessages;
30 | import java.io.IOException;
31 | import java.util.Iterator;
32 | import java.util.List;
33 |
34 | import com.gravity9.jsonpatch.jackson.JsonNumEquals;
35 | import org.testng.annotations.DataProvider;
36 | import org.testng.annotations.Test;
37 |
38 | import static org.testng.Assert.assertEquals;
39 | import static org.testng.Assert.assertTrue;
40 | import static org.testng.Assert.fail;
41 |
42 | public final class ObjectMergePatchTest {
43 |
44 | private static final JsonNumEquals EQUIVALENCE = JsonNumEquals.getInstance();
45 | private static final MessageBundle BUNDLE
46 | = MessageBundles.getBundle(JsonPatchMessages.class);
47 |
48 | private final JsonNode testData;
49 |
50 | public ObjectMergePatchTest()
51 | throws IOException {
52 | final String resource = "/jsonpatch/mergepatch/patch-object.json";
53 | testData = JsonLoader.fromResource(resource);
54 | }
55 |
56 | @Test
57 | public void patchYellsOnNullInput()
58 | throws JsonPatchException {
59 | try {
60 | JsonMergePatch.fromJson(JsonNodeFactory.instance.arrayNode())
61 | .apply(null);
62 | fail("No exception thrown!");
63 | } catch (NullPointerException e) {
64 | assertEquals(e.getMessage(),
65 | BUNDLE.getMessage("jsonPatch.nullValue"));
66 | }
67 | }
68 |
69 | @DataProvider
70 | public Iterator getData() {
71 | final List list = Lists.newArrayList();
72 |
73 | for (final JsonNode node : testData)
74 | list.add(new Object[]{
75 | node.get("patch"), node.get("victim"), node.get("result")
76 | });
77 |
78 | return list.iterator();
79 | }
80 |
81 | @Test(dataProvider = "getData")
82 | public void patchingWorksAsExpected(final JsonNode input,
83 | final JsonNode victim, final JsonNode result)
84 | throws JsonPatchException {
85 | final JsonMergePatch patch = JsonMergePatch.fromJson(input);
86 | final JsonNode patched = patch.apply(victim);
87 |
88 | assertTrue(EQUIVALENCE.equivalent(result, patched));
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/mergepatch/SerializationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.mergepatch;
21 |
22 | import com.fasterxml.jackson.databind.DeserializationFeature;
23 | import com.fasterxml.jackson.databind.JsonNode;
24 | import com.fasterxml.jackson.databind.ObjectMapper;
25 | import com.fasterxml.jackson.databind.node.JsonNodeFactory;
26 | import com.github.fge.jackson.JacksonUtils;
27 | import com.github.fge.jackson.JsonLoader;
28 | import com.google.common.collect.Lists;
29 | import java.io.IOException;
30 | import java.util.Iterator;
31 | import java.util.List;
32 |
33 | import com.gravity9.jsonpatch.jackson.JsonNumEquals;
34 | import org.testng.annotations.DataProvider;
35 | import org.testng.annotations.Test;
36 |
37 | import static org.testng.Assert.assertNotNull;
38 | import static org.testng.Assert.assertSame;
39 | import static org.testng.Assert.assertTrue;
40 | import static org.testng.AssertJUnit.assertEquals;
41 |
42 | public final class SerializationTest {
43 |
44 | private static final JsonNumEquals EQUIVALENCE = JsonNumEquals.getInstance();
45 |
46 | private final ObjectMapper mapper = JacksonUtils.newMapper();
47 | private final JsonNode nonObjectTestData;
48 | private final JsonNode objectTestData;
49 |
50 | public SerializationTest()
51 | throws IOException {
52 | final String resource1 = "/jsonpatch/mergepatch/serdeser-nonobject.json";
53 | final String resource2 = "/jsonpatch/mergepatch/serdeser-object.json";
54 | nonObjectTestData = JsonLoader.fromResource(resource1);
55 | objectTestData = JsonLoader.fromResource(resource2);
56 | }
57 |
58 | @DataProvider
59 | public Iterator getNonObjectInputs() {
60 | final List list = Lists.newArrayList();
61 |
62 | for (final JsonNode node : nonObjectTestData)
63 | list.add(new Object[]{node});
64 |
65 | return list.iterator();
66 | }
67 |
68 | @Test(dataProvider = "getNonObjectInputs")
69 | public void nonObjectSerDeserWorksCorrectly(final JsonNode input)
70 | throws IOException {
71 | final String in = input.toString();
72 | final JsonMergePatch deserialized
73 | = mapper.readValue(in, JsonMergePatch.class);
74 |
75 | assertNotNull(deserialized);
76 | assertSame(deserialized.getClass(), NonObjectMergePatch.class);
77 |
78 | final String out = mapper.writeValueAsString(deserialized);
79 | final JsonNode serialized = JacksonUtils.getReader().readTree(out);
80 |
81 | assertTrue(EQUIVALENCE.equivalent(input, serialized));
82 | }
83 |
84 | @DataProvider
85 | public Iterator getObjectInputs() {
86 | final List list = Lists.newArrayList();
87 |
88 | for (final JsonNode node : objectTestData)
89 | list.add(new Object[]{node});
90 |
91 | return list.iterator();
92 | }
93 |
94 | @Test(dataProvider = "getObjectInputs")
95 | public void objectSerDeserWorksCorrectly(final JsonNode input)
96 | throws IOException {
97 | final String in = input.toString();
98 | final JsonMergePatch deserialized
99 | = mapper.readValue(in, JsonMergePatch.class);
100 |
101 | assertNotNull(deserialized);
102 | assertSame(deserialized.getClass(), ObjectMergePatch.class);
103 |
104 | final String out = mapper.writeValueAsString(deserialized);
105 | final JsonNode serialized = JacksonUtils.getReader().readTree(out);
106 |
107 | assertTrue(EQUIVALENCE.equivalent(input, serialized));
108 | }
109 |
110 | @Test
111 | void testDecimalsKeptAfterPatchWithCustomObjectMapper() throws Exception {
112 | ObjectMapper mapper = new ObjectMapper()
113 | .enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)
114 | .setNodeFactory(new JsonNodeFactory(true));
115 |
116 | JsonNode newer = mapper.readTree("25.000");
117 | JsonNode older = mapper.readTree("24.444");
118 | JsonNode apply = JsonMergePatch.fromJson(newer, mapper).apply(older);
119 |
120 | assertEquals("25.000", apply.asText());
121 | }
122 | }
123 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/model/DataTypesTest.java:
--------------------------------------------------------------------------------
1 | package com.gravity9.jsonpatch.model;
2 |
3 | import com.fasterxml.jackson.core.JsonProcessingException;
4 | import com.fasterxml.jackson.databind.JsonNode;
5 | import com.fasterxml.jackson.databind.ObjectMapper;
6 | import com.gravity9.jsonpatch.JsonPatch;
7 | import com.gravity9.jsonpatch.JsonPatchException;
8 | import org.testng.annotations.Test;
9 |
10 | public class DataTypesTest {
11 |
12 | private final ObjectMapper objectMapper = new ObjectMapper();
13 |
14 | @Test
15 | void should_pass_test_operation_for_string_data_type() throws JsonProcessingException, JsonPatchException {
16 | // given
17 | SimpleModel simpleModel = new SimpleModel("test", 10, 100L, 10.56f, 10.56, true, new EmbeddedModel("embeddedValue"));
18 |
19 | // when
20 | String operation = "[{\"op\":\"test\",\"path\":\"/stringField\",\"value\":\"test\"}]";
21 | JsonPatch jsonPatch = objectMapper.readValue(operation, JsonPatch.class);
22 |
23 | JsonNode jsonNode = objectMapper.valueToTree(simpleModel);
24 |
25 | jsonPatch.apply(jsonNode);
26 | }
27 |
28 | @Test
29 | void should_pass_test_operation_for_float_data_type() throws JsonProcessingException, JsonPatchException {
30 | // given
31 | SimpleModel simpleModel = new SimpleModel("test", 10, 100L, 10.56f, 10.56, true, new EmbeddedModel("embeddedValue"));
32 |
33 | // when
34 | String operation = "[{\"op\":\"test\",\"path\":\"/floatField\",\"value\": 10.56}]";
35 | JsonPatch jsonPatch = objectMapper.readValue(operation, JsonPatch.class);
36 |
37 | JsonNode jsonNode = objectMapper.valueToTree(simpleModel);
38 |
39 | jsonPatch.apply(jsonNode);
40 | }
41 |
42 | @Test
43 | void should_pass_test_operation_for_int_data_type() throws JsonProcessingException, JsonPatchException {
44 | // given
45 | SimpleModel simpleModel = new SimpleModel("test", 10, 100L, 10.56f, 10.56, true, new EmbeddedModel("embeddedValue"));
46 |
47 | // when
48 | String operation = "[{\"op\":\"test\",\"path\":\"/intField\",\"value\": 10}]";
49 | JsonPatch jsonPatch = objectMapper.readValue(operation, JsonPatch.class);
50 |
51 | JsonNode jsonNode = objectMapper.valueToTree(simpleModel);
52 |
53 | jsonPatch.apply(jsonNode);
54 | }
55 |
56 | @Test
57 | void should_pass_test_operation_for_long_data_type() throws JsonProcessingException, JsonPatchException {
58 | // given
59 | SimpleModel simpleModel = new SimpleModel("test", 10, 100L, 10.56f, 10.56, true, new EmbeddedModel("embeddedValue"));
60 |
61 | // when
62 | String operation = "[{\"op\":\"test\",\"path\":\"/longField\",\"value\": 100}]";
63 | JsonPatch jsonPatch = objectMapper.readValue(operation, JsonPatch.class);
64 |
65 | JsonNode jsonNode = objectMapper.valueToTree(simpleModel);
66 |
67 | jsonPatch.apply(jsonNode);
68 | }
69 |
70 | @Test
71 | void should_pass_test_operation_for_double_data_type() throws JsonProcessingException, JsonPatchException {
72 | // given
73 | SimpleModel simpleModel = new SimpleModel("test", 10, 100L, 10.56f, 10.56, true, new EmbeddedModel("embeddedValue"));
74 |
75 | // when
76 | String operation = "[{\"op\":\"test\",\"path\":\"/doubleField\",\"value\": 10.56}]";
77 | JsonPatch jsonPatch = objectMapper.readValue(operation, JsonPatch.class);
78 |
79 | JsonNode jsonNode = objectMapper.valueToTree(simpleModel);
80 |
81 | jsonPatch.apply(jsonNode);
82 | }
83 |
84 | @Test
85 | void should_pass_test_operation_for_boolean_data_type() throws JsonProcessingException, JsonPatchException {
86 | // given
87 | SimpleModel simpleModel = new SimpleModel("test", 10, 100L, 10.56f, 10.56, true, new EmbeddedModel("embeddedValue"));
88 |
89 | // when
90 | String operation = "[{\"op\":\"test\",\"path\":\"/booleanField\",\"value\": true}]";
91 | JsonPatch jsonPatch = objectMapper.readValue(operation, JsonPatch.class);
92 |
93 | JsonNode jsonNode = objectMapper.valueToTree(simpleModel);
94 |
95 | jsonPatch.apply(jsonNode);
96 | }
97 |
98 | @Test
99 | void should_pass_test_operation_for_embedded_data_type() throws JsonProcessingException, JsonPatchException {
100 | // given
101 | SimpleModel simpleModel = new SimpleModel("test", 10, 100L, 10.56f, 10.56, true, new EmbeddedModel("embeddedValue"));
102 |
103 | // when
104 | String operation = "[{\"op\":\"test\",\"path\":\"/embeddedField\",\"value\": {\"embeddedField\": \"embeddedValue\"}}]";
105 | JsonPatch jsonPatch = objectMapper.readValue(operation, JsonPatch.class);
106 |
107 | JsonNode jsonNode = objectMapper.valueToTree(simpleModel);
108 |
109 | jsonPatch.apply(jsonNode);
110 | }
111 | }
112 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/model/EmbeddedModel.java:
--------------------------------------------------------------------------------
1 | package com.gravity9.jsonpatch.model;
2 |
3 | public class EmbeddedModel {
4 |
5 | private String embeddedField;
6 |
7 | public EmbeddedModel(String embeddedField) {
8 | this.embeddedField = embeddedField;
9 | }
10 |
11 | public String getEmbeddedField() {
12 | return embeddedField;
13 | }
14 |
15 | public void setEmbeddedField(String embeddedField) {
16 | this.embeddedField = embeddedField;
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/model/SimpleModel.java:
--------------------------------------------------------------------------------
1 | package com.gravity9.jsonpatch.model;
2 |
3 | public class SimpleModel {
4 |
5 | private String stringField;
6 |
7 | private int intField;
8 |
9 | private long longField;
10 |
11 | private float floatField;
12 |
13 | private double doubleField;
14 |
15 | private boolean booleanField;
16 |
17 | private EmbeddedModel embeddedField;
18 |
19 | public SimpleModel(String stringField, int intField, long longField, float floatField, double doubleField,
20 | boolean booleanField, EmbeddedModel embeddedField) {
21 | this.stringField = stringField;
22 | this.intField = intField;
23 | this.longField = longField;
24 | this.floatField = floatField;
25 | this.doubleField = doubleField;
26 | this.booleanField = booleanField;
27 | this.embeddedField = embeddedField;
28 | }
29 |
30 | public String getStringField() {
31 | return stringField;
32 | }
33 |
34 | public void setStringField(String stringField) {
35 | this.stringField = stringField;
36 | }
37 |
38 | public int getIntField() {
39 | return intField;
40 | }
41 |
42 | public void setIntField(int intField) {
43 | this.intField = intField;
44 | }
45 |
46 | public long getLongField() {
47 | return longField;
48 | }
49 |
50 | public void setLongField(long longField) {
51 | this.longField = longField;
52 | }
53 |
54 | public float getFloatField() {
55 | return floatField;
56 | }
57 |
58 | public void setFloatField(float floatField) {
59 | this.floatField = floatField;
60 | }
61 |
62 | public double getDoubleField() {
63 | return doubleField;
64 | }
65 |
66 | public void setDoubleField(double doubleField) {
67 | this.doubleField = doubleField;
68 | }
69 |
70 | public boolean isBooleanField() {
71 | return booleanField;
72 | }
73 |
74 | public void setBooleanField(boolean booleanField) {
75 | this.booleanField = booleanField;
76 | }
77 |
78 | public EmbeddedModel getEmbeddedField() {
79 | return embeddedField;
80 | }
81 |
82 | public void setEmbeddedField(EmbeddedModel embeddedField) {
83 | this.embeddedField = embeddedField;
84 | }
85 | }
86 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/serialization/AddOperationSerializationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.serialization;
21 |
22 | import com.gravity9.jsonpatch.AddOperation;
23 | import java.io.IOException;
24 |
25 | public final class AddOperationSerializationTest extends JsonPatchOperationSerializationTest {
26 |
27 | public AddOperationSerializationTest()
28 | throws IOException {
29 | super("add", AddOperation.class);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/serialization/CopyOperationSerializationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.serialization;
21 |
22 | import com.gravity9.jsonpatch.CopyOperation;
23 | import java.io.IOException;
24 |
25 | public final class CopyOperationSerializationTest extends JsonPatchOperationSerializationTest {
26 |
27 | public CopyOperationSerializationTest()
28 | throws IOException {
29 | super("copy", CopyOperation.class);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/serialization/JsonPatchOperationSerializationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.serialization;
21 |
22 | import com.fasterxml.jackson.databind.JsonNode;
23 | import com.fasterxml.jackson.databind.ObjectMapper;
24 | import com.github.fge.jackson.JacksonUtils;
25 | import com.github.fge.jackson.JsonLoader;
26 | import com.google.common.collect.Lists;
27 | import com.gravity9.jsonpatch.JsonPatchOperation;
28 | import java.io.IOException;
29 | import java.util.Iterator;
30 | import java.util.List;
31 |
32 | import com.gravity9.jsonpatch.jackson.JsonNumEquals;
33 | import org.testng.annotations.DataProvider;
34 | import org.testng.annotations.Test;
35 |
36 | import static org.testng.Assert.assertSame;
37 | import static org.testng.Assert.assertTrue;
38 |
39 | @Test
40 | public abstract class JsonPatchOperationSerializationTest {
41 |
42 | private static final JsonNumEquals EQUIVALENCE = JsonNumEquals.getInstance();
43 |
44 | private final Class c;
45 | private final JsonNode node;
46 | private final ObjectMapper mapper;
47 |
48 | protected JsonPatchOperationSerializationTest(final String prefix,
49 | final Class c)
50 | throws IOException {
51 | final String resource = "/jsonpatch/" + prefix + ".json";
52 | node = JsonLoader.fromResource(resource);
53 | mapper = JacksonUtils.newMapper();
54 | this.c = c;
55 | }
56 |
57 | @DataProvider
58 | public final Iterator getInputs() {
59 | final List list = Lists.newArrayList();
60 |
61 | for (final JsonNode n : node.get("errors"))
62 | list.add(new Object[]{n.get("op")});
63 |
64 | for (final JsonNode n : node.get("ops"))
65 | list.add(new Object[]{n.get("op")});
66 |
67 | return list.iterator();
68 | }
69 |
70 | @Test(dataProvider = "getInputs")
71 | public final void patchOperationSerializationWorks(final JsonNode input)
72 | throws IOException {
73 | /*
74 | * Deserialize a string input
75 | */
76 | final String in = input.toString();
77 | final JsonPatchOperation op
78 | = mapper.readValue(in, JsonPatchOperation.class);
79 |
80 | /*
81 | * Check that the class of the operation is what is expected
82 | */
83 | assertSame(op.getClass(), c);
84 |
85 | /*
86 | * Now, write the operation as a String...
87 | */
88 | final String out = mapper.writeValueAsString(op);
89 |
90 | /*
91 | * And read it as a JsonNode again, then test for equality.
92 | *
93 | * The reason we do that is that JSON does not guarantee the order of
94 | * object members; but JsonNode's .equals() method will correctly handle
95 | * this event, and we trust its .toString().
96 | */
97 | final JsonNode output = JacksonUtils.getReader().readTree(out);
98 | assertTrue(EQUIVALENCE.equivalent(input, output));
99 | }
100 | }
101 |
102 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/serialization/MoveOperationSerializationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.serialization;
21 |
22 | import com.gravity9.jsonpatch.MoveOperation;
23 | import java.io.IOException;
24 |
25 | public final class MoveOperationSerializationTest extends JsonPatchOperationSerializationTest {
26 |
27 | public MoveOperationSerializationTest()
28 | throws IOException {
29 | super("move", MoveOperation.class);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/serialization/RemoveOperationSerializationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.serialization;
21 |
22 | import com.gravity9.jsonpatch.RemoveOperation;
23 | import java.io.IOException;
24 |
25 | public final class RemoveOperationSerializationTest extends JsonPatchOperationSerializationTest {
26 |
27 | public RemoveOperationSerializationTest()
28 | throws IOException {
29 | super("remove", RemoveOperation.class);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/serialization/ReplaceOperationSerializationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.serialization;
21 |
22 | import com.gravity9.jsonpatch.ReplaceOperation;
23 | import java.io.IOException;
24 |
25 | public final class ReplaceOperationSerializationTest extends JsonPatchOperationSerializationTest {
26 |
27 | public ReplaceOperationSerializationTest()
28 | throws IOException {
29 | super("replace", ReplaceOperation.class);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/com/gravity9/jsonpatch/serialization/TestOperationSerializationTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (c) 2014, Francis Galiegue (fgaliegue@gmail.com)
3 | *
4 | * This software is dual-licensed under:
5 | *
6 | * - the Lesser General Public License (LGPL) version 3.0 or, at your option, any
7 | * later version;
8 | * - the Apache Software License (ASL) version 2.0.
9 | *
10 | * The text of this file and of both licenses is available at the root of this
11 | * project or, if you have the jar distribution, in directory META-INF/, under
12 | * the names LGPL-3.0.txt and ASL-2.0.txt respectively.
13 | *
14 | * Direct link to the sources:
15 | *
16 | * - LGPL 3.0: https://www.gnu.org/licenses/lgpl-3.0.txt
17 | * - ASL 2.0: http://www.apache.org/licenses/LICENSE-2.0.txt
18 | */
19 |
20 | package com.gravity9.jsonpatch.serialization;
21 |
22 | import com.gravity9.jsonpatch.TestOperation;
23 | import java.io.IOException;
24 |
25 | public final class TestOperationSerializationTest extends JsonPatchOperationSerializationTest {
26 |
27 | public TestOperationSerializationTest()
28 | throws IOException {
29 | super("test", TestOperation.class);
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/resources/jsonpatch/diff/diff.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "message": "empty patch if no changes in non-ignored fields",
4 | "first": {"id": 1, "name": "John"},
5 | "second": {"id": 2, "name": "John"},
6 | "ignoreFields": ["/id"],
7 | "patch": []
8 | },
9 | {
10 | "message": "empty patch if no changes in non-ignored fields",
11 | "first": {
12 | "id": 1,
13 | "name": "John",
14 | "address": {
15 | "city": "Warsaw",
16 | "street": "Street1",
17 | "houseNum": 1
18 | }
19 | },
20 | "second": {
21 | "id": 2,
22 | "name": "John",
23 | "address": {
24 | "city": "Warsaw",
25 | "street": "Street1",
26 | "houseNum": 2
27 | }
28 | },
29 | "ignoreFields": ["/id", "/address/houseNum"],
30 | "patch": []
31 | },
32 | {
33 | "message": "empty patch if object does not contain ignored field",
34 | "first": {
35 | "id": 1,
36 | "name": "John",
37 | "address": {
38 | "city": "Warsaw",
39 | "street": "Street1",
40 | "houseNum": 1
41 | }
42 | },
43 | "second": {
44 | "id": 2,
45 | "name": "John",
46 | "address": {
47 | "city": "Warsaw",
48 | "street": "Street1"
49 | }
50 | },
51 | "ignoreFields": ["/id", "/address/houseNum"],
52 | "patch": []
53 | },
54 | {
55 | "message": "empty patch if no changes in non-ignored fields",
56 | "first": {
57 | "id": 1,
58 | "name": "John",
59 | "address": {
60 | "city": "Warsaw",
61 | "street": "Street1",
62 | "houseNum": 1
63 | },
64 | "cars": ["Audi", "Mercedes", "BMW"]
65 | },
66 | "second": {
67 | "id": 2,
68 | "name": "John",
69 | "address": {
70 | "city": "Warsaw",
71 | "street": "Street1",
72 | "houseNum": 2
73 | },
74 | "cars": ["Audi", "Mercedes", "Skoda"]
75 | },
76 | "ignoreFields": ["/id", "/address/houseNum", "$.cars[-1:]"],
77 | "patch": []
78 | },
79 | {
80 | "message": "empty patch if no changes in non-ignored fields",
81 | "first": {
82 | "id": 1,
83 | "name": "John",
84 | "address": {
85 | "city": "Warsaw",
86 | "street": "Street1",
87 | "houseNum": 1
88 | },
89 | "cars": ["Audi", "Mercedes", "BMW"]
90 | },
91 | "second": {
92 | "id": 2,
93 | "name": "John",
94 | "address": {
95 | "city": "Warsaw",
96 | "street": "Street1",
97 | "houseNum": 2
98 | },
99 | "cars": ["Audi", "Mercedes", "Skoda"]
100 | },
101 | "ignoreFields": ["/id", "/address/houseNum", "/cars/2"],
102 | "patch": []
103 | },
104 | {
105 | "message": "empty patch if no changes in non-ignored fields",
106 | "first": [
107 | {"id": 1, "name": "John"},
108 | {"id": 2, "name": "John"}
109 | ],
110 | "second": [
111 | {"id": 2, "name": "John"},
112 | {"id": 3, "name": "John"}
113 | ],
114 | "ignoreFields": ["$..id"],
115 | "patch": []
116 | },
117 | {
118 | "message": "empty patch if no changes in non-ignored fields",
119 | "first": {
120 | "id": 1,
121 | "name": "John",
122 | "address": {
123 | "id": "3",
124 | "city": "Warsaw",
125 | "street": "Street1",
126 | "houseNum": 1
127 | },
128 | "cars": ["Audi", "Mercedes", "BMW"]
129 | },
130 | "second": {
131 | "id": 2,
132 | "name": "John",
133 | "address": {
134 | "id": "4",
135 | "city": "Warsaw",
136 | "street": "Street1",
137 | "houseNum": 1
138 | },
139 | "cars": ["Audi", "Mercedes", "BMW"]
140 | },
141 | "ignoreFields": ["$..id"],
142 | "patch": []
143 | },
144 | {
145 | "message": "Replace address id",
146 | "first": {
147 | "id": 1,
148 | "name": "John",
149 | "address": {
150 | "id": "3",
151 | "city": "Warsaw",
152 | "street": "Street1",
153 | "houseNum": 1
154 | },
155 | "cars": ["Audi", "Mercedes", "BMW"]
156 | },
157 | "second": {
158 | "id": 2,
159 | "name": "John",
160 | "address": {
161 | "id": "4",
162 | "city": "Warsaw",
163 | "street": "Street1",
164 | "houseNum": 1
165 | },
166 | "cars": ["Audi", "Mercedes", "BMW"]
167 | },
168 | "ignoreFields": ["$.id"],
169 | "patch": [{"op":"replace","path":"/address/id","value":"4"}]
170 | },
171 | {
172 | "message": "empty patch if no changes",
173 | "first": "hello",
174 | "second": "hello",
175 | "patch": []
176 | },
177 | {
178 | "message": "numeric values are treated as mathematically equal",
179 | "first": 1,
180 | "second": 1.0,
181 | "patch": []
182 | },
183 | {
184 | "message": "array members appended use special end-of-array pointer",
185 | "first": [ 1, 2, 3 ],
186 | "second": [ 1, 2, 3, 4, 5 ],
187 | "patch": [
188 | { "op": "add", "path": "/-", "value": 4 },
189 | { "op": "add", "path": "/-", "value": 5 }
190 | ]
191 | },
192 | {
193 | "message": "array members are correctly deleted",
194 | "first": [ 1, 2, 3 ],
195 | "second": [ 1 ],
196 | "patch": [
197 | { "op": "remove", "path": "/1" },
198 | { "op": "remove", "path": "/1" }
199 | ]
200 | },
201 | {
202 | "message": "single object member is deleted",
203 | "first": { "a": "b", "c": "d" },
204 | "second": { "a": "b" },
205 | "patch": [
206 | { "op": "remove", "path": "/c" }
207 | ]
208 | },
209 | {
210 | "message": "added object members are in natural order",
211 | "first": { "a": 1 },
212 | "second": { "a": 1, "c": 2, "b": 3, "d": 4 },
213 | "patch": [
214 | { "op": "add", "path": "/b", "value": 3 },
215 | { "op": "add", "path": "/c", "value": 2 },
216 | { "op": "add", "path": "/d", "value": 4 }
217 | ]
218 | },
219 | {
220 | "message": "single object value change is replaced",
221 | "first": { "a": null },
222 | "second": { "a": 6 },
223 | "patch": [
224 | { "op": "replace", "path": "/a", "value": 6 }
225 | ]
226 | },
227 | {
228 | "message": "full value replacement is accounted for",
229 | "first": [ 1, 2, 3 ],
230 | "second": { "hello": "world" },
231 | "patch": [
232 | { "op": "replace", "path": "", "value": { "hello": "world" } }
233 | ]
234 | },
235 | {
236 | "message": "embedded object addition/replacement works",
237 | "first": {
238 | "a": "b",
239 | "c": {
240 | "d": "e"
241 | }
242 | },
243 | "second": {
244 | "a": "b",
245 | "c": {
246 | "d": 1,
247 | "e": "f"
248 | }
249 | },
250 | "patch": [
251 | { "op": "add", "path": "/c/e", "value": "f" },
252 | { "op": "replace", "path": "/c/d", "value": 1 }
253 | ]
254 | },
255 | {
256 | "message": "embedded array addition/replacement works",
257 | "first": {
258 | "a": [ 1, 2, 3 ]
259 | },
260 | "second": {
261 | "a": [ "b", 2, 3, 4 ]
262 | },
263 | "patch": [
264 | { "op": "replace", "path": "/a/0", "value": "b" },
265 | { "op": "add", "path": "/a/-", "value": 4 }
266 | ]
267 | },
268 | {
269 | "message": "embedded object addition/replacement works (#2)",
270 | "first": [ { "a": "b" }, "foo", { "bar": null } ],
271 | "second": [ { "a": "b", "c": "d" }, "foo", { "bar": "baz" } ],
272 | "patch": [
273 | { "op": "add", "path": "/0/c", "value": "d" },
274 | { "op": "replace", "path": "/2/bar", "value": "baz" }
275 | ]
276 | },
277 | {
278 | "message": "embedded array addition/replacement works (#2)",
279 | "first": [ 1, [ 2, 3 ], 4 ],
280 | "second": [ "x", [ 2, 3, "y" ], 4 ],
281 | "patch": [
282 | { "op": "replace", "path": "/0", "value": "x" },
283 | { "op": "add", "path": "/1/-", "value": "y" }
284 | ]
285 | },
286 | {
287 | "message": "similar element is copied instead of added",
288 | "first": {
289 | "a": "c"
290 | },
291 | "second": {
292 | "a": "c",
293 | "d": "c"
294 | },
295 | "patch": [
296 | { "op": "copy", "path": "/d", "from": "/a" }
297 | ]
298 | },
299 | {
300 | "message": "similar element removed then added is moved instead",
301 | "first": { "a": "b" },
302 | "second": { "c": "b" },
303 | "patch": [
304 | { "op": "move", "path": "/c", "from": "/a" }
305 | ]
306 | }
307 | ]
--------------------------------------------------------------------------------
/src/test/resources/jsonpatch/diff/unchanged.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "first": 1,
4 | "second": null,
5 | "unchanged": {}
6 | },
7 | {
8 | "first": "hello",
9 | "second": "hello",
10 | "unchanged": { "": "hello" }
11 | },
12 | {
13 | "first": { "a": "b", "c": "d" },
14 | "second": { "a": "x", "c": "d" },
15 | "unchanged": { "/c": "d" }
16 | },
17 | {
18 | "first": [ "hello", "world", 31 ],
19 | "second": [ "goodbye", "world", 31 ],
20 | "unchanged": {
21 | "/1": "world",
22 | "/2": 31
23 | }
24 | },
25 | {
26 | "first": { "a": { "b": "c", "d": [ 1, 2 ] } },
27 | "second": { "a": { "b": "c", "d": [ 0, 2 ] } },
28 | "unchanged": { "/a/b": "c", "/a/d/1": 2 }
29 | },
30 | {
31 | "first": [ 1, 2, { "a": "b", "x": 3 } ],
32 | "second": [ 1, "ooo", { "a": 1, "x": 3 } ],
33 | "unchanged": {
34 | "/0": 1,
35 | "/2/x": 3
36 | }
37 | },
38 | {
39 | "first": [ "a", "b", "c" ],
40 | "second": [ "a", "b", "c" ],
41 | "unchanged": { "": [ "a", "b", "c" ] }
42 | }
43 | ]
--------------------------------------------------------------------------------
/src/test/resources/jsonpatch/mergepatch/patch-nonobject.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "patch": null,
4 | "victim": { "hello": "world" }
5 | },
6 | {
7 | "patch": "hello",
8 | "victim": {}
9 | },
10 | {
11 | "patch": [ 1, null, { "x": null } ],
12 | "victim": null
13 | }
14 | ]
--------------------------------------------------------------------------------
/src/test/resources/jsonpatch/mergepatch/patch-object.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "patch": { "a": "b" },
4 | "victim": { "c": "d" },
5 | "result": { "a": "b", "c": "d" }
6 | },
7 | {
8 | "patch": { "a": { "d": 1 } },
9 | "victim": { "a": { "d": 2 } },
10 | "result": { "a": { "d": 1 } }
11 | },
12 | {
13 | "patch": { "c": null },
14 | "victim": { "a": "b", "c": "d" },
15 | "result": { "a": "b" }
16 | },
17 | {
18 | "patch": { "a": { "d": null} },
19 | "victim": { "a": { "b": "c", "d": null} },
20 | "result": { "a": { "b": "c" } }
21 | },
22 | {
23 | "patch": {
24 | "a": 1000010002020389.8787987983
25 | },
26 | "victim": {
27 | "a": { "b": "c" },
28 | "d": "e"
29 | },
30 | "result": {
31 | "a": 1000010002020389.8787987983,
32 | "d": "e"
33 | }
34 | },
35 | {
36 | "patch": { "c": [ null ] },
37 | "victim": { "a": "b" },
38 | "result": { "a": "b", "c": [ null ] }
39 | },
40 | {
41 | "patch": { "a": { "b": "c", "d": null } },
42 | "victim": { "a": { "b": null, "d": 3}, "e": -1 },
43 | "result": { "a": { "b": "c" }, "e": -1 }
44 | },
45 | {
46 | "patch": { "a": "b", "c": null },
47 | "victim": "Hello world!",
48 | "result": { "a": "b" }
49 | },
50 | {
51 | "patch": { "foo": "bar " },
52 | "victim": true,
53 | "result": { "foo": "bar " }
54 | },
55 | {
56 | "patch": {
57 | "title": "Hello!",
58 | "phoneNumber": "+01-123-456-7890",
59 | "author": {
60 | "familyName": null
61 | },
62 | "tags": [ "example" ]
63 | },
64 | "victim": {
65 | "title": "Goodbye!",
66 | "author": {
67 | "givenName": "John",
68 | "familyName": "Doe"
69 | },
70 | "tags": [ "example", "sample" ],
71 | "content": "This will be unchanged"
72 | },
73 | "result": {
74 | "title": "Hello!",
75 | "author": {
76 | "givenName": "John"
77 | },
78 | "tags": [ "example" ],
79 | "content": "This will be unchanged",
80 | "phoneNumber": "+01-123-456-7890"
81 | }
82 | }
83 | ]
84 |
--------------------------------------------------------------------------------
/src/test/resources/jsonpatch/mergepatch/serdeser-nonobject.json:
--------------------------------------------------------------------------------
1 | [
2 | null,
3 | 1,
4 | 1.0,
5 | "",
6 | false,
7 | [ 1, 2, 3 ],
8 | [ { "c": "d", "e": null } ],
9 | 908129280192387897129837,
10 | 2391809809803123.29809180297409710294
11 | ]
--------------------------------------------------------------------------------
/src/test/resources/jsonpatch/mergepatch/serdeser-object.json:
--------------------------------------------------------------------------------
1 | [
2 | {
3 | "a": null,
4 | "b": 2398098098098323989.8223987987,
5 | "c": [ 1, { "x": null } ],
6 | "d": "hello"
7 | },
8 | {
9 | "foo": { "bar": "baz", "null": null }
10 | }
11 | ]
--------------------------------------------------------------------------------