Bootcamp i backendutveckling med Node.js · Lektion

Integrationstestning av API-slutpunkter

Implementera integrationstester för att verifiera samspelet mellan olika komponenter och säkerställa API:ets funktionalitet.

Lektion 2 av 411 steg

Integrationstestning av API-slutpunkter är en gratis lektion i Bootcamp i backendutveckling med Node.js på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med Node.js, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad är integrationstestning?

Välkommen! I den här lektionen går vi igenom integrationstestning av Node.js API-endpoints. Till skillnad från enhetstester, som testar små och isolerade delar av koden, verifierar integrationstester att olika delar av applikationen fungerar tillsammans som förväntat.

För API:er innebär det att säkerställa att era endpoints hanterar förfrågningar korrekt, samverkar med databaser eller andra tjänster och returnerar rätt svar.

Varför testa API-endpoints?

Ert API är det huvudsakliga sättet för externa klienter att interagera med backend-systemet. Robusta integrationstester säkerställer att:

Endpoints svarar med korrekta HTTP-statuskoder.
Data som skickas till API:et bearbetas och lagras korrekt.
API:et returnerar förväntade dataformat, till exempel JSON.
Olika komponenter, som routing, middleware och databas, integreras sömlöst.

Det hjälper till att upptäcka buggar tidigt som enhetstester kanske missar.

Viktiga testverktyg

För att testa våra Node.js API-endpoints använder vi några viktiga verktyg:

Jest: Vår testrunner och vårt bibliotek för påståenden (introducerades i lektion 1).
Supertest: Ett bibliotek som är utformat för att testa HTTP-servrar. Det gör det enkelt att skicka förfrågningar och kontrollera svar.
Express: Vårt webbramverk för att bygga själva API:et.

Konfigurera Supertest

Först installerar vi de paket som behövs. Vi behöver express för vårt exempel-API samt jest och supertest för testningen.

Kör följande kommando i projektets terminal:

npm install --save-dev express jest supertest

Vår enkla Express-app

Nu skapar vi en grundläggande Express-applikation som vi kan testa. Vi definierar några enkla routes.

Observera att vi exporterar instansen app, som Supertest använder för att skicka förfrågningar direkt utan att behöva starta 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}`);
  });
}

Testa en GET-endpoint

Nu skriver vi vårt första integrationstest. Vi använder supertest för att skicka en GET-förfrågan till vår root-endpoint / och kontrollera svaret.

Skapa en fil som app.test.js och lägg till följande:

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

Kontrollera JSON-svar

API:er returnerar ofta JSON-data. Supertest gör det enkelt att komma åt den tolkade JSON-kroppen i ett svar med hjälp av res.body.

Nu testar vi vår /data-endpoint för att säkerställa att den returnerar rätt 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');
  });
});

Testa POST-förfrågningar

Att testa POST-förfrågningar fungerar på liknande sätt, men vi använder .post() och ofta .send() för att bifoga en request body.

Vår /echo-endpoint returnerar helt enkelt den JSON-data den tar emot. Nu testar vi den funktionen:

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

Databasinteraktioner och rensning

När ni testar API:er som interagerar med en databas brukar ni:

Använda en separat testdatabas för att förhindra att utvecklingsdata förorenas.
Rensa databasen före varje testsvit eller testfall (med hookarna beforeEach/afterEach).
Förinläsa testdata om ett test kräver specifika data.

Det säkerställer att testerna är oberoende och kan upprepas.

API-testscenario

Ni testar en Node.js API-endpoint /users som accepterar POST-förfrågningar för att skapa en ny användare. Vilka av följande påståenden är SANNA om integrationstestning av denna endpoint?

Besvara frågan i den interaktiva lektionen

Sammanfattning: Integrationstestning

Bra jobbat! Ni har lärt er grunderna i integrationstestning av Node.js API-endpoints:

Vad det är: Att verifiera att komponenter fungerar tillsammans, särskilt vid API-förfrågningar.
Verktyg: Att använda Supertest med Jest för att simulera HTTP-förfrågningar.
Metod: Att skicka GET-/POST-förfrågningar och kontrollera statuskoder, innehåll i svarskroppen och datatyper.
Bästa praxis: Att överväga separata testdatabaser för isolering.

Det säkerställer att ert API är robust och tillförlitligt!

Gratis att börja

Lär dig JavaScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 22
Lektioner: 92

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Integrationstestning av API-slutpunkter” gratis?

Ja – hela texten till ”Integrationstestning av API-slutpunkter” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bootcamp i backendutveckling med Node.js, kan Ni uppgradera till CoddyKit PRO. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.

Vad lär jag mig i ”Integrationstestning av API-slutpunkter”?

Implementera integrationstester för att verifiera samspelet mellan olika komponenter och säkerställa API:ets funktionalitet. Ni övar på Bootcamp i backendutveckling med Node.js med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med Node.js?

Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med Node.js på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Integrationstestning av API-slutpunkter”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med Node.js-lektionen?

Ja. Varje Bootcamp i backendutveckling med Node.js-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Bootcamp i backendutveckling med Node.js