Feature/concurrency tests

src/main/java/io/datanerds/avropatch/Patch.java

@@ -25,8 +25,7 @@ public class Patch {
     private final List<Operation> operations;
 
     public Patch() {
-        operations = new ArrayList<>();
-        headers = new HashMap<>();
+        this(new ArrayList<>(), new HashMap<>());
     }
 
     public Patch(List<Operation> operations) {

src/main/java/io/datanerds/avropatch/operation/Add.java

@@ -16,9 +16,9 @@ public final class Add<T> implements Operation {
     @AvroSchema(DefaultSchema.VALUE)
     public final T value;
 
+    @SuppressWarnings("unused") // no arg constructor needed by Avro
     private Add() {
-        this.path = null;
-        this.value = null;
+        this(null, null);
     }
 
     /**

src/main/java/io/datanerds/avropatch/operation/Copy.java

@@ -13,9 +13,9 @@ public final class Copy implements Operation {
     public final Path from;
     public final Path path;
 
+    @SuppressWarnings("unused") // no arg constructor needed by Avro
     private Copy() {
-        from = null;
-        path = null;
+        this(null, null);
     }
 
     /**

src/main/java/io/datanerds/avropatch/operation/Move.java

@@ -13,9 +13,9 @@ public final class Move implements Operation {
     public final Path from;
     public final Path path;
 
+    @SuppressWarnings("unused") // no arg constructor needed by Avro
     private Move() {
-        this.from = null;
-        this.path = null;
+        this(null, null);
     }
 
     /**

src/main/java/io/datanerds/avropatch/operation/Remove.java

@@ -12,8 +12,9 @@ public final class Remove implements Operation {
     public static final String op = "remove";
     public final Path path;
 
+    @SuppressWarnings("unused") // no arg constructor needed by Avro
     private Remove() {
-        this.path = null;
+        this(null);
     }
 
     /**

src/main/java/io/datanerds/avropatch/operation/Replace.java

@@ -15,9 +15,9 @@ public final class Replace<T> implements Operation {
     @AvroSchema(DefaultSchema.VALUE)
     public final T value;
 
+    @SuppressWarnings("unused") // no arg constructor needed by Avro
     private Replace() {
-        this.path = null;
-        this.value = null;
+        this(null, null);
     }
 
     /**

src/main/java/io/datanerds/avropatch/operation/Test.java

@@ -15,9 +15,9 @@ public final class Test<T> implements Operation {
     @AvroSchema(DefaultSchema.VALUE)
     public final T value;
 
+    @SuppressWarnings("unused") // no arg constructor needed by Avro
     private Test() {
-        this.path = null;
-        this.value = null;
+        this(null, null);
     }
 
     /**

src/main/java/io/datanerds/avropatch/schema/CustomTypes.java

@@ -31,9 +31,7 @@ public interface CustomTypes {
 
     interface PatchType {
         String NAME = Patch.class.getSimpleName();
-        String DOC = "This record represents a JSON PATCH operation holding a sequence of operations to apply to a"
-                + " given object.";
-
+        String DOC = "This record represents a PATCH holding a sequence of operations to apply to a given object.";
         static Schema create(Schema valueSchema) {
             Schema.Field operations = new Schema.Field("operations",
                     Schema.createArray(OperationTypes.Operation.create(valueSchema)),

src/main/java/io/datanerds/avropatch/serialization/CustomTypeSerializer.java

@@ -33,8 +33,8 @@ public final class CustomTypeSerializer {
 
     private CustomTypeSerializer(Schema schema) {
         Objects.nonNull(schema);
-        writer = AvroData.get().createDatumWriter(schema);
-        reader = AvroData.get().createDatumReader(schema);
+        this.writer = AvroData.get().createDatumWriter(schema);
+        this.reader = AvroData.get().createDatumReader(schema);
     }
 
     public byte[] toBytes(Patch value) throws IOException {
@@ -49,10 +49,10 @@ public Patch toObject(byte[] bytes) throws IOException {
     }
 
     public static class Builder {
-        final List<Schema> types = new ArrayList<>();
+        protected final List<Schema> types;
 
         public Builder() {
-            AvroData.get();
+            this.types = new ArrayList<>();
         }
 
         public Builder nullable() {

src/main/java/io/datanerds/avropatch/value/conversion/AvroData.java

@@ -8,10 +8,11 @@
 
 public final class AvroData extends ReflectData {
 
-    public static List<Conversion<?>> CONVERTERS =
-            ImmutableList.of(new DateConversion(), new BigIntegerConversion(), new BigDecimalConversion(),
-                    new UUIDConversion());
-
+    public static final List<Conversion<?>> CONVERTERS = ImmutableList.of(
+            new DateConversion(),
+            new BigIntegerConversion(),
+            new BigDecimalConversion(),
+            new UUIDConversion());
     private static final AvroData INSTANCE = new AvroData();
 
     private AvroData() {

src/main/java/io/datanerds/avropatch/value/conversion/BigDecimalConversion.java

@@ -12,7 +12,7 @@
 import java.math.BigInteger;
 
 /**
- * This class converts an {@link BigDecimal} value into am Avro {@link IndexedRecord} and back. It depends on
+ * This class converts a {@link BigDecimal} value into an Avro {@link IndexedRecord} and back. It depends on
  * {@link BigIntegerConversion} since it serializes the {@link BigDecimal}s unscaled value into a {@link BigInteger} and
  * its scale into an {@link Integer}.
  * Also, its logical type is statically registered in {@link LogicalTypes}, because it introduces a new custom type name

src/test/java/io/datanerds/avropatch/PatchTest.java

@@ -88,7 +88,8 @@ public void serializesTest() throws IOException {
 
     @Test
     public void serializesBunchOfOperations() throws IOException {
-        Patch patch = new Patch(ImmutableList.of(new Add<>(Path.of("person", "name"), "John Doe"),
+        Patch patch = new Patch(ImmutableList.of(
+                new Add<>(Path.of("person", "name"), "John Doe"),
                 new Copy(Path.parse("/person/firstName"), Path.parse("/person/lastName")),
                 new Move(Path.parse("/person/firstName"), Path.parse("/person/lastName")),
                 new Remove(Path.parse("/person/name")),
@@ -103,7 +104,8 @@ public void serializesBunchOfOperations() throws IOException {
     public void serializesDefaultValueTypes() throws IOException {
         Date date = new Date();
         UUID uuid = UUID.randomUUID();
-        Patch patch = new Patch(ImmutableList.of(new Add<>(Path.of("some", "value"), "John Doe"),
+        Patch patch = new Patch(ImmutableList.of(
+                new Add<>(Path.of("some", "value"), "John Doe"),
                 new Add<>(Path.of("some", "value"), 42),
                 new Add<>(Path.of("some", "value"), 42L),
                 new Add<>(Path.of("some", "value"), uuid),
@@ -118,19 +120,28 @@ public void serializesDefaultValueTypes() throws IOException {
     }
 
     @Test
-    public void serializesArbitraryHeaders() throws IOException {
-        Patch patch = new Patch(Collections.EMPTY_LIST, ImmutableMap.of("header 1", UUID.randomUUID(),
-                "header 2", new Date(), "header 3", 1234L, "header 4", new BigDecimal("3214123453.123512345")));
-
+    public void serializesArbitraryHeadersWithoutOperations() throws IOException {
+        Patch patch = new Patch(Collections.EMPTY_LIST,
+                ImmutableMap.of(
+                        "header 1", UUID.randomUUID(),
+                        "header 2", new Date(),
+                        "header 3", 1234L,
+                        "header 4", new BigDecimal("3214123453.123512345")));
         byte[] bytes = patch.toBytes();
         assertThat(patch, is(equalTo(Patch.of(bytes))));
+    }
 
-        patch = new Patch(ImmutableList.of(new Copy(Path.of("from", "here"), Path.of("to", "there")),
-                new Move(Path.of("from", "here"), Path.of("to", "there"))),
-                ImmutableMap.of("header 1", UUID.randomUUID(),
-                        "header 2", new Date(), "header 3", 1234L, "header 4", new BigDecimal("3214123453.123512345")));
-
-        bytes = patch.toBytes();
+    @Test
+    public void serializesArbitraryHeadersWithOperations() throws IOException {
+        Patch patch = new Patch(ImmutableList.of(
+                    new Copy(Path.of("from", "here"), Path.of("to", "there")),
+                    new Move(Path.of("from", "here"), Path.of("to", "there"))),
+                ImmutableMap.of(
+                        "header 1", UUID.randomUUID(),
+                        "header 2", new Date(),
+                        "header 3", 1234L,
+                        "header 4", new BigDecimal("3214123453.123512345")));
+        byte[] bytes = patch.toBytes();;
         assertThat(patch, is(equalTo(Patch.of(bytes))));
     }
 

src/test/java/io/datanerds/avropatch/operation/matcher/OperationMatchers.java

@@ -8,6 +8,7 @@
 
 import java.util.*;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import static org.hamcrest.core.AllOf.allOf;
 
@@ -45,12 +46,9 @@ public static <T extends Operation> Matcher<Iterable<T>> hasItems(T... items) {
     }
 
     public static <T extends Operation> Matcher<Iterable<T>> hasItems(List<T> items) {
-        List<Matcher<? super Iterable<T>>> all = new ArrayList<Matcher<? super Iterable<T>>>(items.size());
-        for (T element : items) {
-            all.add(hasItem(element));
-        }
-
-        return allOf(all);
+        return allOf(items.stream()
+                .map(item -> hasItem(item))
+                .collect(Collectors.toList()));
     }
 
     public static <T extends Operation> Matcher<List<T>> hasItemsOrdered(List<T> expected) {

src/test/java/io/datanerds/avropatch/operation/matcher/PatchMatcher.java

@@ -1,25 +1,11 @@
 package io.datanerds.avropatch.operation.matcher;
 
 import com.google.common.base.Joiner;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
 import io.datanerds.avropatch.Patch;
-import io.datanerds.avropatch.operation.Copy;
-import io.datanerds.avropatch.operation.Move;
-import io.datanerds.avropatch.operation.Operation;
-import io.datanerds.avropatch.operation.Path;
 import org.hamcrest.CustomTypeSafeMatcher;
 import org.hamcrest.Matcher;
-import org.junit.Test;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.UUID;
 
 import static io.datanerds.avropatch.operation.matcher.OperationMatchers.hasItemsOrdered;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.AllOf.allOf;
 
 public class PatchMatcher {
@@ -55,33 +41,4 @@ protected boolean matchesSafely(Patch item) {
             }
         };
     }
-
-    @Test
-    public void headers() throws IOException {
-        UUID uuid = UUID.randomUUID();
-        Patch patch = new Patch(Collections.EMPTY_LIST, ImmutableMap.of("header 1", uuid));
-        Patch patch2 = new Patch(Collections.EMPTY_LIST, ImmutableMap.of("header 1", uuid));
-        Patch patch3 = new Patch(Collections.EMPTY_LIST, ImmutableMap.of("header 2", uuid));
-        Patch patch4 = new Patch(Collections.EMPTY_LIST, ImmutableMap.of("header 1", UUID.randomUUID()));
-
-        assertThat(patch, is(equalTo(patch2)));
-        assertThat(patch2, is(equalTo(patch)));
-        assertThat(patch, is(not(equalTo(patch3))));
-        assertThat(patch, is(not(equalTo(patch4))));
-    }
-
-    @Test
-    public void operations() throws IOException {
-        Operation operation1 = new Copy(Path.of("from", "here"), Path.of("to", "there"));
-        Operation operation2 = new Move(Path.of("from", "here"), Path.of("to", "there"));
-        Patch patch1 = new Patch(ImmutableList.of(operation1, operation2), Collections.EMPTY_MAP);
-        Patch patch2 = new Patch(ImmutableList.of(operation1, operation2), Collections.EMPTY_MAP);
-        Patch patch3 = new Patch(ImmutableList.of(operation1), Collections.EMPTY_MAP);
-        Patch patch4 = new Patch(ImmutableList.of(operation2, operation1), Collections.EMPTY_MAP);
-
-        assertThat(patch1, is(equalTo(patch2)));
-        assertThat(patch2, is(equalTo(patch1)));
-        assertThat(patch1, is(not(equalTo(patch3))));
-        assertThat(patch1, is(not(equalTo(patch4))));
-    }
 }

src/test/java/io/datanerds/avropatch/operation/matcher/PatchMatcherTest.java

@@ -0,0 +1,67 @@
+package io.datanerds.avropatch.operation.matcher;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.datanerds.avropatch.Patch;
+import io.datanerds.avropatch.operation.Copy;
+import io.datanerds.avropatch.operation.Move;
+import io.datanerds.avropatch.operation.Operation;
+import io.datanerds.avropatch.operation.Path;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.UUID;
+
+import static io.datanerds.avropatch.operation.matcher.PatchMatcher.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+@RunWith(Enclosed.class)
+public class PatchMatcherTest {
+
+    public static class Headers {
+        private final UUID uuid = UUID.randomUUID();
+        private final Patch patchWithHeader = new Patch(Collections.EMPTY_LIST, ImmutableMap.of("header", uuid));
+        private final Patch patchWithHeaderSibling = new Patch(Collections.EMPTY_LIST, ImmutableMap.of("header", uuid));
+        private final Patch differentHeader = new Patch(Collections.EMPTY_LIST, ImmutableMap.of("header 2", uuid));
+        private final Patch differentHeaderValue = new Patch(Collections.EMPTY_LIST,
+                ImmutableMap.of("header", UUID.randomUUID()));
+
+        @Test
+        public void equality() throws IOException {
+            assertThat(patchWithHeader, is(equalTo(patchWithHeaderSibling)));
+            assertThat(patchWithHeaderSibling, is(equalTo(patchWithHeader)));
+        }
+
+        @Test
+        public void inequality() throws IOException {
+            assertThat(patchWithHeader, is(not(equalTo(differentHeader))));
+            assertThat(patchWithHeader, is(not(equalTo(differentHeaderValue))));
+        }
+    }
+
+    public static class Operations {
+        private final Operation copy = new Copy(Path.of("from", "here"), Path.of("to", "there"));
+        private final Operation move = new Move(Path.of("from", "here"), Path.of("to", "there"));
+        private final Patch copyMovePatch = new Patch(ImmutableList.of(copy, move), Collections.EMPTY_MAP);
+        private final Patch copyMovePatchSibling = new Patch(ImmutableList.of(copy, move), Collections.EMPTY_MAP);
+        private final Patch withoutMoveOperation = new Patch(ImmutableList.of(copy), Collections.EMPTY_MAP);
+        private final Patch reverseOperationOrder = new Patch(ImmutableList.of(move, copy), Collections.EMPTY_MAP);
+
+        @Test
+        public void equality() throws IOException {
+            assertThat(copyMovePatch, is(equalTo(copyMovePatchSibling)));
+            assertThat(copyMovePatchSibling, is(equalTo(copyMovePatch)));
+        }
+
+        @Test
+        public void inequality() throws IOException {
+            assertThat(copyMovePatch, is(not(equalTo(withoutMoveOperation))));
+            assertThat(copyMovePatch, is(not(equalTo(reverseOperationOrder))));
+        }
+    }
+}