refactor: test refactoring

Author: BlasiusSecundus

graphql-spring-boot-test-autoconfigure/src/test/java/com/graphql/spring/boot/test/GraphQLTestAutoConfigurationTestBase.java

@@ -22,6 +22,7 @@ void assertThatTestSubscriptionWorksCorrectly() {
         // WHEN - THEN
         testSubscription.start("test-subscription.graphql")
             .awaitAndGetNextResponse(1000)
+            .assertThatNoErrorsArePresent()
             .assertThatField("$.data.testSubscription").asString().isEqualTo(FOO);
     }
 
@@ -30,7 +31,7 @@ void assertThatTestTemplateAutoConfigurationWorksCorrectly() throws IOException
         final GraphQLTestTemplate testTemplate = applicationContext.getBean(GraphQLTestTemplate.class);
         // WHEN - THEN
         testTemplate.postForResource("test-query.graphql")
-            .assertThatNumberOfErrors().isZero().and()
+            .assertThatNoErrorsArePresent()
             .assertThatField("$.data.testQuery").asString().isEqualTo(FOO);
     }
 }

graphql-spring-boot-test/src/test/java/com/graphql/spring/boot/test/GraphQLFieldAssertIsNotPresentTest.java

@@ -20,10 +20,10 @@ private static Stream<String> valuesThatShouldCauseFailure() {
         return Stream.of(null, NON_NULL_VALUE);
     }
 
-    @ParameterizedTest
+    @ParameterizedTest(name = "value = {0}")
     @MethodSource("valuesThatShouldCauseFailure")
