Merge pull request #20 from HubSpot/upgrade-jackson

Upgrade Jackson to 2.10
HubSpot · Jan 27, 2020 · 9123eea · 9123eea
2 parents bc5ae1c + 4716642
commit 9123eea
Show file tree

Hide file tree

Showing 5 changed files with 338 additions and 3 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -5,8 +5,8 @@ jdk:
 
 env:
   - # use Jackson versions from POM
+  - JACKSON_VERSIONS="-Ddep.jackson.version=2.9.9 -Ddep.jackson-databind.version=2.9.9.3"
   - JACKSON_VERSIONS="-Ddep.jackson.version=2.9.10 -Ddep.jackson-databind.version=2.9.10.2"
-  - JACKSON_VERSIONS="-Ddep.jackson.version=2.10.2 -Ddep.jackson-databind.version=2.10.2"
 
 script: mvn -B -q verify $JACKSON_VERSIONS
 

diff --git a/pom.xml b/pom.xml
@@ -14,8 +14,8 @@
   <description>JAX-RS MessageBodyWriter that supports filtering via query parameters</description>
 
   <properties>
-    <dep.jackson.version>2.9.9</dep.jackson.version>
-    <dep.jackson-databind.version>2.9.9.3</dep.jackson-databind.version>
+    <dep.jackson.version>2.10.2</dep.jackson.version>
+    <dep.jackson-databind.version>2.10.2</dep.jackson-databind.version>
     <dep.jaxb.version>2.3.2</dep.jaxb.version>
 
     <dep.plugin.duplicate-finder.version>1.3.0</dep.plugin.duplicate-finder.version>

diff --git a/src/main/java/com/hubspot/jackson/jaxrs/PropertyFilteringJsonGenerator.java b/src/main/java/com/hubspot/jackson/jaxrs/PropertyFilteringJsonGenerator.java
@@ -45,6 +45,26 @@ public void writeStartArray(int size) throws IOException {
     }
   }
 
+  @Override
+  public void writeStartArray(Object forValue) throws IOException {
+    if (itemFilter == null) {
+      filterContext = filterContext.createChildArrayContext(null, false);
+    } else {
+      filterContext = filterContext.createChildArrayContext(itemFilter, true);
+      delegate.writeStartArray(forValue);
+    }
+  }
+
+  @Override
+  public void writeStartArray(Object forValue, int size) throws IOException {
+    if (itemFilter == null) {
+      filterContext = filterContext.createChildArrayContext(null, false);
+    } else {
+      filterContext = filterContext.createChildArrayContext(itemFilter, true);
+      delegate.writeStartArray(forValue, size);
+    }
+  }
+
   @Override
   public void writeEndArray() throws IOException {
     filterContext = filterContext.closeArray(delegate);
@@ -74,6 +94,16 @@ public void writeStartObject(Object forValue) throws IOException {
     }
   }
 
