GraphQL APIs with Spring Boot · 강의

GraphQL API 통합 테스트

전체 GraphQL API에 대한 통합 테스트를 수행해 쿼리, 변이, 구독을 엔드투엔드로 검증합니다.

레슨 2/411개 단계

GraphQL API 통합 테스트은(는) CoddyKit의 무료 GraphQL APIs with Spring Boot 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 GraphQL APIs with Spring Boot 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. GraphQL APIs with Spring Boot 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Why Integration Test GraphQL?

Welcome to integration testing for GraphQL APIs! While unit tests check small parts of your code, integration tests verify that different components work together correctly.

End-to-End Flow: They simulate real client requests.
Component Interaction: Ensure your GraphQL schema, resolvers, and data sources all connect properly.
Confidence: Gives you assurance that your API behaves as expected before deployment.

This lesson focuses on using Spring Boot's testing utilities.

Essential Spring Boot Test Tools

Spring Boot provides powerful tools to make integration testing straightforward:

@SpringBootTest: This annotation loads your full application context, making all your beans available for testing.
WebTestClient: A non-blocking client for testing web endpoints. It simulates HTTP requests to your GraphQL API.

Together, these allow you to send actual GraphQL queries/mutations and inspect the responses.

Setting Up Your Test Class

To start, you'll create a test class. Annotate it with @SpringBootTest to load your application context. Then, inject WebTestClient to interact with your GraphQL endpoint.

We typically use @AutoConfigureWebTestClient to configure WebTestClient for testing, often with a specific port or context path.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
class GraphQLIntegrationTest {

  @Autowired
  private WebTestClient webTestClient;

  // Your test methods will go here
}

Crafting a Simple Query Test

Let's write a test for a basic GraphQL query. We'll define the query string and then use WebTestClient to send it to the /graphql endpoint.

The query will be sent as a JSON payload in the request body, typically containing a query field and optionally variables.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;
import java.util.Map;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
class SampleQueryTest {

  @Autowired
  private WebTestClient webTestClient;

  @Test
  void testHelloQuery() {
    String graphQlQuery = "{ hello }";

    webTestClient.post().uri("/graphql")
        .bodyValue(Map.of("query", graphQlQuery))
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .jsonPath("$.data.hello").isEqualTo("Hello, GraphQL!");
  }
}

Runnable: Query & Assert Result

Here's a full runnable example. We have a simple Spring Boot app with a hello GraphQL query, and an integration test verifying its output.

Notice how jsonPath is used to navigate the GraphQL response structure (data.hello) and assert the value.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.graphql.data.method.annotation.QueryMapping;
import org.springframework.stereotype.Controller;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;
import java.util.Map;

// --- Application Code ---
@SpringBootApplication
public class GraphQLApp {
  public static void main(String[] args) {
    SpringApplication.run(GraphQLApp.class, args);
  }
}

@Controller
class HelloResolver {
  @QueryMapping
  public String hello() {
    return "Hello, GraphQL!";
  }
}

// --- Test Code ---
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
class HelloQueryIntegrationTest {
  @Autowired
  private WebTestClient webTestClient;

  @Test
  void testHelloQuery() {
    String graphQlQuery = "{ hello }";

    webTestClient.post().uri("/graphql")
        .bodyValue(Map.of("query", graphQlQuery))
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .jsonPath("$.data.hello").isEqualTo("Hello, GraphQL!");
  }
}

Testing Queries with Variables

Many GraphQL queries take arguments. You can pass these as variables in your request payload. The variables field in the JSON request body should be a map of variable names to their values.

Remember to define the variables in your GraphQL query string (e.g., query MyQuery($name: String!)).

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;
import java.util.Map;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
class QueryWithVarsTest {

  @Autowired
  private WebTestClient webTestClient;

  @Test
  void testGreetQueryWithName() {
    String graphQlQuery = "query Greet($name: String!) { greet(name: $name) }";
    Map<String, Object> variables = Map.of("name", "Coddy");

    webTestClient.post().uri("/graphql")
        .bodyValue(Map.of("query", graphQlQuery, "variables", variables))
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .jsonPath("$.data.greet").isEqualTo("Hello, Coddy!");
  }
}

Integration Testing a Mutation

Mutations are used for creating, updating, or deleting data. Testing them follows a similar pattern to queries but you'll use the mutation keyword in your GraphQL string.

It's good practice to assert the return value of the mutation and, if applicable, verify the state change (e.g., by performing a subsequent query).

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;
import java.util.Map;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
class MutationIntegrationTest {

  @Autowired
  private WebTestClient webTestClient;

