Tests d’intégration des points de terminaison d’API
Mettez en œuvre des tests d’intégration pour vérifier les interactions entre les différents composants et garantir le bon fonctionnement de l’API.
Tests d’intégration des points de terminaison d’API est une leçon Node.js Backend Development Bootcamp gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Node.js Backend Development Bootcamp, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Node.js Backend Development Bootcamp comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
What is Integration Testing?
Welcome! In this lesson, we'll dive into integration testing for Node.js API endpoints. Unlike unit tests (which test small, isolated pieces of code), integration tests verify that different parts of your application work together as expected.
For APIs, this means ensuring your endpoints correctly handle requests, interact with databases or other services, and return the right responses.
Why Test API Endpoints?
Your API is the main way external clients interact with your backend. Robust integration tests ensure:
- Endpoints respond with correct HTTP status codes.
- Data sent to the API is processed and stored properly.
- The API returns expected data formats (e.g., JSON).
- Different components (like routing, middleware, database) integrate seamlessly.
This helps catch bugs early that unit tests might miss.
Essential Testing Tools
To test our Node.js API endpoints, we'll use a couple of key tools:
- Jest: Our test runner and assertion library (introduced in Lesson 1).
- Supertest: A library designed to test HTTP servers. It makes it easy to send requests and assert responses.
- Express: Our web framework, for building the API itself.
Setting Up Supertest
First, let's install the necessary packages. We'll need express for our sample API, and jest and supertest for testing.
Run this command in your project terminal:
npm install --save-dev express jest supertestOur Simple Express App
Let's create a basic Express application that we can test. We'll define a few simple routes.
Notice we export the app instance, which Supertest will use to make requests directly, without needing to start a live server on a 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}`);
});
}Testing a GET Endpoint
Now, let's write our first integration test. We'll use supertest to make a GET request to our root / endpoint and assert its response.
Create a file like app.test.js and add the following:
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!');
});
});Asserting JSON Responses
APIs often return JSON data. Supertest makes it easy to access the parsed JSON body of a response using res.body.
Let's test our /data endpoint to ensure it returns the correct JSON object:
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');
});
});Testing POST Requests
Testing POST requests is similar, but we'll use .post() and often .send() to attach a request body.
Our /echo endpoint simply returns whatever JSON it receives. Let's test that functionality:
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 Interactions & Cleanup
When testing APIs that interact with a database, you typically:
- Use a dedicated test database to prevent polluting your development data.
- Clear the database before each test suite or test case (using
beforeEach/afterEachhooks). - Seed data if specific data is needed for a test.
This ensures tests are independent and repeatable.
API Test Scenario
You're testing a Node.js API endpoint /users that accepts POST requests to create a new user. Which of the following statements are TRUE about integration testing this endpoint?
Recap: Integration Testing
Great job! You've learned the fundamentals of integration testing for Node.js API endpoints:
- What it is: Verifying components work together, especially for API requests.
- Tools: Using Supertest with Jest to simulate HTTP requests.
- Method: Sending GET/POST requests and asserting status codes, body content, and data types.
- Best Practices: Considering dedicated test databases for isolation.
This ensures your API is robust and reliable!
Questions Fréquemment Posées
La leçon « Tests d’intégration des points de terminaison d’API » est-elle gratuite ?
Oui — le texte complet de « Tests d’intégration des points de terminaison d’API » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Node.js Backend Development Bootcamp, passe à CoddyKit PRO. Le cours Node.js Backend Development Bootcamp comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Tests d’intégration des points de terminaison d’API » ?
Mettez en œuvre des tests d’intégration pour vérifier les interactions entre les différents composants et garantir le bon fonctionnement de l’API. Tu pratiques Node.js Backend Development Bootcamp avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Node.js Backend Development Bootcamp ?
Aucune expérience préalable n'est requise. Node.js Backend Development Bootcamp sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Tests d’intégration des points de terminaison d’API » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Node.js Backend Development Bootcamp ?
Oui. Chaque leçon Node.js Backend Development Bootcamp inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Tests unitaires avec Jest
- Tests d’intégration des points de terminaison d’API
- Techniques de débogage efficaces
- Simulations et doublures de test dans Node.js