// fichier : calculatrice.js
function additionner(a, b) {
    return a + b;
}
function diviser(a, b) {
    if (b === 0) throw new Error("Division par zero");
    return a / b;
}
module.exports = { additionner, diviser };

// fichier : api.js
async function obtenirUtilisateur(id, client) {
    const reponse = await client.get(`/utilisateurs/${id}`);
    return reponse.data;
}
module.exports = { obtenirUtilisateur };

// fichier : calculatrice.test.js
const { additionner, diviser } = require("./calculatrice");

// describe : regroupe des tests lies
describe("Calculatrice", () => {
    // test / it : un cas de test individuel
    test("additionne deux nombres positifs", () => {
        expect(additionner(2, 3)).toBe(5);
    });

    it("gere les nombres negatifs", () => {
        expect(additionner(-1, -1)).toBe(-2);
    });

    test("leve une erreur sur division par zero", () => {
        expect(() => diviser(10, 0)).toThrow("Division par zero");
        expect(() => diviser(10, 0)).toThrow(Error);
    });

    // beforeEach / afterEach : setup/teardown autour de CHAQUE test
    let calculatriceAvecEtat;
    beforeEach(() => {
        calculatriceAvecEtat = { historique: [] };
    });
    afterEach(() => {
        calculatriceAvecEtat = null;
    });

    // beforeAll / afterAll : setup/teardown UNE SEULE FOIS pour tout le describe
    beforeAll(() => console.log("Debut de la suite Calculatrice"));
    afterAll(() => console.log("Fin de la suite Calculatrice"));

    // test.each : parametrer plusieurs cas sans dupliquer le code
    test.each([
        [2, 3, 5],
        [-1, 1, 0],
        [0, 0, 0],
        [100, -50, 50],
    ])("additionner(%i, %i) doit valoir %i", (a, b, attendu) => {
        expect(additionner(a, b)).toBe(attendu);
    });
});

// --- Matchers courants ---
test("panorama des matchers", () => {
    expect(2 + 2).toBe(4);                          // egalite stricte (===)
    expect({ a: 1 }).toEqual({ a: 1 });                // egalite profonde de structure
    expect([1, 2, 3]).toContain(2);
    expect(0.1 + 0.2).toBeCloseTo(0.3);                  // pour les flottants
    expect(null).toBeNull();
    expect(undefined).toBeUndefined();
    expect("texte").toMatch(/ex/);
    expect(() => { throw new Error("x"); }).toThrow();
    expect([1, 2, 3]).toHaveLength(3);
});

// --- Mocks : isoler le code teste ---
test("mock d'une fonction simple", () => {
    const mockFn = jest.fn((x) => x * 2);
    expect(mockFn(5)).toBe(10);
    expect(mockFn).toHaveBeenCalledWith(5);
    expect(mockFn).toHaveBeenCalledTimes(1);
});

test("mock avec valeur de retour controlee", () => {
    const mockClient = { get: jest.fn() };
    mockClient.get.mockResolvedValue({ data: { id: 1, nom: "Alice" } });

    const { obtenirUtilisateur } = require("./api");
    return obtenirUtilisateur(1, mockClient).then((utilisateur) => {
        expect(utilisateur.nom).toBe("Alice");
        expect(mockClient.get).toHaveBeenCalledWith("/utilisateurs/1");
    });
});

// --- Mocker un module entier ---
jest.mock("./api");

// --- Tests asynchrones ---
test("test async avec async/await", async () => {
    const client = { get: jest.fn().mockResolvedValue({ data: { id: 2 } }) };
    const { obtenirUtilisateur } = require("./api");
    const resultat = await obtenirUtilisateur(2, client);
    expect(resultat.id).toBe(2);
});

// --- Spies : observer sans remplacer completement le comportement ---
test("spy sur console.error", () => {
    const spy = jest.spyOn(console, "error").mockImplementation(() => {});
    console.error("test");
    expect(spy).toHaveBeenCalledWith("test");
    spy.mockRestore();          // restaure le comportement original apres le test
});

// --- Snapshot testing : detecter des changements inattendus dans une structure ---
test("snapshot de configuration", () => {
    const config = { theme: "sombre", langue: "fr" };
    expect(config).toMatchSnapshot();
});

npx jest                          # lance tous les tests
npx jest calculatrice              # filtre par nom de fichier
npx jest --coverage                 # rapport de couverture de code
npx jest --watch                     # relance automatiquement au changement de fichier