Tester Express avec Jest

Pourquoi Tester Express avec Jest ?

Dans le monde du développement web, tester vos applications est une pratique incontournable. Les technologies comme Express permettent de créer des serveurs robustes et performants, mais ils nécessitent également un niveau élevé de test pour garantir leur fiabilité et leur sécurité. Jest est l'un des frameworks de tests les plus populaires en JavaScript et offre des fonctionnalités puissantes qui facilitent le processus de testing.

Contexte réel : Pourquoi un dev a besoin de ca au quotidien

Imaginez que vous travaillez sur une application e-commerce, où chaque erreur peut entraîner des pertes financières importantes. En utilisant Jest pour tester votre application Express, vous pouvez identifier rapidement les bugs potentiels et les corriger avant qu'ils ne puissent affecter vos utilisateurs. De plus, les tests automatisés peuvent être exécutés régulièrement, ce qui permet de maintenir la qualité du code en temps réel.

Un cas d'usage concret en 2-3 phrases

Un cas concret de test pour une application Express pourrait être le vérification des points de terminaison (endpoints) de l'API. Par exemple, vous pouvez tester si un endpoint pour récupérer tous les articles fonctionne correctement ou s'il renvoie les données attendues.

Prérequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Node.js v14.x ou ultérieur
• npm v6.x ou ultérieur
• Visual Studio Code ou tout autre éditeur de code

Installez ces outils en utilisant les commandes suivantes :

## Installer Node.js et npm via le gestionnaire de paquets de votre système d'exploitation
## Par exemple, sur Ubuntu :
sudo apt update
sudo apt install nodejs npm

## Vérifier la version installée
node -v
npm -v

Concepts fondamentaux

1. Qu'est-ce que Jest ?

Jest est un framework de tests JavaScript créé par Facebook. Il offre des fonctionnalités telles que le mockage, l'espionnage (spying), et la génération automatique de tests (autotesting). Jest peut être utilisé avec n'importe quel environnement JavaScript, y compris Node.js.

2. Comment structure les tests avec Jest ?

Les tests sont organisés en fichiers .test.js ou .spec.js. Chaque fichier contient une suite de tests regroupés sous le nom d'une fonction describe(). Les individuels tests sont définis dans des fonctions it() ou test().

// Exemple de structure de test avec Jest

describe('Addition Function', () => {
  it('should return the sum of two numbers', () => {
    const result = add(2, 3);
    expect(result).toBe(5);
  });
});

3. Les fonctions Expect

Expect est une fonction fournie par Jest qui permet de définir les assertions sur les valeurs retournées par vos fonctions.

// Exemple d'utilisation d'Expect avec Jest

test('add function should return the sum of two numbers', () => {
  const result = add(2, 3);
  expect(result).toBe(5); // Vérifie si le résultat est égal à 5
});

4. Mocking et Espionnage (Spying)

Mocking permet de remplacer une fonction existante par une version simulée qui peut être utilisée pour tester d'autres fonctions sans dépendre des fonctionnalités réelles.

// Exemple de mocking avec Jest

const myModule = {
  getData: jest.fn()
};

myModule.getData();

test('getData should be called', () => {
  expect(myModule.getData).toHaveBeenCalled();
});

Mise en pratique : Projet fil rouge

Pour ce tutoriel, nous allons créer un gestionnaire de tâches basé sur Express. Ce projet comprendra des points de terminaison pour ajouter et récupérer des tâches.

Étape 1 : Initialiser le projet

Créez un nouveau dossier pour votre projet et initialisez-le avec npm :

mkdir task-manager
cd task-manager
npm init -y

Étape 2 : Installer les dépendances

Installez Express et Jest :

npm install express jest --save-dev

Étape 3 : Créer le serveur Express

Créez un fichier app.js et ajoutez le code suivant :

// app.js
const express = require('express');
const app = express();
const port = 3000;

let tasks = [];

app.use(express.json());

app.get('/tasks', (req, res) => {
  res.send(tasks);
});

app.post('/tasks', (req, res) => {
  const task = req.body;
  tasks.push(task);
  res.status(201).send(task);
});

app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}/`);
});

Étape 4 : Créer les tests

Créez un fichier app.test.js pour vos tests :

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

describe('Task Manager API', () => {
  let server;

  beforeAll(async () => {
    // Démarrer le serveur avant les tests
    server = await app.listen(3000);
  });

  afterAll(async () => {
    // Arrêter le serveur après les tests
    await server.close();
  });

  it('should return all tasks', async () => {
    const response = await request(app).get('/tasks');
    expect(response.status).toBe(200);
    expect(response.body).toEqual([]);
  });

  it('should add a new task', async () => {
    const response = await request(app)
      .post('/tasks')
      .send({ title: 'Buy groceries' });
    expect(response.status).toBe(201);
    expect(response.body.title).toBe('Buy groceries');
  });
});

Étape 5 : Exécuter les tests

Exécutez vos tests avec la commande suivante :

npx jest

Erreurs fréquentes et debugging

1. Erreur : ReferenceError: request is not defined

Code incorrect :

it('should return all tasks', async () => {
  const response = await request(app).get('/tasks');
  expect(response.status).toBe(200);
});

Code correct :

const request = require('supertest');

it('should return all tasks', async () => {
  const response = await request(app).get('/tasks');
  expect(response.status).toBe(200);
});

2. Erreur : TypeError: Cannot read property 'length' of undefined

Code incorrect :

test('should add a new task', async () => {
  const response = await request(app)
    .post('/tasks')
    .send({ title: 'Buy groceries' });
  expect(response.body.length).toBe(1);
});

Code correct :

test('should add a new task', async () => {
  const response = await request(app)
    .post('/tasks')
    .send({ title: 'Buy groceries' });
  expect(response.body.title).toBe('Buy groceries');
});

3. Erreur : SyntaxError: Unexpected token import

Code incorrect :

import express from 'express';
const app = express();

Code correct :

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

Pour aller plus loin

1. Mocking des fonctions asynchrones

   • Utilisez jest.fn().mockResolvedValue() pour tester les fonctions qui retournent une promesse.

2. Test d'intégration

   • Créez des tests d'intégration pour vérifier l'interaction entre différents composants de votre application.

3. Coverage et rapport de couverture

   • Utilisez --coverage avec Jest pour générer un rapport de couverture du code, ce qui vous aide à identifier les parties non testées de votre application.

Défi pratique :

1. Ajoutez des tests pour un point de terminaison de mise à jour d'une tâche dans le gestionnaire de tâches.
2. Créez un nouveau endpoint pour supprimer une tâche et ajoutez les tests correspondants.
3. Utilisez mocking pour tester une fonction qui appelle une API externe.

En suivant ce tutoriel, vous devriez être capable de créer des projets Express robustes et testés efficacement avec Jest. N'hésitez pas à explorer les ressources en ligne pour approfondir vos compétences en testing !