Increase coverage

Author: oliemansm

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLClientException.java

@@ -1,8 +1,5 @@
 package graphql.kickstart.spring.webclient.boot;
 
-import lombok.NoArgsConstructor;
-
-@NoArgsConstructor
 public class GraphQLClientException extends RuntimeException {
 
   GraphQLClientException(String message, Throwable cause) {

graphql-webclient/src/main/java/graphql/kickstart/spring/webclient/boot/GraphQLResponse.java

@@ -14,6 +14,8 @@
 @Data
 public class GraphQLResponse {
 
+  public static final String ERRORS_FIELD = "errors";
+
   private final JsonNode data;
   private final List<GraphQLError> errors;
   private final String rawResponse;
@@ -25,7 +27,7 @@ public class GraphQLResponse {
 
     JsonNode tree = readTree(rawResponse);
     errors = readErrors(tree);
-    data = tree.get("data");
+    data = tree.hasNonNull("data") ? tree.get("data") : null;
   }
 
   private JsonNode readTree(String rawResponse) {
@@ -37,12 +39,20 @@ private JsonNode readTree(String rawResponse) {
   }
 
   private List<GraphQLError> readErrors(JsonNode tree) {
-    if (tree.has("errors")) {
-      return objectMapper.convertValue(tree.get("errors"), constructListType(GraphQLError.class));
+    if (tree.has(ERRORS_FIELD) && tree.get(ERRORS_FIELD) != null) {
+      return convertList(tree.get(ERRORS_FIELD), GraphQLError.class);
     }
     return emptyList();
   }
 
+  private <T> List<T> convertList(JsonNode node, Class<T> type) {
+    return objectMapper.convertValue(node, constructListType(type));
+  }
+
+  private JavaType constructListType(Class<?> type) {
+    return objectMapper.getTypeFactory().constructCollectionType(List.class, type);
+  }
+
   public <T> T get(String fieldName, Class<T> type) {
     if (data != null && data.has(fieldName) && data.get(fieldName) != null) {
       return objectMapper.convertValue(data.get(fieldName), type);
@@ -62,26 +72,22 @@ private Optional<JsonNode> getFirstDataEntry() {
   }
 
   public <T> List<T> getList(String fieldName, Class<T> type) {
-    if (data.has(fieldName) && data.get(fieldName) != null) {
-      return objectMapper.convertValue(data.get(fieldName), constructListType(type));
+    if (data != null && data.has(fieldName) && data.get(fieldName) != null) {
+      return convertList(data.get(fieldName), type);
     }
     return emptyList();
   }
 
   @SuppressWarnings("unchecked")
   public <T> List<T> getFirstList(Class<T> type) {
     return getFirstDataEntry()
-        .map(it -> objectMapper.convertValue(it, constructListType(type)))
+        .map(it -> convertList(it, type))
         .map(List.class::cast)
         .orElseGet(Collections::emptyList);
   }
 
-  private JavaType constructListType(Class<?> type) {
-    return objectMapper.getTypeFactory().constructCollectionType(List.class, type);
-  }
-
   public void validateNoErrors() {
-    if (errors != null && !errors.isEmpty()) {
+    if (!errors.isEmpty()) {
       throw new GraphQLErrorsException(errors);
     }
   }

graphql-webclient/src/test/java/graphql/kickstart/spring/webclient/boot/GraphQLResponseTest.java

@@ -0,0 +1,93 @@
+package graphql.kickstart.spring.webclient.boot;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class GraphQLResponseTest {
+
+  private final ObjectMapper mockedMapper = spy(new ObjectMapper());
+
+  @Test
+  void readRawResponse_throwsJsonProcessingException_isConvertedToCustomException() {
+    GraphQLClientException e = assertThrows(GraphQLClientException.class,
+        () -> constructResponse("no valid json"));
+    assertEquals("Cannot read response 'no valid json'", e.getMessage());
+  }
+
+  private GraphQLResponse constructResponse(String json) {
+    return new GraphQLResponse(json, mockedMapper);
+  }
+
+  @Test
+  void getFieldName_dataIsNull_returnsNull() {
+    GraphQLResponse response = constructResponse("{ \"data\": null }");
+    assertNull(response.get("test", String.class));
+  }
+
+  @Test
+  void getFieldName_notDataFieldExists_returnsNull() {
+    GraphQLResponse response = constructResponse("{ \"data\": { \"field\": null } }");
+    assertNull(response.get("test", String.class));
+  }
+
+  @Test
+  void getFieldName_dataFieldIsNull_returnsNull() {
+    GraphQLResponse response = constructResponse("{ \"data\": { \"field\": null } }");
+    assertNull(response.get("field", String.class));
+    verify(mockedMapper, times(0)).convertValue(null, String.class);
+  }
+
+  @Test
+  void getFieldName_dataFieldExists_returnsValue() {
+    GraphQLResponse response = constructResponse("{ \"data\": { \"field\": \"value\" } }");
+    String value = response.get("field", String.class);
+    assertEquals("value", value);
+    verify(mockedMapper, times(1)).convertValue(isA(JsonNode.class), eq(String.class));
+  }
+
+  @Test
+  void getFirstObject_dataIsNull_returnsNull() {
+    GraphQLResponse response = constructResponse("{ \"data\": null }");
+    assertNull(response.getFirstObject(String.class));
+  }
+
+  @Test
+  void getFirstObject_notDataFieldExists_returnsNull() {
+    GraphQLResponse response = constructResponse("{ \"data\": { \"field\": null } }");
+    assertNull(response.getFirstObject(String.class));
+  }
+
+  @Test
+  void getList_dataIsNull_returnsEmptyList() {
+    GraphQLResponse response = constructResponse("{ \"data\": null }");
+    assertNull(response.getData());
+    assertTrue(response.getList("test", String.class).isEmpty());
+  }
+
+  @Test
+  void getList_notDataFieldExists_returnsEmptyList() {
+    GraphQLResponse response = constructResponse("{ \"data\": { \"field\": null } }");
+    assertTrue(response.getList("test", String.class).isEmpty());
+  }
+
+  @Test
+  void getList_dataFieldExists_returnsList() {
+    GraphQLResponse response = constructResponse("{ \"data\": { \"field\": [\"value\"] } }");
+    List<String> values = response.getList("field", String.class);
+    assertEquals(1, values.size());
+    assertEquals("value", values.get(0));
+  }
+
+}