Enhetstesting av GraphQL-resolvere
Skriv effektive enhetstester for GraphQL-resolverne og datainnhentingslogikken din i Spring Boot.
Enhetstesting av GraphQL-resolvere er en gratis leksjon i GraphQL-API-er med Spring Boot på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i GraphQL-API-er med Spring Boot, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i GraphQL-API-er med Spring Boot inneholder totalt 4 leksjoner.
Hvorfor skrive enhetstester for resolvere?
Enhetstesting er avgjørende for å sikre at GraphQL-API-et er pålitelig. Når vi skriver enhetstester for resolvere, fokuserer vi på å teste individuelle komponenter isolert.
- Isolasjon: Vi tester en resolver uten å trenge en server eller database som kjører.
- Korrekthet: Kontroller resolverens logikk, håndtering av argumenter og datatransformasjon.
- Hastighet: Enhetstester kjører svært raskt og gir rask tilbakemelding under utviklingen.
Denne leksjonen veileder Dem gjennom skriving av effektive enhetstester for GraphQL-resolvere i Spring Boot.
Oversikt over Spring Boot-resolvere
Før testingen kan vi kort se på hvordan resolvere er strukturert i Spring Boot. De er vanligvis Spring-@Controller-komponenter med metoder som er annotert for GraphQL-operasjoner, for eksempel @QueryMapping eller @MutationMapping.
Disse metodene er ofte avhengige av andre Spring-@Service-komponenter for å hente eller endre data. Det er her mocking er nyttig i testingen.
Sette opp testmiljøet
Til enhetstesting i Spring Boot bruker De hovedsakelig JUnit 5 og Mockito. Disse følger vanligvis med som standard i spring-boot-starter-test.
- JUnit 5: Testrammeverket som brukes til å skrive og kjøre testene.
- Mockito: Et rammeverk for mocking som oppretter mock-objekter for avhengigheter, slik at resolveren som testes kan isoleres.
Sørg for at pom.xml eller build.gradle inneholder avhengigheten spring-boot-starter-test.
Isolere resolvere med mock-objekter
Resolvere samhandler ofte med tjenester, repositories eller andre komponenter. For å enhetsteste en resolver må vi isolere den fra disse avhengighetene.
Mockito hjelper oss med å opprette «mock»-objekter som etterligner oppførselen til virkelige avhengigheter. Dette lar oss kontrollere hva avhengighetene returnerer, og bekrefte hvordan de kalles, uten å faktisk kjøre den virkelige logikken deres.
@Mock: Oppretter en mock-instans av en klasse eller et grensesnitt.@InjectMocks: Injiserer de opprettede mock-objektene i objektet som testes.@ExtendWith(MockitoExtension.class): Integrerer Mockito med JUnit 5.
Teste en enkel resolver
La oss begynne med en grunnleggende resolver som ikke har noen eksterne avhengigheter. Vi kan instansiere den direkte og kalle metoden.
Dette eksempelet viser en enkel resolver og den tilhørende enhetstesten med påstander fra JUnit 5.
package com.example.app;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
// Imagine MyResolver.java exists with a greeting() method
// @Controller
// public class MyResolver {
// @QueryMapping
// public String greeting() {
// return "Hello GraphQL!";
// }
// }
class MyResolverTest {
@Test
void greetingReturnsCorrectMessage() {
// 1. Arrange: Create an instance of the resolver
MyResolver resolver = new MyResolver();
// 2. Act: Call the method under test
String result = resolver.greeting();
// 3. Assert: Verify the output
assertEquals("Hello GraphQL!", result);
}
}Teste med mockede tjenester
De fleste resolvere er avhengige av tjenester for å utføre forretningslogikk. Slik tester De en resolver som bruker en GreetingService.
Vi bruker @Mock for tjenesten og @InjectMocks for resolveren. Deretter forteller when().thenReturn() mock-objektet hva det skal returnere når metoden kalles.
package com.example.app;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
// Imagine GreetingResolver.java and GreetingService.java exist
// (see previous scenes for context)
@ExtendWith(MockitoExtension.class)
class GreetingResolverTest {
@Mock
private GreetingService greetingService;
@InjectMocks
private GreetingResolver greetingResolver;
@Test
void personalizedGreetingReturnsExpected() {
// Arrange: Define mock behavior
when(greetingService.generateGreeting("Alice"))
.thenReturn("Hello, Alice!");
// Act: Call resolver method
String result = greetingResolver.personalizedGreeting("Alice");
// Assert: Verify resolver's output
assertEquals("Hello, Alice!", result);
}
}Kontrollere inndataargumenter
Det er viktig å sikre at resolveren sender argumentene riktig videre til de underliggende tjenestene. Mockitos verify()-metode hjelper med dette.
Mockito.verify(mockObject).method(expectedArgs) bekrefter at den angitte metoden ble kalt med nøyaktig de forventede argumentene under testkjøringen.
package com.example.app;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class GreetingResolverVerifyTest {
@Mock
private GreetingService greetingService;
@InjectMocks
private GreetingResolver greetingResolver;
@Test
void serviceCalledWithCorrectArgument() {
// Arrange
when(greetingService.generateGreeting("Bob"))
.thenReturn("Hi Bob!");
// Act
greetingResolver.personalizedGreeting("Bob");
// Assert: Verify service method was called with "Bob"
verify(greetingService).generateGreeting("Bob");
}
}Teste forventede returverdier
Etter at en resolver har behandlet data, skal den returnere riktig resultat. JUnits påstander brukes til å bekrefte disse returverdiene.
assertEquals(expected, actual): Kontrollerer om to verdier er like.assertNotNull(object): Kontrollerer om et objekt ikke er null.assertTrue(condition): Kontrollerer om en betingelse er sann.
Kontroller alltid den endelige tilstanden eller returverdien til resolver-metoden.
package com.example.app;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class GreetingResolverAssertTest {
@Mock
private GreetingService greetingService;
@InjectMocks
private GreetingResolver greetingResolver;
@Test
void personalizedGreetingReturnsExpectedValue() {
String name = "Charlie";
String expectedGreeting = "Hello, Charlie!";
// Arrange
when(greetingService.generateGreeting(name))
.thenReturn(expectedGreeting);
// Act
String actualGreeting =
greetingResolver.personalizedGreeting(name);
// Assert
assertEquals(expectedGreeting, actualGreeting);
}
}Teste feilsituasjoner
Robuste resolvere bør håndtere feil på en god måte. Enhetstester kan bekrefte at resolverne kaster forventede unntak eller håndterer dem på riktig måte.
Bruk JUnits assertThrows for å bekrefte at en bestemt unntakstype kastes når bestemte betingelser er oppfylt, for eksempel når en tjeneste mislykkes.
package com.example.app;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class ErrorHandlingResolverTest {
@Mock
private GreetingService greetingService;
@InjectMocks
private GreetingResolver greetingResolver;
@Test
void personalizedGreetingThrowsExceptionOnError() {
String name = "ErrorUser";
// Arrange: Mock service to throw an exception
when(greetingService.generateGreeting(name))
.thenThrow(new RuntimeException("Service failed"));
// Act & Assert: Verify that the resolver throws
assertThrows(RuntimeException.class, () -> {
greetingResolver.personalizedGreeting(name);
});
}
}Hurtigsjekk: konsepter for enhetstesting
Når De enhetstester en Spring Boot GraphQL-resolver som er avhengig av en UserService, hva er hovedhensikten med å bruke Mockitos @Mock-annotasjon på UserService-instansen i testklassen?
Oppsummering og veien videre
Gratulerer! De har lært det grunnleggende om enhetstesting av GraphQL-resolvere i Spring Boot.
- Vi har forstått hvor viktig isolasjon er for enhetstester.
- Vi brukte Mockito til å mocke tjenesteavhengigheter.
- Vi skrev tester for å kontrollere resolverens logikk, videsending av argumenter og returverdier.
- Vi har også gått gjennom testing av feilsituasjoner.
Ved å bruke disse teknikkene kan De sikre at GraphQL-resolverne er robuste og oppfører seg som forventet. Deretter kan De utforske integrasjonstesting for å kontrollere hele GraphQL-API-et fra ende til ende.
Lær deg GraphQL-API-er med Spring Boot med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 12
- Leksjoner
- 48
Ofte stilte spørsmål
Er leksjonen «Enhetstesting av GraphQL-resolvere» gratis?
Ja – hele teksten i «Enhetstesting av GraphQL-resolvere» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av GraphQL-API-er med Spring Boot-kurset, kan du oppgradere til CoddyKit PRO. Kurset i GraphQL-API-er med Spring Boot inneholder totalt 4 leksjoner.
Hva lærer jeg i «Enhetstesting av GraphQL-resolvere»?
Skriv effektive enhetstester for GraphQL-resolverne og datainnhentingslogikken din i Spring Boot. Du øver på GraphQL-API-er med Spring Boot med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med GraphQL-API-er med Spring Boot?
Ingen tidligere erfaring er nødvendig. GraphQL-API-er med Spring Boot på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.
Hvor lang tid tar leksjonen «Enhetstesting av GraphQL-resolvere»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne GraphQL-API-er med Spring Boot-leksjonen?
Ja. Alle GraphQL-API-er med Spring Boot-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- Enhetstesting av GraphQL-resolvere
- Integrasjonstesting av GraphQL-API-er
- Utrulling av Spring Boot GraphQL
- Kontinuerlig integrasjon for GraphQL-API-er