GraphQL-API's met Spring Boot · Les

GraphQL-API's integratietesten

Voer integratietests uit voor uw volledige GraphQL-API en controleer queries, mutations en subscriptions van begin tot eind.

Les 2 van 411 stappen

GraphQL-API's integratietesten is een gratis GraphQL-API's met Spring Boot-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject GraphQL-API's met Spring Boot. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus GraphQL-API's met Spring Boot bevat in totaal 4 lessen.

Waarom GraphQL integratietesten?

Welkom bij integratietests voor GraphQL-API's! Terwijl unittests kleine onderdelen van je code controleren, verifiëren integratietests of verschillende componenten correct samenwerken.

End-to-endverwerking: ze simuleren echte clientverzoeken.
Interactie tussen componenten: ze zorgen ervoor dat je GraphQL-schema, resolvers en gegevensbronnen goed met elkaar verbonden zijn.
Vertrouwen: ze geven je de zekerheid dat je API zich vóór de implementatie gedraagt zoals verwacht.

Deze les richt zich op het gebruik van de testhulpmiddelen van Spring Boot.

Essentiële testhulpmiddelen van Spring Boot

Spring Boot biedt krachtige hulpmiddelen om integratietests eenvoudig te maken:

@SpringBootTest: deze annotatie laadt de volledige applicatiecontext, zodat al je beans beschikbaar zijn voor tests.
WebTestClient: een niet-blokkerende client voor het testen van web-eindpunten. Deze simuleert HTTP-verzoeken naar je GraphQL-API.

Samen maken deze hulpmiddelen het mogelijk om echte GraphQL-query's en -mutaties te versturen en de antwoorden te inspecteren.

Je testklasse instellen

Om te beginnen maak je een testklasse. Annoteer deze met @SpringBootTest om je applicatiecontext te laden. Injecteer vervolgens WebTestClient om met je GraphQL-eindpunt te communiceren.

Meestal gebruiken we @AutoConfigureWebTestClient om WebTestClient voor tests te configureren, vaak met een specifieke poort of contextpad.

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
}

Een eenvoudige querytest schrijven

Laten we een test voor een eenvoudige GraphQL-query schrijven. We definiëren de querytekenreeks en gebruiken vervolgens WebTestClient om deze naar het eindpunt /graphql te sturen.

De query wordt als JSON-payload in de hoofdtekst van het verzoek verstuurd, meestal met een veld query en optioneel 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!");
  }
}

Uitvoerbaar: resultaat opvragen en controleren

Hier is een volledig uitvoerbaar voorbeeld. We hebben een eenvoudige Spring Boot-app met een GraphQL-query hello en een integratietest die de uitvoer ervan controleert.

Let op hoe jsonPath wordt gebruikt om door de structuur van het GraphQL-antwoord (data.hello) te navigeren en de waarde te controleren.

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!");
  }
}

Query's met variabelen testen

Veel GraphQL-query's accepteren argumenten. Je kunt deze als variables in de payload van je verzoek doorgeven. Het veld variables in de JSON-hoofdtekst van het verzoek moet een toewijzing zijn van variabelenamen aan hun waarden.

Vergeet niet de variabelen in je GraphQL-querytekenreeks te definiëren, bijvoorbeeld 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!");
  }
}

Een mutatie integratietesten

Mutaties worden gebruikt om gegevens te maken, bij te werken of te verwijderen. Het testen ervan volgt een vergelijkbaar patroon als bij query's, maar je gebruikt het sleutelwoord mutation in je GraphQL-tekenreeks.

Het is een goede gewoonte om de retourwaarde van de mutatie te controleren en, indien van toepassing, de statuswijziging te verifiëren, bijvoorbeeld door een daaropvolgende query uit te voeren.

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");
  }
}

GraphQL-fouten in tests afhandelen

Wanneer je GraphQL-API een fout tegenkomt, zoals een validatiefout of onbevoegde toegang, retourneert deze meestal een array errors in de hoofdtekst van het antwoord, naast een mogelijk veld data als sommige onderdelen wel zijn geslaagd.

Je kunt jsonPath gebruiken om in je tests de aanwezigheid en inhoud van deze foutberichten te controleren.

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.");
  }
}

Beveiligde eindpunten testen

Als je GraphQL-API Spring Security gebruikt, wil je testen hoe deze reageert op geauthenticeerde en niet-geauthenticeerde verzoeken. Met WebTestClient kun je eenvoudig headers toevoegen, waaronder autorisatietokens.

Zo controleer je of je beveiligingsconfiguratie je GraphQL-velden en -bewerkingen correct beschermt.

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");
  }
}

Korte controle: integratietests

Bekijk de volgende GraphQL-query en een Spring Boot-toepassing die een product(id: ID!)-query beschikbaar maakt. Welke WebTestClient-assertie controleert correct of een product met ID '123' en de naam 'Laptop' wordt geretourneerd?

Beantwoord dit in de interactieve les

Samenvatting: integratietests voor GraphQL

In deze les heb je geleerd hoe je integratietests uitvoert voor je GraphQL-API's met Spring Boot.

We hebben besproken hoe je je testomgeving instelt met @SpringBootTest en WebTestClient.
Je hebt gezien hoe je GraphQL-queries en -mutaties opstelt en uitvoert, inclusief het doorgeven van variabelen.
We hebben onderzocht hoe je de verwachte gegevens in het antwoord controleert met jsonPath.
Tot slot heb je geleerd hoe je omgaat met foutantwoorden en beveiligde eindpunten test.

Integratietests zijn essentieel om de robuustheid en juistheid van je GraphQL-API te waarborgen!

Gratis beginnen

Leer GraphQL-API's met Spring Boot met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “GraphQL-API's integratietesten” gratis?

Ja — de volledige tekst van “GraphQL-API's integratietesten” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus GraphQL-API's met Spring Boot wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus GraphQL-API's met Spring Boot bevat in totaal 4 lessen.

Wat leer ik in “GraphQL-API's integratietesten”?

Voer integratietests uit voor uw volledige GraphQL-API en controleer queries, mutations en subscriptions van begin tot eind. Je oefent met GraphQL-API's met Spring Boot door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met GraphQL-API's met Spring Boot te beginnen?

Ervaring vooraf is niet nodig. GraphQL-API's met Spring Boot op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “GraphQL-API's integratietesten”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over GraphQL-API's met Spring Boot?

Ja. Elke les over GraphQL-API's met Spring Boot bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

GraphQL-resolvers unit-testen
GraphQL-API's integratietesten
Spring Boot GraphQL implementeren
Continuous Integration voor GraphQL-API's

← Terug naar GraphQL-API's met Spring Boot