npm install -D vitest supertest

// math.test.js — tests unitaires purs
import { describe, it, expect } from "vitest";
import { add, divide } from "./math.js";

describe("add", () => {
  it("additionne deux nombres positifs", () => {
    expect(add(2, 3)).toBe(5);
  });

  it("gère les nombres négatifs", () => {
    expect(add(-2, 5)).toBe(3);
  });
});

describe("divide", () => {
  it("lève une erreur en cas de division par zéro", () => {
    expect(() => divide(10, 0)).toThrow("Division par zéro");
  });
});

// app.test.js — test d'intégration HTTP avec Supertest (sans vrai serveur écoutant un port)
import { describe, it, expect, beforeEach } from "vitest";
import request from "supertest";
import { createApp } from "../src/app.js";

describe("API /users", () => {
  const app = createApp({ database: createTestDatabase() });

  it("GET /users retourne 200 et un tableau", async () => {
    const response = await request(app).get("/users");

    expect(response.status).toBe(200);
    expect(Array.isArray(response.body)).toBe(true);
  });

  it("POST /users avec payload invalide retourne 400", async () => {
    const response = await request(app).post("/users").send({ name: "" });

    expect(response.status).toBe(400);
    expect(response.body.error).toBeDefined();
  });

  it("POST /users crée un utilisateur et retourne 201", async () => {
    const response = await request(app)
      .post("/users")
      .send({ name: "Alice", email: "alice@example.com" });

    expect(response.status).toBe(201);
    expect(response.body).toMatchObject({ name: "Alice" });
    expect(response.body.id).toBeDefined();
  });
});

function createTestDatabase() {
  return { users: [] };
}

// Mocking d'un service externe — isoler le code testé du réseau réel
import { describe, it, expect, vi, beforeEach } from "vitest";
import { getWeather } from "./weather-service.js";

vi.mock("./http-client.js", () => ({
  httpGet: vi.fn(),
}));

import { httpGet } from "./http-client.js";

describe("getWeather", () => {
  beforeEach(() => vi.clearAllMocks());

  it("retourne les données formatées quand l'API répond", async () => {
    httpGet.mockResolvedValue({ temp_c: 18, condition: "Ensoleillé" });

    const result = await getWeather("Paris");

    expect(result).toEqual({ city: "Paris", temperature: 18, condition: "Ensoleillé" });
    expect(httpGet).toHaveBeenCalledWith(expect.stringContaining("Paris"));
  });

  it("propage une erreur claire si l'API échoue", async () => {
    httpGet.mockRejectedValue(new Error("Timeout"));

    await expect(getWeather("Paris")).rejects.toThrow("Impossible de récupérer la météo");
  });
});

// Base de données de test — isolation via transaction annulée après chaque test
import { beforeEach, afterEach } from "vitest";
import { pool } from "../src/db.js";

let client;

beforeEach(async () => {
  client = await pool.connect();
  await client.query("BEGIN"); // toute mutation du test reste dans cette transaction
});

afterEach(async () => {
  await client.query("ROLLBACK"); // annule TOUTES les écritures du test précédent
  client.release();
});

// vitest.config.js — couverture de code
// export default { test: { coverage: { provider: "v8", thresholds: { lines: 80 } } } }