Bootcamp backendontwikkeling met Node.js · Les

Integratietesten van API-eindpunten

Implementeer integratietests om de interactie tussen verschillende componenten te verifiëren en de werking van de API te garanderen.

Les 2 van 411 stappen

Integratietesten van API-eindpunten is een gratis Bootcamp backendontwikkeling met Node.js-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 Bootcamp backendontwikkeling met Node.js. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.

Wat is integration testing?

Welkom! In deze les behandelen we integration testing voor Node.js API-eindpunten. In tegenstelling tot unit tests, die kleine, geïsoleerde stukken code testen, controleren integratietests of verschillende onderdelen van je applicatie samenwerken zoals verwacht.

Voor API's betekent dit dat je controleert of je eindpunten verzoeken correct afhandelen, met databases of andere services communiceren en de juiste antwoorden teruggeven.

Waarom API-eindpunten testen?

Je API is de belangrijkste manier waarop externe clients met je backend communiceren. Robuuste integratietests zorgen ervoor dat:

Eindpunten reageren met de juiste HTTP-statuscodes.
Gegevens die naar de API worden gestuurd correct worden verwerkt en opgeslagen.
De API de verwachte gegevensindelingen teruggeeft, zoals JSON.
Verschillende onderdelen, zoals routering, middleware en de database, naadloos samenwerken.

Zo ontdek je vroegtijdig bugs die unit tests mogelijk missen.

Essentiële testhulpmiddelen

Om onze Node.js API-eindpunten te testen, gebruiken we enkele belangrijke hulpmiddelen:

Jest: Onze testrunner en bibliotheek voor controles (geïntroduceerd in les 1).
Supertest: Een bibliotheek om HTTP-servers te testen. Hiermee kun je eenvoudig verzoeken verzenden en antwoorden controleren.
Express: Ons webframework voor het bouwen van de API zelf.

Supertest instellen

Laten we eerst de benodigde pakketten installeren. We hebben express nodig voor onze voorbeeld-API en jest en supertest om te testen.

Voer deze opdracht uit in de terminal van je project:

npm install --save-dev express jest supertest

Onze eenvoudige Express-app

Laten we een eenvoudige Express-applicatie maken die we kunnen testen. We definiëren enkele eenvoudige routes.

Let op dat we de instantie app exporteren. Supertest gebruikt deze om rechtstreeks verzoeken te doen, zonder dat er een actieve server op een poort hoeft te worden gestart.

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

Een GET-eindpunt testen

Laten we nu onze eerste integratietest schrijven. We gebruiken supertest om een GET-verzoek te doen naar ons hoofdeindpunt / en het antwoord te controleren.

Maak een bestand zoals app.test.js en voeg het volgende toe:

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

JSON-antwoorden controleren

API's geven vaak JSON-gegevens terug. Met Supertest krijg je eenvoudig toegang tot de geparseerde JSON-inhoud van een antwoord via res.body.

Laten we ons /data-eindpunt testen om te controleren of het het juiste JSON-object teruggeeft:

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

POST-verzoeken testen

POST-verzoeken testen werkt vergelijkbaar, maar we gebruiken .post() en vaak .send() om een aanvraaginhoud toe te voegen.

Ons /echo-eindpunt geeft simpelweg alle JSON terug die het ontvangt. Laten we deze functionaliteit testen:

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

Database-interacties en opruimen

Wanneer je API's test die met een database communiceren, doe je meestal het volgende:

Gebruik een afzonderlijke testdatabase om te voorkomen dat je ontwikkelgegevens vervuild raken.
Wis de database vóór elke testsuite of elk testgeval, met hooks zoals beforeEach/afterEach.
Vul testgegevens in als een test specifieke gegevens nodig heeft.

Zo zorg je ervoor dat tests onafhankelijk en herhaalbaar zijn.

API-testscenario

Je test een Node.js API-eindpunt /users dat POST-verzoeken accepteert om een nieuwe gebruiker te maken. Welke van de volgende uitspraken over het integratietesten van dit eindpunt zijn WAAR?

Beantwoord dit in de interactieve les

Samenvatting: integration testing

Goed gedaan! Je hebt de basisprincipes van integration testing voor Node.js API-eindpunten geleerd:

Wat het is: Controleren of onderdelen samenwerken, vooral bij API-verzoeken.
Hulpmiddelen: Supertest met Jest gebruiken om HTTP-verzoeken te simuleren.
Methode: GET-/POST-verzoeken verzenden en statuscodes, inhoud van de antwoordtekst en gegevenstypen controleren.
Best practices: Afzonderlijke testdatabases overwegen voor isolatie.

Zo zorg je ervoor dat je API robuust en betrouwbaar is!

Gratis beginnen

Leer JavaScript 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: 22
Lessen: 92

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Integratietesten van API-eindpunten” gratis?

Ja — de volledige tekst van “Integratietesten van API-eindpunten” 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 Bootcamp backendontwikkeling met Node.js wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Bootcamp backendontwikkeling met Node.js bevat in totaal 4 lessen.

Wat leer ik in “Integratietesten van API-eindpunten”?

Implementeer integratietests om de interactie tussen verschillende componenten te verifiëren en de werking van de API te garanderen. Je oefent met Bootcamp backendontwikkeling met Node.js 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 Bootcamp backendontwikkeling met Node.js te beginnen?

Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met Node.js 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 “Integratietesten van API-eindpunten”?

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 Bootcamp backendontwikkeling met Node.js?

Ja. Elke les over Bootcamp backendontwikkeling met Node.js 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

Unit testing met Jest
Integratietesten van API-eindpunten
Effectieve technieken voor foutopsporing
Mocking en test doubles in Node.js

← Terug naar Bootcamp backendontwikkeling met Node.js