google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
GraphQL Testing with Java: Complete Guide
awiskar acharya
November 19, 2025
11:26 am

Introduction

GraphQL testing in Java involves testing both GraphQL servers and clients to ensure proper query execution, error handling, and performance. This guide covers comprehensive testing strategies using popular Java testing frameworks and tools.

Dependencies and Setup

1. Maven Dependencies

<properties> <spring-boot.version>3.2.0</spring-boot.version> <graphql-java.version>21.3</graphql-java.version> <graphql-java-kickstart.version>15.0.0</graphql-java-kickstart.version> <junit.version>5.10.1</junit.version> <testcontainers.version>1.19.3</testcontainers.version> </properties> <dependencies> <!-- Spring Boot GraphQL --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-graphql</artifactId> <version>${spring-boot.version}</version> </dependency> <!-- Spring Boot Web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${spring-boot.version}</version> </dependency> <!-- GraphQL Java --> <dependency> <groupId>com.graphql-java</groupId> <artifactId>graphql-java</artifactId> <version>${graphql-java.version}</version> </dependency> <!-- GraphQL Java Tools --> <dependency> <groupId>com.graphql-java-kickstart</groupId> <artifactId>graphql-java-tools</artifactId> <version>${graphql-java-kickstart.version}</version> </dependency> <!-- GraphQL Test Utilities --> <dependency> <groupId>com.graphql-java-kickstart</groupId> <artifactId>graphql-spring-boot-starter-test</artifactId> <version>${graphql-java-kickstart.version}</version> <scope>test</scope> </dependency> <!-- Testing --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <version>${spring-boot.version}</version> <scope>test</scope> </dependency> <!-- TestContainers --> <dependency> <groupId>org.testcontainers</groupId> <artifactId>junit-jupiter</artifactId> <version>${testcontainers.version}</version> <scope>test</scope> </dependency> <!-- HTTP Client for Testing --> <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>4.12.0</version> <scope>test</scope> </dependency> <!-- JSON Assertions --> <dependency> <groupId>org.skyscreamer</groupId> <artifactId>jsonassert</artifactId> <version>1.5.1</version> <scope>test</scope> </dependency> <!-- Awaitility for Async Testing --> <dependency> <groupId>org.awaitility</groupId> <artifactId>awaitility</artifactId> <version>4.2.0</version> <scope>test</scope> </dependency> </dependencies>

GraphQL Server Implementation

2. GraphQL Schema Definition

# schema.graphqls type Query { users: [User!]! user(id: ID!): User posts(userId: ID, first: Int, after: String): PostConnection! searchUsers(query: String!): [User!]! } type Mutation { createUser(input: CreateUserInput!): User! updateUser(id: ID!, input: UpdateUserInput!): User! deleteUser(id: ID!): Boolean! createPost(input: CreatePostInput!): Post! } type Subscription { postCreated: Post! userUpdated: User! } type User { id: ID! name: String! email: String! age: Int posts: [Post!]! createdAt: String! updatedAt: String! } type Post { id: ID! title: String! content: String! author: User! comments: [Comment!]! published: Boolean! createdAt: String! } type Comment { id: ID! content: String! author: User! post: Post! createdAt: String! } type PostConnection { edges: [PostEdge!]! pageInfo: PageInfo! } type PostEdge { node: Post! cursor: String! } type PageInfo { hasNextPage: Boolean! hasPreviousPage: Boolean! startCursor: String endCursor: String } input CreateUserInput { name: String! email: String! age: Int } input UpdateUserInput { name: String email: String age: Int } input CreatePostInput { title: String! content: String! authorId: ID! published: Boolean = false }

3. Data Models