-    @DisplayName("Should fail if the value at the provided path is null.")
-    void shouldFailIfNull(final String value) {
+    @DisplayName("Should fail if the value at the provided path is present.")
+    void shouldFailIfValueIsPresent(final String value) {
         // GIVEN
         given(graphQLResponse.getRaw(MOCK_PATH)).willReturn(value);
         final GraphQLFieldAssert graphQLFieldAssert = new GraphQLFieldAssert(graphQLResponse, MOCK_PATH);

graphql-spring-boot-test/src/test/java/com/graphql/spring/boot/test/GraphQLResponseTest.java

@@ -32,13 +32,15 @@
 import java.util.List;
 import java.util.stream.Stream;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.*;
 
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
 public class GraphQLResponseTest {
 
-    private static final String DATA_PATH = "$.data.test";
+    private static final String DATA_PATH_TEST = "$.data.test";
+    private static final String INNER_FOO_LIST_DATA_PATH = "$.data.externalList[*].fooList";
+    private static final String NESTED_LIST_RESPONSE_FILE = "response-with-nested-list.json";
+    private static final String EMPTY_OBJECT_RESPONSE = "{}";
 
     @Autowired
     private ObjectMapper objectMapper;
@@ -80,84 +82,78 @@ private static Stream<Arguments> testGetListArguments() {
         );
     }
 
+    private static String loadClassPathResource(final String path) {
+        try(InputStream resourceStream = new ClassPathResource(path).getInputStream()) {
+            return StreamUtils.copyToString(resourceStream, StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            fail("Test setup error - failed to load test resource.", e);
+            return "";
+        }
+    }
+
     @DisplayName("Should get the JSON node's value as a String.")
     @ParameterizedTest
     @MethodSource("testGetStringArguments")
-    public void testGetString(
-        final String bodyString,
-        final String expected
-    ) {
+    public void testGetString(final String bodyString, final String expected) {
         //GIVEN
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(bodyString), objectMapper);
+        final GraphQLResponse graphQLResponse = createResponse(bodyString);
         //WHEN
-        final String actual = graphQLResponse.get(DATA_PATH);
+        final String actual = graphQLResponse.get(DATA_PATH_TEST);
         //THEN
         assertThat(actual).isEqualTo(expected);
     }
 
     @DisplayName("Should get the JSON node's value as an instance of a specified class.")
     @ParameterizedTest
     @MethodSource("testGetArguments")
-    public <T> void testGet(
-        final String bodyString,
-        final Class<T> clazz,
-        final T expected
-    ) {
+    public <T> void testGet(final String bodyString, final Class<T> clazz, final T expected) {
         //GIVEN
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(bodyString), objectMapper);
+        final GraphQLResponse graphQLResponse = createResponse(bodyString);
         //WHEN
-        final T actual = graphQLResponse.get(DATA_PATH, clazz);
+        final T actual = graphQLResponse.get(DATA_PATH_TEST, clazz);
         //THEN
         assertThat(actual).isInstanceOf(clazz).isEqualTo(expected);
     }
 
     @DisplayName("Should get the JSON node's value as a List.")
     @ParameterizedTest
     @MethodSource("testGetListArguments")
-    public <T> void testGetList(
-        final String bodyString,
-        final Class<T> clazz,
-        final List<T> expected
-    ) {
+    public <T> void testGetList(final String bodyString, final Class<T> clazz, final List<T> expected) {
         //GIVEN
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(bodyString), objectMapper);
+        final GraphQLResponse graphQLResponse = createResponse(bodyString);
         //WHEN
-        final List<T> actual = graphQLResponse.getList(DATA_PATH, clazz);
+        final List<T> actual = graphQLResponse.getList(DATA_PATH_TEST, clazz);
         //THEN
         assertThat(actual).containsExactlyElementsOf(expected);
     }
 
     @DisplayName("Should get field as defined by Jackson's JavaType.")
     @Test
-    public void testGetAsJavaType() throws IOException {
+    public void testGetAsJavaType() {
         // GIVEN
-        final String dataPath = "$.data.externalList[*].fooList";
-        final String response = loadClassPathResource("response-with-nested-list.json");
         final List<List<String>> expected = Arrays.asList(Arrays.asList("foo1", "foo2"),
             Collections.singletonList("foo3"));
         final JavaType stringList = objectMapper.getTypeFactory().constructCollectionType(List.class, String.class);
         final JavaType listOfStringLists = objectMapper.getTypeFactory().constructCollectionType(List.class,
             stringList);
         // WHEN
-        final List<List<String>> actual = new GraphQLResponse(ResponseEntity.ok(response), objectMapper)
-            .get(dataPath, listOfStringLists);
+        final List<List<String>> actual = createResponse(loadClassPathResource(NESTED_LIST_RESPONSE_FILE))
+            .get(INNER_FOO_LIST_DATA_PATH, listOfStringLists);
         // THEN
         assertThat(actual).containsExactlyElementsOf(expected);
 
     }
 
     @DisplayName("Should throw illegal argument exception if type is incompatible")
     @Test
-    public void testGetAsJavaTypeConversionError() throws IOException {
+    public void testGetAsJavaTypeConversionError() {
         // GIVEN
-        final String dataPath = "$.data.externalList[*].fooList";
-        final String response = loadClassPathResource("response-with-nested-list.json");
         final JavaType stringType = objectMapper.getTypeFactory().constructType(String.class);
         // WHEN
-        final GraphQLResponse actual = new GraphQLResponse(ResponseEntity.ok(response), objectMapper);
+        final GraphQLResponse actual = createResponse(loadClassPathResource(NESTED_LIST_RESPONSE_FILE));
         // THEN
         assertThatExceptionOfType(IllegalArgumentException.class)
-            .isThrownBy(() -> actual.get(dataPath, stringType));
+            .isThrownBy(() -> actual.get(INNER_FOO_LIST_DATA_PATH, stringType));
 
     }
 
@@ -170,7 +166,7 @@ public void testGetAsJavaTypeConversionError() throws IOException {
     @DisplayName("Should pass the assertion if no errors are present.")
     void testExpectNoErrorsPass(final String response) {
         // WHEN
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(response), objectMapper);
+        final GraphQLResponse graphQLResponse = createResponse(response);
         // THEN
         assertThat(graphQLResponse.assertThatNoErrorsArePresent())
             .as("Should not throw an exception. Should return GraphQL response instance.")
@@ -180,112 +176,116 @@ void testExpectNoErrorsPass(final String response) {
     @Test
     @DisplayName("Should throw assertion error if an error is present in the response.")
     void testExpectNoErrorsFail() {
-        // WHEN
+        // GIVEN
         final String response = "{\"errors\": [{\"message\": \"Test error.\"}], \"data\": { \"foo\":\"bar\"} }";
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(response), objectMapper);
+        // WHEN
+        final GraphQLResponse graphQLResponse = createResponse(response);
         // THEN
         assertThatExceptionOfType(AssertionError.class)
             .isThrownBy(graphQLResponse::assertThatNoErrorsArePresent)
             .withMessage("Expected no GraphQL errors, but got 1: <Unspecified error>: Test error.");
     }
 
     @Test
-    @DisplayName("Should return assertion for the number of errors.")
+    @DisplayName("Should return an assertion for the number of errors.")
     void testNumberOfErrorsAssertion() {
-        // WHEN
+        // GIVEN
         final String response = "{\"errors\": [{\"message\": \"Test error.\"}, {\"message\": \"Test error 2.\"}], "
             + "\"data\": { \"foo\":\"bar\"} }";
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(response), objectMapper);
-        // THEN
+        final GraphQLResponse graphQLResponse = createResponse(response);
+        // WHEN
         final NumberOfErrorsAssertion actual = graphQLResponse.assertThatNumberOfErrors();
+        // THEN
         assertThat(actual).extracting("actual").isEqualTo(2);
         assertThat(actual.and()).isSameAs(graphQLResponse);
     }
 
     @Test
-    @DisplayName("Should return assertion for the list of errors.")
+    @DisplayName("Should return an assertion for the list of errors.")
     void testErrorListAssertion() {
         // GIVEN
         final String response = "{\"errors\": [{\"message\": \"Test error.\", \"errorType\": \"DataFetchingException\"}], "
             + "\"data\": { \"foo\":\"bar\"} }";
+        final GraphQLResponse graphQLResponse = createResponse(response);
         // WHEN
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(response), objectMapper);
         final GraphQLErrorListAssertion actual = graphQLResponse.assertThatListOfErrors();
         // THEN
         assertThat(actual).isNotNull();
         assertThat(actual).extracting("actual").isEqualTo(Collections.singletonList(GraphQLTestError.builder()
-        .message("Test error.").errorType(ErrorType.DataFetchingException).build()));
+            .message("Test error.").errorType(ErrorType.DataFetchingException).build()));
         assertThat(actual.and()).isSameAs(graphQLResponse);
     }
 
     @Test
-    @DisplayName("Should return a assertion for the json content of the response.")
+    @DisplayName("Should return an assertion for the json content of the response.")
     void testFieldAssertion() {
         // GIVEN
         final String response = "{ \"data\": { \"foo\":\"bar\"} }";
+        final GraphQLResponse graphQLResponse = createResponse(response);
         // WHEN
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(response), objectMapper);
         final JsonContentAssert actual = graphQLResponse.assertThatJsonContent();
         // THEN
         assertThat(actual).isNotNull();
         assertThat(actual).extracting("actual").isEqualTo(response);
     }
 
     @Test
-    @DisplayName("Should return a assertion for the data field.")
+    @DisplayName("Should return an assertion for the data field.")
     void testDataFieldAssertion() {
+        // GIVEN
+        final GraphQLResponse response = createResponse(EMPTY_OBJECT_RESPONSE);
         // WHEN
-        final GraphQLResponse response = new GraphQLResponse(ResponseEntity.ok("{}"), objectMapper);
         final GraphQLFieldAssert actual = response.assertThatDataField();
         // THEN
-        assertThat(actual).isNotNull();
-        assertThat(actual).extracting("graphQLResponse", "jsonPath")
-            .containsExactly(response, "$.data");
+        assertThatAssertionIsCorrect(actual, response, "$.data");
     }
 
     @Test
-    @DisplayName("Should return a assertion for the errors field.")
+    @DisplayName("Should return an assertion for the errors field.")
     void testErrorFieldAssertion() {
+        // GIVEN
+        final GraphQLResponse response = createResponse(EMPTY_OBJECT_RESPONSE);
         // WHEN
-        final GraphQLResponse response = new GraphQLResponse(ResponseEntity.ok("{}"), objectMapper);
         final GraphQLFieldAssert actual = response.assertThatErrorsField();
         // THEN
-        assertThat(actual).isNotNull();
-        assertThat(actual).extracting("graphQLResponse", "jsonPath")
-            .containsExactly(response, "$.errors");
+        assertThatAssertionIsCorrect(actual, response, "$.errors");
     }
 
     @Test
-    @DisplayName("Should return a assertion for the extensions field.")
+    @DisplayName("Should return an assertion for the extensions field.")
     void testErrorExtensionsAssertion() {
+        // GIVEN
+        final GraphQLResponse response = createResponse(EMPTY_OBJECT_RESPONSE);
         // WHEN
-        final GraphQLResponse response = new GraphQLResponse(ResponseEntity.ok("{}"), objectMapper);
         final GraphQLFieldAssert actual = response.assertThatExtensionsField();
         // THEN
-        assertThat(actual).isNotNull();
-        assertThat(actual).extracting("graphQLResponse", "jsonPath")
-            .containsExactly(response, "$.extensions");
+        assertThatAssertionIsCorrect(actual, response, "$.extensions");
     }
 
     @Test
     @DisplayName("Should return a field assertion for the specific field.")
     void testJsonAssertion() {
         // GIVEN
-        final String response = "{}";
         final String path = "$any.path";
+        final GraphQLResponse graphQLResponse = createResponse(EMPTY_OBJECT_RESPONSE);
         // WHEN
-        final GraphQLResponse graphQLResponse = new GraphQLResponse(ResponseEntity.ok(response), objectMapper);
         final GraphQLFieldAssert actual = graphQLResponse.assertThatField(path);
         // THEN
-        assertThat(actual).isNotNull();
-        assertThat(actual).extracting("graphQLResponse", "jsonPath")
-            .containsExactly(graphQLResponse, path);
+        assertThatAssertionIsCorrect(actual, graphQLResponse, path);
     }
 
-    private String loadClassPathResource(String path) throws IOException {
-        try(InputStream resourceStream = new ClassPathResource(path).getInputStream()) {
-            return StreamUtils.copyToString(resourceStream, StandardCharsets.UTF_8);
-        }
+    private GraphQLResponse createResponse(final String s) {
+        return new GraphQLResponse(ResponseEntity.ok(s), objectMapper);
+    }
+
+    private void assertThatAssertionIsCorrect(
+        final GraphQLFieldAssert actual,
+        final GraphQLResponse expectedResponse,
+        final Object expectedPath
+    ) {
+        assertThat(actual).isNotNull();
+        assertThat(actual).extracting("graphQLResponse", "jsonPath")
+            .containsExactly(expectedResponse, expectedPath);
     }
 
     @Data

graphql-spring-boot-test/src/test/java/com/graphql/spring/boot/test/GraphQLTestErrorToStringTest.java

@@ -3,6 +3,7 @@
 import graphql.ErrorType;
 import graphql.GraphQLError;
 import graphql.language.SourceLocation;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -15,57 +16,60 @@
 
 public class GraphQLTestErrorToStringTest {
 
+    private static final String TEST_MESSAGE = "Test message";
+
     private static Stream<Arguments> toStringTestArguments() {
         return Stream.of(
             Arguments.of(
                 new GraphQLTestError(null, null, null, null, null),
                 "<Unspecified error>: <error message not provided>"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", null, null, null, null),
+                new GraphQLTestError(TEST_MESSAGE, null, null, null, null),
                 "<Unspecified error>: Test message"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", null, ErrorType.DataFetchingException, null, null),
+                new GraphQLTestError(TEST_MESSAGE, null, ErrorType.DataFetchingException, null, null),
                 "DataFetchingException: Test message"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", Collections.emptyList(), ErrorType.DataFetchingException, null, null),
+                new GraphQLTestError(TEST_MESSAGE, Collections.emptyList(), ErrorType.DataFetchingException, null, null),
                 "DataFetchingException: Test message"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", Collections.singletonList(new SourceLocation(1, 2)),
+                new GraphQLTestError(TEST_MESSAGE, Collections.singletonList(new SourceLocation(1, 2)),
                     ErrorType.DataFetchingException, null, null),
                 "DataFetchingException: Test message at line 1, column 2 in unnamed/unspecified source"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", Collections.singletonList(new SourceLocation(1, 2)),
+                new GraphQLTestError(TEST_MESSAGE, Collections.singletonList(new SourceLocation(1, 2)),
                     ErrorType.DataFetchingException, Collections.emptyList(), null),
                 "DataFetchingException: Test message at line 1, column 2 in unnamed/unspecified source"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", Collections.singletonList(new SourceLocation(1, 2)),
+                new GraphQLTestError(TEST_MESSAGE, Collections.singletonList(new SourceLocation(1, 2)),
                     ErrorType.DataFetchingException, Arrays.asList("path", "to", "error"), null),
                 "DataFetchingException: Test message at line 1, column 2 in unnamed/unspecified source. Selection path: path/to/error"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", Collections.singletonList(new SourceLocation(1, 2, "test.graphql")),
+                new GraphQLTestError(TEST_MESSAGE, Collections.singletonList(new SourceLocation(1, 2, "test.graphql")),
                     ErrorType.DataFetchingException, Arrays.asList("path", "to", "error"), null),
                 "DataFetchingException: Test message at line 1, column 2 in test.graphql. Selection path: path/to/error"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", Collections.singletonList(new SourceLocation(1, 2)),
+                new GraphQLTestError(TEST_MESSAGE, Collections.singletonList(new SourceLocation(1, 2)),
                     ErrorType.DataFetchingException, Arrays.asList("path", 123, "error"), null),
                 "DataFetchingException: Test message at line 1, column 2 in unnamed/unspecified source. Selection path: path[123]/error"
             ),
             Arguments.of(
-                new GraphQLTestError("Test message", Collections.singletonList(new SourceLocation(1, 2)),
+                new GraphQLTestError(TEST_MESSAGE, Collections.singletonList(new SourceLocation(1, 2)),
                     ErrorType.DataFetchingException, Arrays.asList("path", 123, "error"), Collections.singletonMap("please ignore", "this")),
                 "DataFetchingException: Test message at line 1, column 2 in unnamed/unspecified source. Selection path: path[123]/error"
             )
         );
     }
 
+    @DisplayName("toString should work properly")
     @ParameterizedTest(name = "{1}")
     @MethodSource("toStringTestArguments")
     void testGraphQLTestErrorToString(final GraphQLError error, final String expectedToString) {