  @Test
  void testCreateItemMutation() {
    String graphQlMutation = "mutation CreateItem($name: String!) { createItem(name: $name) { id name } }";
    Map<String, Object> variables = Map.of("name", "New Widget");

    webTestClient.post().uri("/graphql")
        .bodyValue(Map.of("query", graphQlMutation, "variables", variables))
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .jsonPath("$.data.createItem.name").isEqualTo("New Widget");
  }
}

Handling GraphQL Errors in Tests

When your GraphQL API encounters an error (e.g., validation failure, unauthorized access), it typically returns an errors array in the response body, alongside a potential data field (if some parts succeeded).

You can use jsonPath to check for the presence and content of these error messages in your tests.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;
import java.util.Map;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
class ErrorHandlingTest {

  @Autowired
  private WebTestClient webTestClient;

  @Test
  void testInvalidInputError() {
    String graphQlMutation = "mutation CreateItem($name: String!) { createItem(name: $name) { id } }";
    Map<String, Object> variables = Map.of("name", ""); // Assume empty name is invalid

    webTestClient.post().uri("/graphql")
        .bodyValue(Map.of("query", graphQlMutation, "variables", variables))
        .exchange()
        .expectStatus().isOk() // GraphQL errors usually return 200 OK
        .expectBody()
        .jsonPath("$.errors").isArray()
        .jsonPath("$.errors[0].message").isNotEmpty()
        .jsonPath("$.errors[0].message").isEqualTo("Item name cannot be empty.");
  }
}

Testing Protected Endpoints

If your GraphQL API uses Spring Security, you'll want to test how it responds to authenticated and unauthenticated requests. WebTestClient allows you to easily add headers, including authorization tokens.

This ensures your security configuration correctly protects your GraphQL fields and operations.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;
import java.util.Map;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureWebTestClient
class ProtectedEndpointTest {

  @Autowired
  private WebTestClient webTestClient;

  @Test
  void testProtectedQuery_unauthorized() {
    String graphQlQuery = "{ protectedData }";

    webTestClient.post().uri("/graphql")
        .bodyValue(Map.of("query", graphQlQuery))
        .exchange()
        .expectStatus().isOk() // GraphQL often returns 200 with errors for auth issues
        .expectBody()
        .jsonPath("$.errors").isArray()
        .jsonPath("$.errors[0].message").isEqualTo("Unauthorized access");
  }

  @Test
  void testProtectedQuery_authorized() {
    String graphQlQuery = "{ protectedData }";
    String validToken = "mock-jwt-token"; // In a real app, generate a valid test token

    webTestClient.post().uri("/graphql")
        .header("Authorization", "Bearer " + validToken)
        .bodyValue(Map.of("query", graphQlQuery))
        .exchange()
        .expectStatus().isOk()
        .expectBody()
        .jsonPath("$.data.protectedData").isEqualTo("Secret Info");
  }
}

Quick Check: Integration Tests

Consider the following GraphQL query and a Spring Boot application that exposes a product(id: ID!) query. Which WebTestClient assertion correctly verifies that a product with ID '123' and name 'Laptop' is returned?

인터랙티브 레슨에서 답해보세요

Recap: GraphQL Integration Testing

In this lesson, you learned how to perform integration tests for your GraphQL APIs using Spring Boot.

We covered setting up your test environment with @SpringBootTest and WebTestClient.
You saw how to craft and execute GraphQL queries and mutations, including passing variables.
We explored asserting the expected data in the response using jsonPath.
Finally, you learned to handle error responses and test protected endpoints.

Integration tests are vital for ensuring the robustness and correctness of your GraphQL API!

무료로 시작

AI 튜터와 함께 GraphQL APIs with Spring Boot을(를) 배우세요 — 무료

브라우저에서 실제 코드를 작성하고 실행하며, 24/7 AI 튜터로부터 즉각적인 도움을 받고, 웹이나 앱에서 중단한 부분부터 계속 학습하세요.

코스: 12
레슨: 48

무료로 학습 시작 전체 코스 보기

자주 묻는 질문

“GraphQL API 통합 테스트” 강의는 무료인가요?

네 — “GraphQL API 통합 테스트” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 GraphQL APIs with Spring Boot 강의 전체를 잠금 해제할 수 있습니다. GraphQL APIs with Spring Boot 강의에는 총 4개의 강의가 포함되어 있습니다.

“GraphQL API 통합 테스트”에서 뭘 배우나요?

전체 GraphQL API에 대한 통합 테스트를 수행해 쿼리, 변이, 구독을 엔드투엔드로 검증합니다. 브라우저에서 직접 실행하는 실습 코드로 GraphQL APIs with Spring Boot을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

GraphQL APIs with Spring Boot을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 GraphQL APIs with Spring Boot은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“GraphQL API 통합 테스트” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 GraphQL APIs with Spring Boot 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 GraphQL APIs with Spring Boot 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← GraphQL APIs with Spring Boot(으)로 돌아가기