package com.example.graphql.model; import java.time.LocalDateTime; import java.util.List; public class User { private String id; private String name; private String email; private Integer age; private List<Post> posts; private LocalDateTime createdAt; private LocalDateTime updatedAt; // Constructors public User() {} public User(String id, String name, String email, Integer age) { this.id = id; this.name = name; this.email = email; this.age = age; this.createdAt = LocalDateTime.now(); this.updatedAt = LocalDateTime.now(); } // Getters and Setters public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public List<Post> getPosts() { return posts; } public void setPosts(List<Post> posts) { this.posts = posts; } public LocalDateTime getCreatedAt() { return createdAt; } public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; } public LocalDateTime getUpdatedAt() { return updatedAt; } public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; } } package com.example.graphql.model; import java.time.LocalDateTime; import java.util.List; public class Post { private String id; private String title; private String content; private User author; private List<Comment> comments; private boolean published; private LocalDateTime createdAt; // Constructors public Post() {} public Post(String id, String title, String content, User author, boolean published) { this.id = id; this.title = title; this.content = content; this.author = author; this.published = published; this.createdAt = LocalDateTime.now(); } // Getters and Setters public String getId() { return id; } public void setId(String id) { this.id = id; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } public User getAuthor() { return author; } public void setAuthor(User author) { this.author = author; } public List<Comment> getComments() { return comments; } public void setComments(List<Comment> comments) { this.comments = comments; } public boolean isPublished() { return published; } public void setPublished(boolean published) { this.published = published; } public LocalDateTime getCreatedAt() { return createdAt; } public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; } } package com.example.graphql.model; import java.time.LocalDateTime; public class Comment { private String id; private String content; private User author; private Post post; private LocalDateTime createdAt; // Constructors, getters, and setters public Comment() {} public Comment(String id, String content, User author, Post post) { this.id = id; this.content = content; this.author = author; this.post = post; this.createdAt = LocalDateTime.now(); } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } public User getAuthor() { return author; } public void setAuthor(User author) { this.author = author; } public Post getPost() { return post; } public void setPost(Post post) { this.post = post; } public LocalDateTime getCreatedAt() { return createdAt; } public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; } } package com.example.graphql.model; import java.util.List; public class PostConnection { private List<PostEdge> edges; private PageInfo pageInfo; // Constructors, getters, and setters public PostConnection() {} public PostConnection(List<PostEdge> edges, PageInfo pageInfo) { this.edges = edges; this.pageInfo = pageInfo; } public List<PostEdge> getEdges() { return edges; } public void setEdges(List<PostEdge> edges) { this.edges = edges; } public PageInfo getPageInfo() { return pageInfo; } public void setPageInfo(PageInfo pageInfo) { this.pageInfo = pageInfo; } } package com.example.graphql.model; public class PostEdge { private Post node; private String cursor; // Constructors, getters, and setters public PostEdge() {} public PostEdge(Post node, String cursor) { this.node = node; this.cursor = cursor; } public Post getNode() { return node; } public void setNode(Post node) { this.node = node; } public String getCursor() { return cursor; } public void setCursor(String cursor) { this.cursor = cursor; } } package com.example.graphql.model; public class PageInfo { private boolean hasNextPage; private boolean hasPreviousPage; private String startCursor; private String endCursor; // Constructors, getters, and setters public PageInfo() {} public PageInfo(boolean hasNextPage, boolean hasPreviousPage, String startCursor, String endCursor) { this.hasNextPage = hasNextPage; this.hasPreviousPage = hasPreviousPage; this.startCursor = startCursor; this.endCursor = endCursor; } public boolean isHasNextPage() { return hasNextPage; } public void setHasNextPage(boolean hasNextPage) { this.hasNextPage = hasNextPage; } public boolean isHasPreviousPage() { return hasPreviousPage; } public void setHasPreviousPage(boolean hasPreviousPage) { this.hasPreviousPage = hasPreviousPage; } public String getStartCursor() { return startCursor; } public void setStartCursor(String startCursor) { this.startCursor = startCursor; } public String getEndCursor() { return endCursor; } public void setEndCursor(String endCursor) { this.endCursor = endCursor; } }

4. GraphQL Resolvers

package com.example.graphql.resolver; import com.example.graphql.model.*; import graphql.kickstart.tools.GraphQLMutationResolver; import graphql.kickstart.tools.GraphQLQueryResolver; import graphql.kickstart.tools.GraphQLSubscriptionResolver; import org.reactivestreams.Publisher; import org.springframework.stereotype.Component; import reactor.core.publisher.Flux; import reactor.core.publisher.Sinks; import java.time.Duration; import java.util.List; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.stream.Collectors; @Component public class UserResolver implements GraphQLQueryResolver, GraphQLMutationResolver, GraphQLSubscriptionResolver { private final ConcurrentHashMap<String, User> users = new ConcurrentHashMap<>(); private final ConcurrentHashMap<String, Post> posts = new ConcurrentHashMap<>(); private final Sinks.Many<Post> postSink = Sinks.many().multicast().onBackpressureBuffer(); private final Sinks.Many<User> userSink = Sinks.many().multicast().onBackpressureBuffer(); public UserResolver() { // Initialize with some test data initializeTestData(); } // Query Resolvers public List<User> users() { return List.copyOf(users.values()); } public User user(String id) { return users.get(id); } public PostConnection posts(String userId, Integer first, String after) { List<Post> allPosts = posts.values().stream() .filter(post -> userId == null || post.getAuthor().getId().equals(userId)) .filter(Post::isPublished) .collect(Collectors.toList()); // Simple pagination implementation int startIndex = after != null ? Integer.parseInt(after) : 0; int endIndex = first != null ? Math.min(startIndex + first, allPosts.size()) : allPosts.size(); List<PostEdge> edges = allPosts.subList(startIndex, endIndex).stream() .map(post -> new PostEdge(post, String.valueOf(endIndex))) .collect(Collectors.toList()); PageInfo pageInfo = new PageInfo( endIndex < allPosts.size(), startIndex > 0, String.valueOf(startIndex), String.valueOf(endIndex) ); return new PostConnection(edges, pageInfo); } public List<User> searchUsers(String query) { return users.values().stream() .filter(user -> user.getName().toLowerCase().contains(query.toLowerCase()) || user.getEmail().toLowerCase().contains(query.toLowerCase())) .collect(Collectors.toList()); } // Mutation Resolvers public User createUser(CreateUserInput input) { String id = UUID.randomUUID().toString(); User user = new User(id, input.getName(), input.getEmail(), input.getAge()); users.put(id, user); return user; } public User updateUser(String id, UpdateUserInput input) { User user = users.get(id); if (user == null) { throw new RuntimeException("User not found: " + id); } if (input.getName() != null) { user.setName(input.getName()); } if (input.getEmail() != null) { user.setEmail(input.getEmail()); } if (input.getAge() != null) { user.setAge(input.getAge()); } user.setUpdatedAt(java.time.LocalDateTime.now()); // Notify subscribers userSink.tryEmitNext(user); return user; } public Boolean deleteUser(String id) { return users.remove(id) != null; } public Post createPost(CreatePostInput input) { String id = UUID.randomUUID().toString(); User author = users.get(input.getAuthorId()); if (author == null) { throw new RuntimeException("Author not found: " + input.getAuthorId()); } Post post = new Post(id, input.getTitle(), input.getContent(), author, input.isPublished()); posts.put(id, post); // Notify subscribers postSink.tryEmitNext(post); return post; } // Subscription Resolvers public Publisher<Post> postCreated() { return postSink.asFlux(); } public Publisher<User> userUpdated() { return userSink.asFlux(); } private void initializeTestData() { User user1 = new User("1", "John Doe", "[email protected]", 30); User user2 = new User("2", "Jane Smith", "[email protected]", 25); users.put(user1.getId(), user1); users.put(user2.getId(), user2); Post post1 = new Post("1", "First Post", "Content of first post", user1, true); Post post2 = new Post("2", "Second Post", "Content of second post", user2, true); posts.put(post1.getId(), post1); posts.put(post2.getId(), post2); } // Input Types public static class CreateUserInput { private String name; private String email; private Integer age; // Getters and Setters public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } } public static class UpdateUserInput { private String name; private String email; private Integer age; // Getters and Setters public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } } public static class CreatePostInput { private String title; private String content; private String authorId; private boolean published = false; // Getters and Setters public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } public String getAuthorId() { return authorId; } public void setAuthorId(String authorId) { this.authorId = authorId; } public boolean isPublished() { return published; } public void setPublished(boolean published) { this.published = published; } } }

Testing Framework

5. Base Test Configuration

package com.example.graphql.test.config; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.web.server.LocalServerPort; import org.springframework.test.context.DynamicPropertyRegistry; import org.springframework.test.context.DynamicPropertySource; import org.testcontainers.containers.GenericContainer; import org.testcontainers.junit.jupiter.Testcontainers; @Testcontainers @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) public abstract class BaseGraphQLTest { @LocalServerPort protected int port; protected String getGraphQLEndpoint() { return "http://localhost:" + port + "/graphql"; } // TestContainers setup for external dependencies static GenericContainer<?> redis = new GenericContainer<>("redis:7-alpine") .withExposedPorts(6379); @DynamicPropertySource static void configureProperties(DynamicPropertyRegistry registry) { redis.start(); registry.add("spring.redis.host", redis::getHost); registry.add("spring.redis.port", redis::getFirstMappedPort); } }

6. GraphQL Test Client

package com.example.graphql.test.client; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import okhttp3.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; import java.io.IOException; import java.util.Map; import java.util.concurrent.TimeUnit; @Component public class GraphQLTestClient { private static final Logger log = LoggerFactory.getLogger(GraphQLTestClient.class); private final OkHttpClient httpClient; private final ObjectMapper objectMapper; private final String graphqlEndpoint; private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8"); public GraphQLTestClient(String graphqlEndpoint) { this.graphqlEndpoint = graphqlEndpoint; this.objectMapper = new ObjectMapper(); this.httpClient = new OkHttpClient.Builder() .connectTimeout(10, TimeUnit.SECONDS) .readTimeout(30, TimeUnit.SECONDS) .writeTimeout(10, TimeUnit.SECONDS) .build(); } public GraphQLResponse executeQuery(String query) throws IOException { return executeQuery(query, null, null); } public GraphQLResponse executeQuery(String query, Map<String, Object> variables) throws IOException { return executeQuery(query, variables, null); } public GraphQLResponse executeQuery(String query, Map<String, Object> variables, Map<String, String> headers) throws IOException { GraphQLRequest request = new GraphQLRequest(query, variables); String requestBody = objectMapper.writeValueAsString(request); Request.Builder requestBuilder = new Request.Builder() .url(graphqlEndpoint) .post(RequestBody.create(requestBody, JSON)); if (headers != null) { headers.forEach(requestBuilder::addHeader); } Request httpRequest = requestBuilder.build(); try (Response response = httpClient.newCall(httpRequest).execute()) { if (response.body() != null) { String responseBody = response.body().string(); log.debug("GraphQL Response: {}", responseBody); return new GraphQLResponse(responseBody, response.code(), objectMapper); } else { throw new IOException("Empty response body"); } } } public GraphQLResponse executeMutation(String mutation, Map<String, Object> variables) throws IOException { return executeQuery(mutation, variables); } public static class GraphQLRequest { private String query; private Map<String, Object> variables; private String operationName; public GraphQLRequest(String query, Map<String, Object> variables) { this.query = query; this.variables = variables; } // Getters and Setters public String getQuery() { return query; } public void setQuery(String query) { this.query = query; } public Map<String, Object> getVariables() { return variables; } public void setVariables(Map<String, Object> variables) { this.variables = variables; } public String getOperationName() { return operationName; } public void setOperationName(String operationName) { this.operationName = operationName; } } public static class GraphQLResponse { private final String rawResponse; private final int statusCode; private final JsonNode jsonNode; private final ObjectMapper objectMapper; public GraphQLResponse(String rawResponse, int statusCode, ObjectMapper objectMapper) throws IOException { this.rawResponse = rawResponse; this.statusCode = statusCode; this.objectMapper = objectMapper; this.jsonNode = objectMapper.readTree(rawResponse); } public boolean isSuccessful() { return statusCode >= 200 && statusCode < 300 && !hasErrors(); } public boolean hasErrors() { return jsonNode.has("errors"); } public JsonNode getData() { return jsonNode.get("data"); } public JsonNode getErrors() { return jsonNode.get("errors"); } public String getRawResponse() { return rawResponse; } public int getStatusCode() { return statusCode; } public <T> T getDataAs(Class<T> type) throws IOException { return objectMapper.treeToValue(getData(), type); } public String getFirstErrorMessage() { if (hasErrors()) { JsonNode firstError = getErrors().get(0); return firstError.get("message").asText(); } return null; } } }

Comprehensive Test Suites

7. Query Testing

package com.example.graphql.test.query; import com.example.graphql.test.client.GraphQLTestClient; import com.example.graphql.test.config.BaseGraphQLTest; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import java.io.IOException; import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; class QueryTest extends BaseGraphQLTest { @Autowired private GraphQLTestClient graphQLTestClient; @BeforeEach void setUp() { // Reset test data or set up initial state } @Test void testGetAllUsers() throws IOException { String query = """ query { users { id name email age } } """; GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query); assertThat(response.isSuccessful()).isTrue(); assertThat(response.hasErrors()).isFalse(); assertThat(response.getData().get("users")).isNotNull(); assertThat(response.getData().get("users").isArray()).isTrue(); } @Test void testGetUserById() throws IOException { String query = """ query GetUser($id: ID!) { user(id: $id) { id name email posts { id title } } } """; Map<String, Object> variables = Map.of("id", "1"); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query, variables); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("user").get("id").asText()).isEqualTo("1"); assertThat(response.getData().get("user").get("name").asText()).isEqualTo("John Doe"); } @Test void testGetUserNotFound() throws IOException { String query = """ query { user(id: "nonexistent") { id name } } """; GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("user")).isNull(); } @Test void testPostsPagination() throws IOException { String query = """ query GetPosts($first: Int, $after: String) { posts(first: $first, after: $after) { edges { node { id title author { name } } cursor } pageInfo { hasNextPage hasPreviousPage startCursor endCursor } } } """; Map<String, Object> variables = Map.of("first", 1, "after", "0"); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query, variables); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("posts").get("edges")).isNotNull(); assertThat(response.getData().get("posts").get("pageInfo").get("hasNextPage").asBoolean()).isTrue(); } @Test void testSearchUsers() throws IOException { String query = """ query SearchUsers($query: String!) { searchUsers(query: $query) { id name email } } """; Map<String, Object> variables = Map.of("query", "john"); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query, variables); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("searchUsers").isArray()).isTrue(); assertThat(response.getData().get("searchUsers").get(0).get("name").asText()).containsIgnoringCase("john"); } }

8. Mutation Testing

package com.example.graphql.test.mutation; import com.example.graphql.test.client.GraphQLTestClient; import com.example.graphql.test.config.BaseGraphQLTest; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import java.io.IOException; import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; class MutationTest extends BaseGraphQLTest { @Autowired private GraphQLTestClient graphQLTestClient; @Test void testCreateUser() throws IOException { String mutation = """ mutation CreateUser($input: CreateUserInput!) { createUser(input: $input) { id name email age createdAt } } """; Map<String, Object> variables = Map.of( "input", Map.of( "name", "Test User", "email", "[email protected]", "age", 28 ) ); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeMutation(mutation, variables); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("createUser").get("name").asText()).isEqualTo("Test User"); assertThat(response.getData().get("createUser").get("email").asText()).isEqualTo("[email protected]"); assertThat(response.getData().get("createUser").get("id")).isNotNull(); } @Test void testUpdateUser() throws IOException { String mutation = """ mutation UpdateUser($id: ID!, $input: UpdateUserInput!) { updateUser(id: $id, input: $input) { id name email age updatedAt } } """; Map<String, Object> variables = Map.of( "id", "1", "input", Map.of( "name", "Updated Name", "age", 35 ) ); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeMutation(mutation, variables); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("updateUser").get("name").asText()).isEqualTo("Updated Name"); assertThat(response.getData().get("updateUser").get("age").asInt()).isEqualTo(35); } @Test void testUpdateUserNotFound() throws IOException { String mutation = """ mutation UpdateUser($id: ID!, $input: UpdateUserInput!) { updateUser(id: $id, input: $input) { id name } } """; Map<String, Object> variables = Map.of( "id", "nonexistent", "input", Map.of("name", "New Name") ); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeMutation(mutation, variables); assertThat(response.hasErrors()).isTrue(); assertThat(response.getFirstErrorMessage()).contains("User not found"); } @Test void testDeleteUser() throws IOException { String mutation = """ mutation DeleteUser($id: ID!) { deleteUser(id: $id) } """; Map<String, Object> variables = Map.of("id", "2"); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeMutation(mutation, variables); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("deleteUser").asBoolean()).isTrue(); } @Test void testCreatePost() throws IOException { String mutation = """ mutation CreatePost($input: CreatePostInput!) { createPost(input: $input) { id title content published author { id name } } } """; Map<String, Object> variables = Map.of( "input", Map.of( "title", "New Post", "content", "This is a test post", "authorId", "1", "published", true ) ); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeMutation(mutation, variables); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("createPost").get("title").asText()).isEqualTo("New Post"); assertThat(response.getData().get("createPost").get("author").get("id").asText()).isEqualTo("1"); } }

9. Error Handling Testing

package com.example.graphql.test.error; import com.example.graphql.test.client.GraphQLTestClient; import com.example.graphql.test.config.BaseGraphQLTest; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import java.io.IOException; import java.util.Map; import static org.assertj.core.api.Assertions.assertThat; class ErrorHandlingTest extends BaseGraphQLTest { @Autowired private GraphQLTestClient graphQLTestClient; @Test void testInvalidQuerySyntax() throws IOException { String invalidQuery = """ query { users { id name invalidField } } """; GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(invalidQuery); assertThat(response.hasErrors()).isTrue(); assertThat(response.getFirstErrorMessage()).contains("invalidField"); } @Test void testValidationErrors() throws IOException { String mutation = """ mutation CreateUser($input: CreateUserInput!) { createUser(input: $input) { id name } } """; // Missing required fields Map<String, Object> variables = Map.of("input", Map.of()); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeMutation(mutation, variables); assertThat(response.hasErrors()).isTrue(); assertThat(response.getFirstErrorMessage()).contains("Validation error"); } @Test void testFieldLevelErrors() throws IOException { String query = """ query { users { id name posts { id title invalidNestedField } } } """; GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query); assertThat(response.hasErrors()).isTrue(); // Should still get partial data assertThat(response.getData().get("users")).isNotNull(); } @Test void testAuthenticationErrors() throws IOException { String query = """ query { users { id name } } """; Map<String, String> headers = Map.of("Authorization", "Bearer invalid-token"); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query, null, headers); // This depends on your authentication setup // assertThat(response.getStatusCode()).isEqualTo(401); } }

10. Performance and Load Testing

package com.example.graphql.test.performance; import com.example.graphql.test.client.GraphQLTestClient; import com.example.graphql.test.config.BaseGraphQLTest; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import java.io.IOException; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import static org.assertj.core.api.Assertions.assertThat; import static org.awaitility.Awaitility.await; class PerformanceTest extends BaseGraphQLTest { @Autowired private GraphQLTestClient graphQLTestClient; @Test void testConcurrentQueries() throws Exception { int concurrentRequests = 10; ExecutorService executor = Executors.newFixedThreadPool(concurrentRequests); List<CompletableFuture<GraphQLTestClient.GraphQLResponse>> futures = new ArrayList<>(); AtomicInteger successCount = new AtomicInteger(0); String query = """ query { users { id name email } } """; for (int i = 0; i < concurrentRequests; i++) { CompletableFuture<GraphQLTestClient.GraphQLResponse> future = CompletableFuture.supplyAsync(() -> { try { GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query); if (response.isSuccessful()) { successCount.incrementAndGet(); } return response; } catch (IOException e) { throw new RuntimeException(e); } }, executor); futures.add(future); } CompletableFuture<Void> allFutures = CompletableFuture.allOf( futures.toArray(new CompletableFuture[0]) ); allFutures.get(30, TimeUnit.SECONDS); assertThat(successCount.get()).isEqualTo(concurrentRequests); executor.shutdown(); } @Test void testQueryPerformance() throws IOException { String complexQuery = """ query { users { id name email age posts { id title content author { name email } comments { id content author { name } } } } } """; long startTime = System.currentTimeMillis(); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(complexQuery); long endTime = System.currentTimeMillis(); long responseTime = endTime - startTime; assertThat(response.isSuccessful()).isTrue(); assertThat(responseTime).isLessThan(1000); // Should respond within 1 second } @Test void testNPlusOneQueryDetection() throws IOException { // This query could cause N+1 if not properly optimized String query = """ query { users { id name posts { id title author { name posts { id title } } } } } """; GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeQuery(query); assertThat(response.isSuccessful()).isTrue(); // In a real scenario, you'd monitor database queries here } }

11. Subscription Testing

package com.example.graphql.test.subscription; import com.example.graphql.test.client.GraphQLTestClient; import com.example.graphql.test.config.BaseGraphQLTest; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.web.client.TestRestTemplate; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.ResponseEntity; import java.io.IOException; import java.util.Map; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import static org.assertj.core.api.Assertions.assertThat; import static org.awaitility.Awaitility.await; class SubscriptionTest extends BaseGraphQLTest { @Autowired private GraphQLTestClient graphQLTestClient; @Autowired private TestRestTemplate restTemplate; @Test void testPostCreatedSubscription() throws Exception { // This is a simplified test - real WebSocket testing would be more complex String subscriptionQuery = """ subscription { postCreated { id title author { name } } } """; // In a real implementation, you'd use WebSocket client to test subscriptions // For now, we'll test that the mutation triggers the subscription logic String mutation = """ mutation CreatePost($input: CreatePostInput!) { createPost(input: $input) { id title } } """; Map<String, Object> variables = Map.of( "input", Map.of( "title", "Subscription Test Post", "content", "Testing subscription", "authorId", "1", "published", true ) ); GraphQLTestClient.GraphQLResponse response = graphQLTestClient.executeMutation(mutation, variables); assertThat(response.isSuccessful()).isTrue(); assertThat(response.getData().get("createPost").get("title").asText()) .isEqualTo("Subscription Test Post"); } }

12. Integration Testing with TestContainers

package com.example.graphql.test.integration; import com.example.graphql.test.client.GraphQLTestClient; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.web.server.LocalServerPort; import org.springframework.test.context.DynamicPropertyRegistry; import org.springframework.test.context.DynamicPropertySource; import org.testcontainers.containers.PostgreSQLContainer; import org.testcontainers.junit.jupiter.Container; import org.testcontainers.junit.jupiter.Testcontainers; import java.io.IOException; import static org.assertj.core.api.Assertions.assertThat; @Testcontainers @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) class DatabaseIntegrationTest { @LocalServerPort private int port; @Container static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15-alpine") .withDatabaseName("testdb") .withUsername("test") .withPassword("test"); @DynamicPropertySource static void configureProperties(DynamicPropertyRegistry registry) { registry.add("spring.datasource.url", postgres::getJdbcUrl); registry.add("spring.datasource.username", postgres::getUsername); registry.add("spring.datasource.password", postgres::getPassword); } @Test void testGraphQLWithRealDatabase() throws IOException { GraphQLTestClient client = new GraphQLTestClient("http://localhost:" + port + "/graphql"); String query = """ query { users { id name email } } """; GraphQLTestClient.GraphQLResponse response = client.executeQuery(query); assertThat(response.isSuccessful()).isTrue(); assertThat(response.hasErrors()).isFalse(); } }

Test Utilities

13. GraphQL Test Utilities

package com.example.graphql.test.util; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import org.skyscreamer.jsonassert.JSONAssert; import org.skyscreamer.jsonassert.JSONCompareMode; import java.util.List; import java.util.Map; import java.util.stream.Collectors; public class GraphQLTestUtils { private static final ObjectMapper objectMapper = new ObjectMapper(); public static String createQuery(String operation, String fields) { return String.format("query { %s { %s } }", operation, fields); } public static String createMutation(String operation, String input, String fields) { return String.format("mutation { %s(input: %s) { %s } }", operation, input, fields); } public static Map<String, Object> createVariables(Map<String, Object> variables) { return variables; } public static void assertNoErrors(JsonNode response) { assertThat(response.has("errors")).isFalse(); } public static void assertHasErrors(JsonNode response) { assertThat(response.has("errors")).isTrue(); } public static void assertResponseMatches(String actualJson, String expectedJson) throws Exception { JSONAssert.assertEquals(expectedJson, actualJson, JSONCompareMode.LENIENT); } public static List<String> extractFieldValues(JsonNode data, String fieldPath) { String[] path = fieldPath.split("\\."); JsonNode currentNode = data; for (String segment : path) { if (currentNode.isArray()) { // Handle arrays List<String> results = new ArrayList<>(); for (JsonNode node : currentNode) { results.addAll(extractFieldValues(node, String.join(".", Arrays.copyOfRange(path, 1, path.length)))); } return results; } else { currentNode = currentNode.get(segment); } } if (currentNode != null && currentNode.isArray()) { List<String> results = new ArrayList<>(); for (JsonNode node : currentNode) { results.add(node.asText()); } return results; } return List.of(currentNode != null ? currentNode.asText() : ""); } public static class QueryBuilder { private final StringBuilder query = new StringBuilder(); public QueryBuilder query(String operation) { query.append("query { ").append(operation); return this; } public QueryBuilder mutation(String operation) { query.append("mutation { ").append(operation); return this; } public QueryBuilder withField(String field) { query.append(" ").append(field); return this; } public QueryBuilder withFields(String... fields) { for (String field : fields) { query.append(" ").append(field); } return this; } public String build() { return query.append(" } }").toString(); } } }

Configuration

14. Test Configuration

# application-test.yml spring: graphql: graphiql: enabled: true path: /graphiql schema: printer: enabled: true sql: init: platform: postgresql logging: level: com.example.graphql: DEBUG org.springframework.graphql: DEBUG graphql: servlet: enabled: true cors-enabled: true

Best Practices

  1. Test All Operations: Cover queries, mutations, and subscriptions
  2. Test Error Scenarios: Include validation errors, authentication errors, and business logic errors
  3. Performance Testing: Test query performance and N+1 query detection
  4. Security Testing: Test authentication and authorization
  5. Integration Testing: Test with real databases and external services
  6. Use Test Containers: For realistic integration testing
  7. Mock External Services: When testing in isolation
  8. Test Data Loading: Use consistent test data setup
  9. Concurrent Testing: Test for thread safety and performance under load
  10. Schema Testing: Validate GraphQL schema compliance

Conclusion

This comprehensive GraphQL testing framework provides:

  • Query Testing: Test all GraphQL query operations
  • Mutation Testing: Test create, update, and delete operations
  • Error Handling: Test various error scenarios
  • Performance Testing: Test query performance and load handling
  • Subscription Testing: Test real-time updates
  • Integration Testing: Test with real databases using TestContainers
  • Test Utilities: Helper methods for common testing patterns

The framework enables robust testing of GraphQL APIs in Java applications, ensuring reliability, performance, and correctness of your GraphQL implementation.

Pyroscope Profiling in Java
Explains how to use Pyroscope for continuous profiling in Java applications, helping developers analyze CPU and memory usage patterns to improve performance and identify bottlenecks.
https://macronepal.com/blog/pyroscope-profiling-in-java/

OpenTelemetry Metrics in Java: Comprehensive Guide
Provides a complete guide to collecting and exporting metrics in Java using OpenTelemetry, including counters, histograms, gauges, and integration with monitoring tools. (MACRO NEPAL)
https://macronepal.com/blog/opentelemetry-metrics-in-java-comprehensive-guide/

OTLP Exporter in Java: Complete Guide for OpenTelemetry
Explains how to configure OTLP exporters in Java to send telemetry data such as traces, metrics, and logs to monitoring systems using HTTP or gRPC protocols. (MACRO NEPAL)
https://macronepal.com/blog/otlp-exporter-in-java-complete-guide-for-opentelemetry/

Thanos Integration in Java: Global View of Metrics
Explains how to integrate Thanos with Java monitoring systems to create a scalable global metrics view across multiple Prometheus instances.

https://macronepal.com/blog/thanos-integration-in-java-global-view-of-metrics

Time Series with InfluxDB in Java: Complete Guide (Version 2)
Explains how to manage time-series data using InfluxDB in Java applications, including storing, querying, and analyzing metrics data.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide-2

Time Series with InfluxDB in Java: Complete Guide
Provides an overview of integrating InfluxDB with Java for time-series data handling, including monitoring applications and managing performance metrics.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide

Implementing Prometheus Remote Write in Java (Version 2)
Explains how to configure Java applications to send metrics data to Prometheus-compatible systems using the remote write feature for scalable monitoring.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide-2

Implementing Prometheus Remote Write in Java: Complete Guide
Provides instructions for sending metrics from Java services to Prometheus servers, enabling centralized monitoring and real-time analytics.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide

Building a TileServer GL in Java: Vector and Raster Tile Server
Explains how to build a TileServer GL in Java for serving vector and raster map tiles, useful for geographic visualization and mapping applications.

https://macronepal.com/blog/building-a-tileserver-gl-in-java-vector-and-raster-tile-server

Indoor Mapping in Java
Explains how to create indoor mapping systems in Java, including navigation inside buildings, spatial data handling, and visualization techniques.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper