Jest et Supertest pour les tests d'authentification

Introduction

Les tests d'authentification sont essentiels pour s'assurer du bon fonctionnement des systèmes d'authentification dans une application. Jest et Supertest sont des outils populaires dans l'écosystème JavaScript pour écrire et exécuter des tests unitaires et d'intégration.

Dans ce cours, nous allons apprendre à écrire des tests d'authentification en utilisant Jest pour l'assertion et Supertest pour effectuer des requêtes HTTP sur notre application.

Prérequis

Avant de commencer à écrire des tests, assurez-vous d'avoir les éléments suivants :

• Connaissance de base de JavaScript et des tests unitaires.
• Un projet Node.js avec un système d'authentification implémenté.
• Jest et Supertest installés dans votre projet.

Configuration de l'environnement de test

Avant d'écrire des tests, nous devons configurer notre environnement de test pour qu'il soit prêt à exécuter nos cas de test.

Dans notre fichier de configuration de Jest, nous devons nous assurer que notre application est correctement initialisée et que notre base de données est prête pour les tests. Nous pouvons également utiliser des fonctions beforeEach et afterEach pour exécuter du code avant et après chaque test.

Voici un exemple de configuration de l'environnement de test :

import bcrypt from "bcrypt";
import supertest from "supertest";
import database from "../../src/database";
import User from "../../src/entities/User";
import app from "../../src/app";
import { initAndClearDatabase } from "../utils";

beforeAll(async () => {
  if (!database.isInitialized) {
    await database.initialize();
  }
});

beforeEach(async () => {
  await initAndClearDatabase();
  
  await database.getRepository(User).insert({
    first_name: "first name",
    last_name: "last name",
    password_hash: await bcrypt.hash("$£°a+ù%è`²47G\"(@", 12),
    email: "mail@example.xyz",
    phone_number: "0000000000",
    admin: false,
  });
});

afterEach(async () => { 
  await database.destroy(); 
});

Écriture des tests

Maintenant que notre environnement de test est configuré, nous pouvons commencer à écrire nos tests d'authentification. Nous allons tester plusieurs scénarios, tels que l'authentification réussie, l'authentification avec un mauvais email et l'authentification avec un mauvais mot de passe.

Voici un exemple de tests d'authentification :

describe("Authentication", () => {
  test("Authentication success", async () => {
    const response = await supertest(app)
      .post("/authenticate")
      .send({
        email: "mail@example.xyz",
        password: "$£°a+ù%è`²47G\"(@"
      });

    expect(response.status).toBe(200);
    // Assurez-vous de vérifier les détails de la réponse selon votre implémentation
  });

  test("Authentication with bad email", async () => {
    const response = await supertest(app)
      .post("/authenticate")
      .send({
        email: "wrong_email@example.xyz",
        password: "$£°a+ù%è`²47G\"(@"
      });

    expect(response.status).toBe(401);
    expect(response.text).toBe("Unauthorized");
    // Assurez-vous de vérifier les détails de la réponse selon votre implémentation
  });

  test("Authentication with bad password", async () => {
    const response = await supertest(app)
      .post("/authenticate")
      .send({
        email: "mail@example.xyz",
        password: "$£°a+ù%èbad_password`²47G\"(@"
      });

    expect(response.status).toBe(401);
    expect(response.text).toBe("Unauthorized");
    // Assurez-vous de vérifier les détails de la réponse selon votre implémentation
  });
});

Conclusion

Les tests d'authentification sont cruciaux pour garantir la sécurité et la fiabilité de votre application. En utilisant Jest et Supertest, vous pouvez écrire des tests robustes qui vérifient le comportement de votre système d'authentification dans divers scénarios.

N'oubliez pas d'adapter ces exemples à votre propre implémentation d'authentification et de continuer à écrire des tests pour couvrir tous les cas d'utilisation de votre application.