Add json enricher and json field filter

scm-webapp/src/test/java/sonia/scm/api/rest/JSONContextResolverTest.java

@@ -59,7 +59,7 @@ import static org.junit.Assert.*;
  */
 public class JSONContextResolverTest {
 
-  private final ObjectMapper mapper = new JSONContextResolver().getContext(Object.class);
+  private final ObjectMapper mapper = new ObjectMapperProvider().get();
 
   /**
    * Tests json unmarshalling with unknown properties.

scm-webapp/src/test/java/sonia/scm/api/v2/FieldContainerResponseFilterTest.java

@@ -0,0 +1,85 @@
+package sonia.scm.api.v2;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.Lists;
+import com.google.common.io.Resources;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerResponseContext;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.UriInfo;
+import java.io.IOException;
+import java.net.URL;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class FieldContainerResponseFilterTest {
+
+  private final ObjectMapper objectMapper = new ObjectMapper();
+
+  @Mock
+  private ContainerRequestContext requestContext;
+
+  @Mock
+  private ContainerResponseContext responseContext;
+
+  private FieldContainerResponseFilter filter = new FieldContainerResponseFilter();
+
+  @Test
+  public void testFilter() throws IOException {
+    applyFields("one");
+    JsonNode node = applyEntity("filter-test-002");
+
+    filter.filter(requestContext, responseContext);
+
+    assertEquals("{\"one\":1}", objectMapper.writeValueAsString(node));
+  }
+
+  @Test
+  public void testFilterWithMultiple() throws IOException {
+    applyFields("one", "five");
+    JsonNode node = applyEntity("filter-test-002");
+
+    filter.filter(requestContext, responseContext);
+
+    assertEquals("{\"one\":1,\"five\":5}", objectMapper.writeValueAsString(node));
+  }
+
+  @Test
+  public void testFilterCommaSeparated() throws IOException {
+    applyFields("one,five");
+    JsonNode node = applyEntity("filter-test-002");
+
+    filter.filter(requestContext, responseContext);
+
+    assertEquals("{\"one\":1,\"five\":5}", objectMapper.writeValueAsString(node));
+  }
+
+  private void applyFields(String... fields) {
+    UriInfo info = mock(UriInfo.class);
+    MultivaluedMap<String,String> queryParameters = mock(MultivaluedMap.class);
+    when(queryParameters.get("fields")).thenReturn(Lists.newArrayList(fields));
+    when(info.getQueryParameters()).thenReturn(queryParameters);
+    when(requestContext.getUriInfo()).thenReturn(info);
+  }
+
+  private JsonNode applyEntity(String name) throws IOException {
+    JsonNode node = readJson(name);
+    when(responseContext.hasEntity()).thenReturn(Boolean.TRUE);
+    when(responseContext.getEntity()).thenReturn(node);
+    return node;
+  }
+
+  private JsonNode readJson(String name) throws IOException {
+    URL resource = Resources.getResource("sonia/scm/api/v2/" + name + ".json");
+    return objectMapper.readTree(resource);
+  }
+}

scm-webapp/src/test/java/sonia/scm/api/v2/JsonFiltersTest.java

@@ -0,0 +1,83 @@
+package sonia.scm.api.v2;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.google.common.collect.Lists;
+import com.google.common.io.Resources;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.URL;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class JsonFiltersTest {
+
+  private ObjectMapper objectMapper = new ObjectMapper();
+
+  @Test
+  public void testFilterByFields() throws IOException {
+    JsonNode node = readJson("filter-test-001");
+
+    JsonFilters.filterByFields(node, Lists.newArrayList("one"));
+
+    assertEquals(1, node.get("one").intValue());
+    assertFalse(node.has("two"));
+    assertFalse(node.has("three"));
+  }
+
+  @Test
+  public void testFilterByFieldsWithMultipleFields() throws IOException {
+    JsonNode node = readJson("filter-test-001");
+
+    JsonFilters.filterByFields(node, Lists.newArrayList("one", "three"));
+
+    assertEquals(1, node.get("one").intValue());
+    assertFalse(node.has("two"));
+    assertEquals(3, node.get("three").intValue());
+  }
+
+  @Test
+  public void testFilterByFieldsWithNonPrimitive() throws IOException {
+    JsonNode node = readJson("filter-test-002");
+    JsonFilters.filterByFields(node, Lists.newArrayList("two"));
+    assertEquals("{\"two\":{\"three\":3,\"four\":4}}", objectMapper.writeValueAsString(node));
+  }
+
+  @Test
+  public void testFilterByFieldsWithDeepField() throws IOException {
+    JsonNode node = readJson("filter-test-002");
+    JsonFilters.filterByFields(node, Lists.newArrayList("two.three"));
+    assertEquals("{\"two\":{\"three\":3}}", objectMapper.writeValueAsString(node));
+  }
+
+  @Test
+  public void testFilterByFieldsWithVeryDeepField() throws IOException {
+    JsonNode node = readJson("filter-test-003");
+    JsonFilters.filterByFields(node, Lists.newArrayList("two.three.four.five"));
+    assertFalse(node.has("one"));
+    String json = objectMapper.writeValueAsString(node.get("two").get("three").get("four").get("five"));
+    assertEquals("{\"six\":6,\"seven\":7}", json);
+  }
+
+  @Test
+  public void testFilterByFieldsWithArray() throws IOException {
+    JsonNode node = readJson("filter-test-004");
+    JsonFilters.filterByFields(node, Lists.newArrayList("one.two"));
+    ArrayNode one = (ArrayNode) node.get("one");
+    assertEquals(one.size(), 2);
+    for (int i=0; i<one.size(); i++) {
+      JsonNode childOfOne = one.get(i);
+      assertFalse(childOfOne.has("three"));
+      assertEquals(2, childOfOne.get("two").intValue());
+    }
+  }
+
+  private JsonNode readJson(String name) throws IOException {
+    URL resource = Resources.getResource("sonia/scm/api/v2/" + name + ".json");
+    return objectMapper.readTree(resource);
+  }
+
+}

scm-webapp/src/test/java/sonia/scm/api/v2/JsonMarshallingResponseFilterTest.java

@@ -0,0 +1,122 @@
+package sonia.scm.api.v2;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import sonia.scm.web.JsonEnricher;
+import sonia.scm.web.VndMediaType;
+
+import javax.ws.rs.container.ContainerRequestContext;
+import javax.ws.rs.container.ContainerResponseContext;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.UriInfo;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class JsonMarshallingResponseFilterTest {
+
+  @Mock
+  private ContainerRequestContext requestContext;
+
+  @Mock
+  private ContainerResponseContext responseContext;
+
+  @Mock
+  private UriInfo uriInfo;
+
+  @Captor
+  private ArgumentCaptor<JsonNode> jsonNodeCaptor;
+
+  private final ObjectMapper mapper = new ObjectMapper();
+
+  private Set<JsonEnricher> enrichers;
+
+  private JsonMarshallingResponseFilter filter;
+
+  @Before
+  public void setUpObjectUnderTest() throws URISyntaxException {
+    this.enrichers = new HashSet<>();
+    filter = new JsonMarshallingResponseFilter(mapper, enrichers);
+
+    when(requestContext.getUriInfo()).thenReturn(uriInfo);
+    when(uriInfo.getRequestUri()).thenReturn(new URI("https://www.scm-manager.org/scm/api/v2/repositories"));
+  }
+
+  @Test
+  public void testFilter() {
+    when(responseContext.hasEntity()).thenReturn(Boolean.TRUE);
+    when(responseContext.getEntity()).thenReturn(new JsonMarshallingResponseFilterTest.Sample("one-two-three"));
+    when(responseContext.getMediaType()).thenReturn(VndMediaType.jsonType("sample"));
+
+    filter.filter(requestContext, responseContext);
+
+    verify(responseContext).setEntity(jsonNodeCaptor.capture());
+
+    JsonNode node = jsonNodeCaptor.getValue();
+    assertEquals("one-two-three", node.get("value").asText());
+  }
+
+  @Test
+  public void testFilterWithEnricher() {
+    enrichers.add(context -> {
+      JsonNode node = context.getResponseEntity();
+      if (node.isObject()) {
+        ((ObjectNode)node).put("version", 2);
+      }
+    });
+
+    when(responseContext.hasEntity()).thenReturn(Boolean.TRUE);
+    when(responseContext.getEntity()).thenReturn(new JsonMarshallingResponseFilterTest.Sample("one-two-three"));
+    when(responseContext.getMediaType()).thenReturn(VndMediaType.jsonType("sample"));
+
+    filter.filter(requestContext, responseContext);
+
+    verify(responseContext).setEntity(jsonNodeCaptor.capture());
+
+    JsonNode node = jsonNodeCaptor.getValue();
+    assertEquals(2, node.get("version").asInt());
+  }
+
+  @Test
+  public void testFilterWithoutEntity() {
+    filter.filter(requestContext, responseContext);
+    verify(responseContext, never()).setEntity(Mockito.anyObject());
+  }
+
+  @Test
+  public void testFilterWithNonVndEntity() {
+    when(responseContext.hasEntity()).thenReturn(Boolean.TRUE);
+    when(responseContext.getEntity()).thenReturn(new JsonMarshallingResponseFilterTest.Sample("one-two-three"));
+    when(responseContext.getMediaType()).thenReturn(MediaType.APPLICATION_JSON_TYPE);
+
+    filter.filter(requestContext, responseContext);
+    verify(responseContext, never()).setEntity(Mockito.anyObject());
+  }
+
+  public static class Sample {
+
+    private String value;
+
+    public Sample(String value) {
+      this.value = value;
+    }
+
+    public String getValue() {
+      return value;
+    }
+  }
+}

scm-webapp/src/test/java/sonia/scm/it/IntegrationTestUtil.java

@@ -35,37 +35,34 @@ package sonia.scm.it;
 
 //~--- non-JDK imports --------------------------------------------------------
 
-import sonia.scm.ScmState;
-import sonia.scm.Type;
-import sonia.scm.user.User;
-import sonia.scm.util.IOUtil;
-
-import static org.junit.Assert.*;
-
-//~--- JDK imports ------------------------------------------------------------
-
 import com.sun.jersey.api.client.Client;
 import com.sun.jersey.api.client.ClientResponse;
 import com.sun.jersey.api.client.WebResource;
-import com.sun.jersey.api.client.filter.LoggingFilter;
 import com.sun.jersey.client.apache.ApacheHttpClient;
 import com.sun.jersey.client.apache.config.ApacheHttpClientConfig;
 import com.sun.jersey.client.apache.config.DefaultApacheHttpClientConfig;
 import com.sun.jersey.core.util.MultivaluedMapImpl;
+import sonia.scm.ScmState;
+import sonia.scm.Type;
+import sonia.scm.api.rest.JSONContextResolver;
+import sonia.scm.api.rest.ObjectMapperProvider;
+import sonia.scm.repository.Person;
+import sonia.scm.repository.client.api.ClientCommand;
+import sonia.scm.repository.client.api.RepositoryClient;
+import sonia.scm.user.User;
+import sonia.scm.util.IOUtil;
 
+import javax.ws.rs.core.MultivaluedMap;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
-
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.UUID;
 
-import javax.ws.rs.core.MultivaluedMap;
-import sonia.scm.api.rest.JSONContextResolver;
-import sonia.scm.repository.Person;
-import sonia.scm.repository.client.api.ClientCommand;
-import sonia.scm.repository.client.api.RepositoryClient;
+import static org.junit.Assert.*;
+
+//~--- JDK imports ------------------------------------------------------------
 
 /**
  *
@@ -175,7 +172,7 @@ public final class IntegrationTestUtil
   public static Client createClient()
   {
     DefaultApacheHttpClientConfig config = new DefaultApacheHttpClientConfig();
-    config.getSingletons().add(new JSONContextResolver());
+    config.getSingletons().add(new JSONContextResolver(new ObjectMapperProvider().get()));
     config.getProperties().put(ApacheHttpClientConfig.PROPERTY_HANDLE_COOKIES, true);
 
     return ApacheHttpClient.create(config);