Bootcamp i backendutvikling med Node.js · leksjon

Integrasjonstesting av API-endepunkter

Implementer integrasjonstester for å kontrollere samspillet mellom ulike komponenter og sikre at API-et fungerer som det skal.

Leksjon 2 av 411 trinn

Integrasjonstesting av API-endepunkter er en gratis leksjon i Bootcamp i backendutvikling med Node.js på CoddyKit. Dette er leksjon 2 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 Bootcamp i backendutvikling med Node.js, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.

Hva er integrasjonstesting?

Velkommen! I denne leksjonen skal vi se nærmere på integrasjonstesting av Node.js API-endepunkter. I motsetning til enhetstester, som tester små, isolerte deler av kode, kontrollerer integrasjonstester at ulike deler av applikasjonen fungerer sammen som forventet.

For API-er innebærer dette å sikre at endepunktene håndterer forespørsler riktig, samhandler med databaser eller andre tjenester og returnerer riktige svar.

Hvorfor teste API-endepunkter?

API-et er den viktigste måten eksterne klienter samhandler med backend på. Robuste integrasjonstester sikrer at:

Endepunktene svarer med riktige HTTP-statuskoder.
Data som sendes til API-et, behandles og lagres riktig.
API-et returnerer forventede dataformater, for eksempel JSON.
Ulike komponenter, som ruting, middleware og database, integreres sømløst.

Dette bidrar til å oppdage feil tidlig som enhetstester kanskje ikke fanger opp.

Viktige testverktøy

For å teste Node.js API-endepunktene våre bruker vi et par viktige verktøy:

Jest: Testkjøreren og biblioteket for påstander som ble introdusert i leksjon 1.
Supertest: Et bibliotek utviklet for å teste HTTP-servere. Det gjør det enkelt å sende forespørsler og kontrollere svar.
Express: Web-rammeverket vårt, som brukes til å bygge selve API-et.

Konfigurere Supertest

Først installerer vi de nødvendige pakkene. Vi trenger express til eksempel-API-et vårt, samt jest og supertest til testingen.

Kjør denne kommandoen i prosjektets terminal:

npm install --save-dev express jest supertest

Vår enkle Express-app

La oss opprette en grunnleggende Express-applikasjon som vi kan teste. Vi definerer noen enkle ruter.

Legg merke til at vi eksporterer app-instansen. Supertest bruker den til å sende forespørsler direkte, uten at vi trenger å starte en aktiv server på en port.

const express = require('express');
const app = express();

// Middleware to parse JSON request bodies
app.use(express.json());

// A simple GET route
app.get('/', (req, res) => {
  res.send('Hello from Express!');
});

// A GET route that returns JSON
app.get('/data', (req, res) => {
  res.json({ message: 'API data', version: 1.0 });
});

// A POST route that echoes the request body
app.post('/echo', (req, res) => {
  res.json(req.body);
});

// Export the app for testing purposes
module.exports = app;

// Start the server only if not in a test environment
if (process.env.NODE_ENV !== 'test') {
  const port = 3000;
  app.listen(port, () => {
    console.log(`Server running on port ${port}`);
  });
}

Teste et GET-endepunkt

La oss nå skrive vår første integrasjonstest. Vi bruker supertest til å sende en GET-forespørsel til rotendepunktet / og kontrollere svaret.

Opprett en fil som app.test.js og legg til følgende:

const request = require('supertest');
const app = require('./app'); // Import our Express app

describe('GET /', () => {
  it('should return "Hello from Express!"', async () => {
    const res = await request(app).get('/');
    expect(res.statusCode).toEqual(200);
    expect(res.text).toEqual('Hello from Express!');
  });
});

Kontrollere JSON-svar

API-er returnerer ofte JSON-data. Supertest gjør det enkelt å få tilgang til den analyserte JSON-kroppen i et svar ved hjelp av res.body.

La oss teste /data-endepunktet for å sikre at det returnerer riktig JSON-objekt:

const request = require('supertest');
const app = require('./app');

describe('GET /data', () => {
  it('should return JSON with message and version', async () => {
    const res = await request(app).get('/data');
    expect(res.statusCode).toEqual(200);
    expect(res.type).toEqual('application/json');
    expect(res.body).toEqual({ message: 'API data', version: 1.0 });
    expect(res.body.message).toBe('API data');
  });
});

Teste POST-forespørsler

Testing av POST-forespørsler fungerer på lignende måte, men vi bruker .post() og ofte .send() for å legge ved en forespørselskropp.

/echo-endepunktet vårt returnerer ganske enkelt JSON-dataene det mottar. La oss teste denne funksjonaliteten:

const request = require('supertest');
const app = require('./app');

describe('POST /echo', () => {
  it('should echo the sent JSON data', async () => {
    const testData = { name: 'Coddy', score: 95 };
    const res = await request(app)
      .post('/echo')
      .send(testData);

    expect(res.statusCode).toEqual(200);
    expect(res.type).toEqual('application/json');
    expect(res.body).toEqual(testData);
  });
});

Databaseinteraksjoner og opprydding

Når De tester API-er som samhandler med en database, gjør De vanligvis følgende:

Bruker en egen testdatabase for å unngå å forurense utviklingsdataene.
Tømmer databasen før hver testpakke eller hvert testtilfelle ved hjelp av beforeEach/afterEach-hooks.
Setter inn testdata hvis en test trenger bestemte data.

Dette sikrer at testene er uavhengige og kan gjentas.

API-testscenario

De tester et Node.js API-endepunkt /users som godtar POST-forespørsler for å opprette en ny bruker. Hvilke av de følgende påstandene er SANNE om integrasjonstesting av dette endepunktet?

Besvar den i den interaktive leksjonen

Oppsummering: Integrasjonstesting

Godt jobbet! De har lært det grunnleggende om integrasjonstesting av Node.js API-endepunkter:

Hva det er: Å kontrollere at komponenter fungerer sammen, spesielt ved API-forespørsler.
Verktøy: Å bruke Supertest sammen med Jest for å simulere HTTP-forespørsler.
Metode: Å sende GET-/POST-forespørsler og kontrollere statuskoder, innholdet i svaret og datatyper.
Beste praksis: Å vurdere egne testdatabaser for å sikre isolasjon.

Dette sikrer at API-et er robust og pålitelig!

Gratis å komme i gang

Lær deg JavaScript 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: 22
Leksjoner: 92

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Integrasjonstesting av API-endepunkter» gratis?

Ja – hele teksten i «Integrasjonstesting av API-endepunkter» 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 Bootcamp i backendutvikling med Node.js-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Bootcamp i backendutvikling med Node.js inneholder totalt 4 leksjoner.

Hva lærer jeg i «Integrasjonstesting av API-endepunkter»?

Implementer integrasjonstester for å kontrollere samspillet mellom ulike komponenter og sikre at API-et fungerer som det skal. Du øver på Bootcamp i backendutvikling med Node.js 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 Bootcamp i backendutvikling med Node.js?

Ingen tidligere erfaring er nødvendig. Bootcamp i backendutvikling med Node.js 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 2 av 4.

Hvor lang tid tar leksjonen «Integrasjonstesting av API-endepunkter»?

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 Bootcamp i backendutvikling med Node.js-leksjonen?

Ja. Alle Bootcamp i backendutvikling med Node.js-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

← Tilbake til Bootcamp i backendutvikling med Node.js