+  @Override
+  public void writeStartObject(Object forValue, int size) throws IOException {
+    if (itemFilter == null) {
+      filterContext = filterContext.createChildObjectContext(itemFilter, false);
+    } else {
+      filterContext = filterContext.createChildObjectContext(itemFilter, true);
+      delegate.writeStartObject(forValue, size);
+    }
+  }
+
   @Override
   public void writeEndObject() throws IOException {
     filterContext = filterContext.closeObject(delegate);

diff --git a/src/test/java/com/hubspot/jackson/jaxrs/ArrayIntegrationTest.java b/src/test/java/com/hubspot/jackson/jaxrs/ArrayIntegrationTest.java
@@ -0,0 +1,249 @@
+package com.hubspot.jackson.jaxrs;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.hubspot.jackson.jaxrs.util.TestResource.TestArrayObject;
+import com.hubspot.jackson.jaxrs.util.TestResource.TestNestedObject;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+
+public class ArrayIntegrationTest extends BaseTest {
+
+  private static final TypeReference<List<TestArrayObject>> LIST_ARRAY_TYPE = new TypeReference<List<TestArrayObject>>() {};
+  private static final TypeReference<Map<Long, TestArrayObject>> MAP_ARRAY_TYPE = new TypeReference<Map<Long, TestArrayObject>>() {};
+  private static final TypeReference<TestArrayObject> ARRAY_OBJECT_TYPE = new TypeReference<TestArrayObject>() {};
+
+  @Test
+  public void testArrayList() throws IOException {
+    List<TestArrayObject> objects = getObjects(LIST_ARRAY_TYPE, "/array/list", "property", "id,nested.secondNested.name");
+
+    assertThat(objects).hasSize(10);
+    for (int i = 0; i < 10; i++) {
+      assertThat(objects.get(i).getId()).isEqualTo((long) i);
+      assertThat(objects.get(i).getName()).isNull();
+
+      assertThat(objects.get(i).getNested()).hasSize(10);
+      for (int j = 0; j < 10; j++) {
+        TestNestedObject nested = objects.get(i).getNested().get(j);
+
+        assertThat(nested.getNested()).isNull();
+
+        assertThat(nested.getSecondNested().getName()).isEqualTo("SecondNested Test " + (i + j) * 1_000);
+        assertThat(nested.getSecondNested().getId()).isNull();
+      }
+    }
+  }
+
+  @Test
+  public void testArrayListWithExclusion() throws IOException {
+    List<TestArrayObject> objects = getObjects(LIST_ARRAY_TYPE, "/array/list", "property", "!nested.secondNested");
+
+    assertThat(objects).hasSize(10);
+    for (int i = 0; i < 10; i++) {
+      assertThat(objects.get(i).getId()).isEqualTo((long) i);
+      assertThat(objects.get(i).getName()).isEqualTo("Test " + i);
+
+      assertThat(objects.get(i).getNested()).hasSize(10);
+      for (int j = 0; j < 10; j++) {
+        TestNestedObject nested = objects.get(i).getNested().get(j);
+
+        assertThat(nested.getNested().getName()).isEqualTo("Nested Test " + (i + j) * 100);
+        assertThat(nested.getNested().getId()).isEqualTo((i + j) * 100);
+
+        assertThat(nested.getSecondNested()).isNull();
+      }
+    }
+  }
+
+  @Test
+  public void testArrayObject() throws IOException {
+    Map<Long, TestArrayObject> objects = getObjects(MAP_ARRAY_TYPE, "/array/object", "property", "*.name");
+
+    assertThat(objects).hasSize(10);
+    for (long i = 0; i < 10; i++) {
+      assertThat(objects).containsKeys(i);
+
+      TestArrayObject object = objects.get(i);
+
+      assertThat(object.getId()).isNull();
+      assertThat(object.getName()).isEqualTo("Test " + i);
+
+      assertThat(object.getNested()).isNull();
+    }
+  }
+
+  @Test
+  public void testArrayWithoutPrefix() throws IOException {
+    // no prefix, should select root properties
+    TestArrayObject object = getObjects(ARRAY_OBJECT_TYPE, "/array", "property", "id,name");
+
+    assertThat(object.getNested()).isNull();
+    assertThat(object.getId()).isEqualTo(1);
+    assertThat(object.getName()).isEqualTo("Test 1");
+  }
+
+  @Test
+  public void testArrayExclusions() throws IOException {
+    Map<Long, TestArrayObject> objects = getObjects(MAP_ARRAY_TYPE, "/array/object", "property", "!*.name");
+
+    assertThat(objects).hasSize(10);
+    for (long i = 0; i < 10; i++) {
+      assertThat(objects).containsKeys(i);
+
+      TestArrayObject object = objects.get(i);
+
+      assertThat(object.getId()).isEqualTo(i);
+      assertThat(object.getName()).isNull();
+
+      assertThat(object.getNested()).hasSize(10);
+      for (int j = 0; j < 10; j++) {
+        TestNestedObject nested = object.getNested().get(j);
+
+        assertThat(nested.getNested().getName()).isEqualTo("Nested Test " + (i + j) * 100);
+        assertThat(nested.getNested().getId()).isEqualTo((i + j) * 100);
+
+        assertThat(nested.getSecondNested().getName()).isEqualTo("SecondNested Test " + (i + j) * 1_000);
+        assertThat(nested.getSecondNested().getId()).isEqualTo((i + j) * 1_000);
+      }
+    }
+  }
+
+  @Test
+  public void testSecondLevelWildcard() throws IOException {
+    Map<Long, TestArrayObject> objects = getObjects(MAP_ARRAY_TYPE, "/array/object", "property", "9.*");
+
+    assertThat(objects).containsOnlyKeys(9L);
+
+    TestArrayObject object = objects.get(9L);
+
+    assertThat(object.getId()).isEqualTo(9L);
+    assertThat(object.getName()).isEqualTo("Test 9");
+
+    assertThat(object.getNested()).hasSize(10);
+    for (int j = 0; j < 10; j++) {
+      TestNestedObject nested = object.getNested().get(j);
+
+      assertThat(nested.getNested().getName()).isEqualTo("Nested Test " + (j + 9) * 100);
+      assertThat(nested.getNested().getId()).isEqualTo((j + 9) * 100);
+
+      assertThat(nested.getSecondNested().getName()).isEqualTo("SecondNested Test " + (j + 9) * 1_000);
+      assertThat(nested.getSecondNested().getId()).isEqualTo((j + 9) * 1_000);
+    }
+  }
+
+  @Test
+  public void testSecondLevelWildcardExclusion() throws IOException {
+    Map<Long, TestArrayObject> objects = getObjects(MAP_ARRAY_TYPE, "/array/object", "property", "!9.*");
+
+    assertThat(objects).containsKeys(9L);
+    assertThat(objects.get(9L).getId()).isNull();
+    assertThat(objects.get(9L).getName()).isNull();
+    assertThat(objects.get(9L).getNested()).isNull();
+
+    for (long i = 0; i < 9; i++) {
+      assertThat(objects).containsKeys(i);
+
+      TestArrayObject object = objects.get(i);
+
+      assertThat(object.getId()).isEqualTo(i);
+      assertThat(object.getName()).isEqualTo("Test " + i);
+
+      assertThat(object.getNested()).hasSize(10);
+      for (int j = 0; j < 10; j++) {
+        TestNestedObject nested = object.getNested().get(j);
+
+        assertThat(nested.getNested().getName()).isEqualTo("Nested Test " + (i + j) * 100);
+        assertThat(nested.getNested().getId()).isEqualTo((i + j) * 100);
+
+        assertThat(nested.getSecondNested().getName()).isEqualTo("SecondNested Test " + (i + j) * 1_000);
+        assertThat(nested.getSecondNested().getId()).isEqualTo((i + j) * 1_000);
+      }
+    }
+  }
+
+  @Test
+  public void testMiddleLevelWildcard() throws IOException {
+    Map<Long, TestArrayObject> objects = getObjects(MAP_ARRAY_TYPE, "/array/object", "property", "9.*.*.name");
+
+    assertThat(objects).containsOnlyKeys(9L);
+    TestArrayObject object = objects.get(9L);
+
+    assertThat(object.getId()).isEqualTo(9L);
+    assertThat(object.getName()).isEqualTo("Test 9");
+
+    assertThat(object.getNested()).hasSize(10);
+    for (int j = 0; j < 10; j++) {
+      TestNestedObject nested = object.getNested().get(j);
+
+      assertThat(nested.getNested().getName()).isEqualTo("Nested Test " + (j + 9) * 100);
+      assertThat(nested.getNested().getId()).isNull();
+
+      assertThat(nested.getSecondNested().getName()).isEqualTo("SecondNested Test " + (j + 9) * 1_000);
+      assertThat(nested.getSecondNested().getId()).isNull();
+    }
+  }
+
+  @Test
+  public void testMiddleLevelWildcardExclusion() throws IOException {
+    Map<Long, TestArrayObject> objects = getObjects(MAP_ARRAY_TYPE, "/array/object", "property", "!9.*.*.name");
+
+    assertThat(objects).containsKeys(9L);
+    TestArrayObject object = objects.get(9L);
+
+    assertThat(object.getId()).isEqualTo(9L);
+    assertThat(object.getName()).isEqualTo("Test 9");
+
+    assertThat(objects.get(9L).getNested()).hasSize(10);
+    for (int j = 0; j < 10; j++) {
+      TestNestedObject nested = object.getNested().get(j);
+
+      assertThat(nested.getNested().getName()).isNull();
+      assertThat(nested.getNested().getId()).isEqualTo((j + 9) * 100);
+
+      assertThat(nested.getSecondNested().getName()).isNull();
+      assertThat(nested.getSecondNested().getId()).isEqualTo((j + 9) * 1_000);
+    }
+
+    for (long i = 0; i < 9; i++) {
+      assertThat(objects).containsKeys(i);
+
+      object = objects.get(i);
+
+      assertThat(object.getId()).isEqualTo(i);
+      assertThat(object.getName()).isEqualTo("Test " + i);
+
+      assertThat(object.getNested()).hasSize(10);
+      for (int j = 0; j < 10; j++) {
+        TestNestedObject nested = object.getNested().get(j);
+
+        assertThat(nested.getNested().getName()).isEqualTo("Nested Test " + (i + j) * 100);
+        assertThat(nested.getNested().getId()).isEqualTo((i + j) * 100);
+
+        assertThat(nested.getSecondNested().getName()).isEqualTo("SecondNested Test " + (i + j) * 1_000);
+        assertThat(nested.getSecondNested().getId()).isEqualTo((i + j) * 1_000);
+      }
+    }
+  }
+
+  @Test
+  public void testArrayObjectWithMultiplePropertyLevels() throws IOException {
+    Map<Long, TestArrayObject> objects = getObjects(MAP_ARRAY_TYPE, "/array/object", "property", "*.name,9.id");
+
+    assertThat(objects).hasSize(10);
+    for (long i = 0; i < 9; i++) {
+      assertThat(objects).containsKeys(i);
+
+      assertThat(objects.get(i).getId()).isNull();
+      assertThat(objects.get(i).getName()).isEqualTo("Test " + i);
+      assertThat(objects.get(i).getNested()).isNull();
+    }
+
+    assertThat(objects).containsKeys(9L);
+    assertThat(objects.get(9L).getId()).isEqualTo(9L);
+    assertThat(objects.get(9L).getName()).isEqualTo("Test 9");
+    assertThat(objects.get(9L).getNested()).isNull();
+  }
+}
diff --git a/src/test/java/com/hubspot/jackson/jaxrs/util/TestResource.java b/src/test/java/com/hubspot/jackson/jaxrs/util/TestResource.java
@@ -71,6 +71,31 @@ public Map<Long, TestObject> getNestedObjectsMap() {
     return result;
   }
 
+  @GET
+  @Path("/array/list")
+  @PropertyFiltering
+  public List<TestArrayObject> getArrayObjectsList() {
+    return getArrayObjects();
+  }
+
+  @GET
+  @Path("/array")
+  @PropertyFiltering
+  public TestArrayObject getArrayObject() {
+    return getArrayObject(1);
+  }
+
+  @GET
+  @Path("/array/object")
+  @PropertyFiltering
+  public Map<Long, TestArrayObject> getArrayObjectsMap() {
+    Map<Long, TestArrayObject> result = new HashMap<>();
+    for (TestArrayObject testArrayObject : getArrayObjects()) {
+      result.put(testArrayObject.getId(), testArrayObject);
+    }
+    return result;
+  }
+
   @GET
   @Path("/prefix")
   @PropertyFiltering(prefix = "nested")
@@ -110,6 +135,24 @@ private static List<TestNestedObject> getNestedObjects() {
     return objects;
   }
 
+  private static TestArrayObject getArrayObject(long i) {
+    List<TestNestedObject> nested = new ArrayList<>();
+    for (long j = i; j < i + 10; j++) {
+      nested.add(getNestedObject(j));
+    }
+
+    return new TestArrayObject(i, "Test " + i, nested);
+  }
+
+  private static List<TestArrayObject> getArrayObjects() {
+    List<TestArrayObject> objects = new ArrayList<>();
+    for (long i = 0; i < 10; i++) {
+      objects.add(getArrayObject(i));
+    }
+
+    return objects;
+  }
+
   public interface TestView {}
   public interface OtherView {}
 
@@ -150,4 +193,17 @@ public TestObject getSecondNested() {
       return secondNested;
     }
   }
+
+  public static class TestArrayObject extends TestObject {
+    private final List<TestNestedObject> nested;
+
+    public TestArrayObject(@JsonProperty("id") Long id, @JsonProperty("name") String name, @JsonProperty("nested") List<TestNestedObject> nested) {
+      super(id, name);
+      this.nested = nested;
+    }
+
+    public List<TestNestedObject> getNested() {
+      return nested;
+    }
+  }
 }