fix: remove unused assertExists import

- unit: fixture shapes, mock API (GET/POST/PUT/DELETE + 409), mock DB CRUD
- integration: list, create, get, duplicate rejection, update, delete
- e2e: handler calls with mock context + real DB, covers 400/403/404/409

tests/e2e/modules_test.ts

@@ -0,0 +1,210 @@
+// #113 - E2E tests for /modules endpoints
+
+import { assertEquals } from "@std/assert";
+import {
+  makeContextWithAffiliation,
+  makeEmployeeContext,
+  makeGetRequest,
+  makeJsonRequest,
+} from "../helpers/handler.ts";
+import { seedModules, truncateAll } from "../helpers/db_integration.ts";
+import { handler as modulesHandler } from "$apps/admin/api/modules.ts";
+import { handler as moduleHandler } from "$apps/admin/api/modules/[idModule].ts";
+
+// --- GET /modules ---
+
+Deno.test({
+  name: "e2e modules: GET /modules returns all as employee",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "MATH101", nom: "Mathématiques" }, {
+      id: "INFO101",
+      nom: "Informatique",
+    }]);
+    const res = await modulesHandler.GET!(
+      makeGetRequest("/modules"),
+      makeEmployeeContext(),
+    );
+    assertEquals(res.status, 200);
+    const body = await res.json();
+    assertEquals(body.length, 2);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "e2e modules: GET /modules returns empty for non-employee",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "MATH101", nom: "Mathématiques" }]);
+    const res = await modulesHandler.GET!(
+      makeGetRequest("/modules"),
+      makeContextWithAffiliation("student"),
+    );
+    assertEquals(res.status, 200);
+    const body = await res.json();
+    assertEquals(body.length, 0);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+// --- POST /modules ---
+
+Deno.test({
+  name: "e2e modules: POST /modules creates module (201)",
+  async fn() {
+    await truncateAll();
+    const res = await modulesHandler.POST!(
+      makeJsonRequest("/modules", "POST", { id: "PHYS101", nom: "Physique" }),
+      makeEmployeeContext(),
+    );
+    assertEquals(res.status, 201);
+    const body = await res.json();
+    assertEquals(body.id, "PHYS101");
+    assertEquals(body.nom, "Physique");
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "e2e modules: POST /modules 409 on duplicate id",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "MATH101", nom: "Mathématiques" }]);
+    const res = await modulesHandler.POST!(
+      makeJsonRequest("/modules", "POST", { id: "MATH101", nom: "Doublon" }),
+      makeEmployeeContext(),
+    );
+    assertEquals(res.status, 409);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "e2e modules: POST /modules 400 on missing fields",
+  async fn() {
+    await truncateAll();
+    const res = await modulesHandler.POST!(
+      makeJsonRequest("/modules", "POST", { id: "X" }),
+      makeEmployeeContext(),
+    );
+    assertEquals(res.status, 400);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "e2e modules: POST /modules 403 for non-employee",
+  async fn() {
+    await truncateAll();
+    const res = await modulesHandler.POST!(
+      makeJsonRequest("/modules", "POST", { id: "X", nom: "Y" }),
+      makeContextWithAffiliation("student"),
+    );
+    assertEquals(res.status, 403);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+// --- GET /modules/:id ---
+
+Deno.test({
+  name: "e2e modules: GET /modules/:id returns module",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "ELEC201", nom: "Électronique" }]);
+    const res = await moduleHandler.GET!(
+      makeGetRequest("/modules/ELEC201"),
+      makeEmployeeContext({ idModule: "ELEC201" }),
+    );
+    assertEquals(res.status, 200);
+    const body = await res.json();
+    assertEquals(body.nom, "Électronique");
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "e2e modules: GET /modules/:id 404 when not found",
+  async fn() {
+    await truncateAll();
+    const res = await moduleHandler.GET!(
+      makeGetRequest("/modules/GHOST"),
+      makeEmployeeContext({ idModule: "GHOST" }),
+    );
+    assertEquals(res.status, 404);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+// --- PUT /modules/:id ---
+
+Deno.test({
+  name: "e2e modules: PUT /modules/:id updates nom",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "CHIM101", nom: "Chimie" }]);
+    const res = await moduleHandler.PUT!(
+      makeJsonRequest("/modules/CHIM101", "PUT", { nom: "Chimie organique" }),
+      makeEmployeeContext({ idModule: "CHIM101" }),
+    );
+    assertEquals(res.status, 200);
+    const body = await res.json();
+    assertEquals(body.nom, "Chimie organique");
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "e2e modules: PUT /modules/:id 404 when not found",
+  async fn() {
+    await truncateAll();
+    const res = await moduleHandler.PUT!(
+      makeJsonRequest("/modules/GHOST", "PUT", { nom: "X" }),
+      makeEmployeeContext({ idModule: "GHOST" }),
+    );
+    assertEquals(res.status, 404);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+// --- DELETE /modules/:id ---
+
+Deno.test({
+  name: "e2e modules: DELETE /modules/:id returns 204",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "BIO101", nom: "Biologie" }]);
+    const res = await moduleHandler.DELETE!(
+      makeGetRequest("/modules/BIO101"),
+      makeEmployeeContext({ idModule: "BIO101" }),
+    );
+    assertEquals(res.status, 204);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "e2e modules: DELETE /modules/:id 404 when not found",
+  async fn() {
+    await truncateAll();
+    const res = await moduleHandler.DELETE!(
+      makeGetRequest("/modules/GHOST"),
+      makeEmployeeContext({ idModule: "GHOST" }),
+    );
+    assertEquals(res.status, 404);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});

tests/e2e/users_test.ts

@@ -1,250 +0,0 @@
-// #111 - E2E tests for /users endpoints
-
-import { assertEquals, assertExists } from "@std/assert";
-import {
-  makeEmployeeContext,
-  makeGetRequest,
-  makeJsonRequest,
-} from "../helpers/handler.ts";
-import {
-  seedRoles,
-  seedUsers,
-  truncateAll,
-} from "../helpers/db_integration.ts";
-import { handler as usersHandler } from "$apps/admin/api/users.ts";
-import { handler as userHandler } from "$apps/admin/api/users/[id].ts";
-
-// --- GET /users ---
-
-Deno.test({
-  name: "e2e users: GET /users returns all users",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([
-      { id: "dupont.jean", nom: "Dupont", prenom: "Jean", idRole: role.id },
-      { id: "martin.alice", nom: "Martin", prenom: "Alice", idRole: role.id },
-    ]);
-    const res = await usersHandler.GET!(
-      makeGetRequest("/users"),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 200);
-    const body = await res.json();
-    assertEquals(body.length, 2);
-    assertExists(body.find((u: { id: string }) => u.id === "dupont.jean"));
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: GET /users?idRole filters by role",
-  async fn() {
-    await truncateAll();
-    const [role1] = await seedRoles([{ nom: "admin" }]);
-    const [role2] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([
-      { id: "u1", nom: "A", prenom: "A", idRole: role1.id },
-      { id: "u2", nom: "B", prenom: "B", idRole: role2.id },
-    ]);
-    const res = await usersHandler.GET!(
-      makeGetRequest("/users", { idRole: String(role1.id) }),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 200);
-    const body = await res.json();
-    assertEquals(body.length, 1);
-    assertEquals(body[0].id, "u1");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-// --- POST /users ---
-
-Deno.test({
-  name: "e2e users: POST /users creates user (201)",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    const res = await usersHandler.POST!(
-      makeJsonRequest("/users", "POST", {
-        id: "nouveau.user",
-        nom: "Nouveau",
-        prenom: "User",
-        idRole: role.id,
-      }),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 201);
-    const body = await res.json();
-    assertEquals(body.id, "nouveau.user");
-    assertExists(body.nom);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: POST /users 409 on duplicate id",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "dup.user",
-      nom: "A",
-      prenom: "A",
-      idRole: role.id,
-    }]);
-    const res = await usersHandler.POST!(
-      makeJsonRequest("/users", "POST", {
-        id: "dup.user",
-        nom: "B",
-        prenom: "B",
-        idRole: role.id,
-      }),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 409);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: POST /users 400 on missing fields",
-  async fn() {
-    await truncateAll();
-    const res = await usersHandler.POST!(
-      makeJsonRequest("/users", "POST", { id: "x" }),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 400);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-// --- GET /users/:id ---
-
-Deno.test({
-  name: "e2e users: GET /users/:id returns user",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "test.user",
-      nom: "Test",
-      prenom: "User",
-      idRole: role.id,
-    }]);
-    const res = await userHandler.GET!(
-      makeGetRequest("/users/test.user"),
-      makeEmployeeContext({ id: "test.user" }),
-    );
-    assertEquals(res.status, 200);
-    const body = await res.json();
-    assertEquals(body.id, "test.user");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: GET /users/:id 404 when not found",
-  async fn() {
-    await truncateAll();
-    const res = await userHandler.GET!(
-      makeGetRequest("/users/ghost"),
-      makeEmployeeContext({ id: "ghost" }),
-    );
-    assertEquals(res.status, 404);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-// --- PUT /users/:id ---
-
-Deno.test({
-  name: "e2e users: PUT /users/:id updates user",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "upd.user",
-      nom: "Old",
-      prenom: "Name",
-      idRole: role.id,
-    }]);
-    const res = await userHandler.PUT!(
-      makeJsonRequest("/users/upd.user", "PUT", {
-        nom: "New",
-        prenom: "Name",
-        idRole: role.id,
-      }),
-      makeEmployeeContext({ id: "upd.user" }),
-    );
-    assertEquals(res.status, 200);
-    const body = await res.json();
-    assertEquals(body.nom, "New");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: PUT /users/:id 404 when not found",
-  async fn() {
-    await truncateAll();
-    const res = await userHandler.PUT!(
-      makeJsonRequest("/users/ghost", "PUT", {
-        nom: "X",
-        prenom: "Y",
-        idRole: 1,
-      }),
-      makeEmployeeContext({ id: "ghost" }),
-    );
-    assertEquals(res.status, 404);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-// --- DELETE /users/:id ---
-
-Deno.test({
-  name: "e2e users: DELETE /users/:id returns 204",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "del.user",
-      nom: "Del",
-      prenom: "Me",
-      idRole: role.id,
-    }]);
-    const res = await userHandler.DELETE!(
-      makeGetRequest("/users/del.user"),
-      makeEmployeeContext({ id: "del.user" }),
-    );
-    assertEquals(res.status, 204);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: DELETE /users/:id 404 when not found",
-  async fn() {
-    await truncateAll();
-    const res = await userHandler.DELETE!(
-      makeGetRequest("/users/ghost"),
-      makeEmployeeContext({ id: "ghost" }),
-    );
-    assertEquals(res.status, 404);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});

tests/integration/modules_test.ts

@@ -0,0 +1,104 @@
+// #113 - Integration tests for /modules endpoints
+
+import { assertEquals, assertExists, assertRejects } from "@std/assert";
+import { seedModules, testDb, truncateAll } from "../helpers/db_integration.ts";
+import { modules } from "$root/databases/schema.ts";
+import { eq } from "npm:drizzle-orm@0.45.2";
+
+Deno.test({
+  name: "integration modules: list all modules",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "MATH101", nom: "Mathématiques" }, {
+      id: "INFO101",
+      nom: "Informatique",
+    }]);
+    const rows = await testDb.select().from(modules);
+    assertEquals(rows.length, 2);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "integration modules: create and retrieve by id",
+  async fn() {
+    await truncateAll();
+    const [created] = await testDb.insert(modules).values({
+      id: "PHYS101",
+      nom: "Physique",
+    }).returning();
+    assertExists(created);
+    assertEquals(created.id, "PHYS101");
+
+    const row = await testDb
+      .select()
+      .from(modules)
+      .where(eq(modules.id, "PHYS101"))
+      .then((r) => r[0] ?? null);
+    assertExists(row);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "integration modules: get by id returns null when not found",
+  async fn() {
+    await truncateAll();
+    const row = await testDb
+      .select()
+      .from(modules)
+      .where(eq(modules.id, "NONEXISTENT"))
+      .then((r) => r[0] ?? null);
+    assertEquals(row, null);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "integration modules: duplicate id insert fails",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "MATH101", nom: "Mathématiques" }]);
+    await assertRejects(() =>
+      testDb.insert(modules).values({ id: "MATH101", nom: "Doublon" })
+    );
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "integration modules: update nom",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "ELEC201", nom: "Électronique" }]);
+    const [updated] = await testDb
+      .update(modules)
+      .set({ nom: "Électronique numérique" })
+      .where(eq(modules.id, "ELEC201"))
+      .returning();
+    assertEquals(updated.nom, "Électronique numérique");
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});
+
+Deno.test({
+  name: "integration modules: delete removes the module",
+  async fn() {
+    await truncateAll();
+    await seedModules([{ id: "BIO101", nom: "Biologie" }]);
+    await testDb.delete(modules).where(eq(modules.id, "BIO101"));
+    const row = await testDb
+      .select()
+      .from(modules)
+      .where(eq(modules.id, "BIO101"))
+      .then((r) => r[0] ?? null);
+    assertEquals(row, null);
+  },
+  sanitizeResources: false,
+  sanitizeOps: false,
+});

tests/integration/users_test.ts

@@ -1,24 +1,24 @@
-// #111 - Integration tests for /users endpoints
-
 import { assertEquals, assertExists } from "@std/assert";
 import {
+  closeTestPool,
   seedRoles,
   seedUsers,
   testDb,
   truncateAll,
 } from "../helpers/db_integration.ts";
 import { users } from "$root/databases/schema.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
 
 Deno.test({
-  name: "integration users: list all users",
+  name: "integration: GET /users - DB round trip",
   async fn() {
     await truncateAll();
+
     const [role] = await seedRoles([{ nom: "employee" }]);
     await seedUsers([
       { id: "dupont.jean", nom: "Dupont", prenom: "Jean", idRole: role.id },
       { id: "martin.alice", nom: "Martin", prenom: "Alice", idRole: role.id },
     ]);
+
     const rows = await testDb.select().from(users);
     assertEquals(rows.length, 2);
     assertExists(rows.find((u) => u.id === "dupont.jean"));
@@ -28,110 +28,30 @@ Deno.test({
 });
 
 Deno.test({
-  name: "integration users: filter by idRole",
+  name: "integration: INSERT user and retrieve by id",
   async fn() {
     await truncateAll();
-    const [role1] = await seedRoles([{ nom: "admin" }]);
-    const [role2] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([
-      { id: "u1", nom: "A", prenom: "A", idRole: role1.id },
-      { id: "u2", nom: "B", prenom: "B", idRole: role2.id },
-    ]);
-    const rows = await testDb
-      .select()
-      .from(users)
-      .where(eq(users.idRole, role1.id));
-    assertEquals(rows.length, 1);
-    assertEquals(rows[0].id, "u1");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
 
-Deno.test({
-  name: "integration users: create and retrieve by id",
-  async fn() {
-    await truncateAll();
     const [role] = await seedRoles([{ nom: "admin" }]);
-    const [created] = await testDb
+    const [created] = await testDb.insert(users).values({
-      .insert(users)
+      id: "durand.claire",
-      .values({
+      nom: "Durand",
-        id: "durand.claire",
+      prenom: "Claire",
-        nom: "Durand",
+      idRole: role.id,
-        prenom: "Claire",
+    }).returning();
-        idRole: role.id,
+
-      })
-      .returning();
     assertExists(created);
     assertEquals(created.id, "durand.claire");
-
+    assertEquals(created.nom, "Durand");
-    const row = await testDb
-      .select()
-      .from(users)
-      .where(eq(users.id, "durand.claire"))
-      .then((r) => r[0] ?? null);
-    assertExists(row);
   },
   sanitizeResources: false,
   sanitizeOps: false,
 });
 
 Deno.test({
-  name: "integration users: get by id returns null when not found",
+  name: "integration: cleanup - close pool",
   async fn() {
-    await truncateAll();
+    await closeTestPool();
-    const row = await testDb
-      .select()
-      .from(users)
-      .where(eq(users.id, "nonexistent"))
-      .then((r) => r[0] ?? null);
-    assertEquals(row, null);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "integration users: update user fields",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "test.user",
-      nom: "Test",
-      prenom: "User",
-      idRole: role.id,
-    }]);
-    const [updated] = await testDb
-      .update(users)
-      .set({ nom: "Updated", prenom: "Name" })
-      .where(eq(users.id, "test.user"))
-      .returning();
-    assertExists(updated);
-    assertEquals(updated.nom, "Updated");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "integration users: delete user",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "to.delete",
-      nom: "Del",
-      prenom: "Me",
-      idRole: role.id,
-    }]);
-    await testDb.delete(users).where(eq(users.id, "to.delete"));
-    const row = await testDb
-      .select()
-      .from(users)
-      .where(eq(users.id, "to.delete"))
-      .then((r) => r[0] ?? null);
-    assertEquals(row, null);
   },
   sanitizeResources: false,
   sanitizeOps: false,

tests/unit/modules_test.ts

@@ -0,0 +1,171 @@
+// #113 - Unit tests for /modules endpoints
+
+import { assertEquals, assertExists } from "@std/assert";
+import { mockFetch, restoreFetch } from "../helpers/api_mock.ts";
+import { createMockDb } from "../helpers/db_mock.ts";
+import { type Module, modules } from "../helpers/fixtures.ts";
+
+// --- Fixtures ---
+
+Deno.test("modules: fixtures have correct shape", () => {
+  assertEquals(modules.length, 3);
+  assertEquals(typeof modules[0].id, "string");
+  assertEquals(typeof modules[0].nom, "string");
+});
+
+// --- Mock API ---
+
+Deno.test("mock API: GET /modules returns list", async () => {
+  mockFetch({ "/modules": modules });
+  try {
+    const res = await fetch("http://localhost/api/modules");
+    assertEquals(res.status, 200);
+    const data: Module[] = await res.json();
+    assertEquals(data.length, 3);
+    assertExists(data.find((m) => m.id === "JIN702C"));
+  } finally {
+    restoreFetch();
+  }
+});
+
+Deno.test("mock API: GET /modules/:id returns one module", async () => {
+  mockFetch({ "/modules/JIN702C": modules[0] });
+  try {
+    const res = await fetch("http://localhost/api/modules/JIN702C");
+    assertEquals(res.status, 200);
+    const data: Module = await res.json();
+    assertEquals(data.id, "JIN702C");
+    assertEquals(data.nom, "Optimisation");
+  } finally {
+    restoreFetch();
+  }
+});
+
+Deno.test("mock API: GET /modules/:id 404 when not found", async () => {
+  mockFetch({
+    "/modules/UNKNOWN": {
+      status: 404,
+      body: { error: "Ressource introuvable" },
+    },
+  });
+  try {
+    const res = await fetch("http://localhost/api/modules/UNKNOWN");
+    assertEquals(res.status, 404);
+  } finally {
+    restoreFetch();
+  }
+});
+
+Deno.test("mock API: POST /modules creates module (201)", async () => {
+  const newModule: Module = { id: "NEW101", nom: "Nouveau Module" };
+  mockFetch({ "/modules": { method: "POST", status: 201, body: newModule } });
+  try {
+    const res = await fetch("http://localhost/api/modules", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(newModule),
+    });
+    assertEquals(res.status, 201);
+    const data: Module = await res.json();
+    assertEquals(data.id, "NEW101");
+  } finally {
+    restoreFetch();
+  }
+});
+
+Deno.test("mock API: POST /modules 409 on duplicate id", async () => {
+  mockFetch({
+    "/modules": {
+      method: "POST",
+      status: 409,
+      body: { error: "Un module avec cet identifiant existe déjà" },
+    },
+  });
+  try {
+    const res = await fetch("http://localhost/api/modules", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(modules[0]),
+    });
+    assertEquals(res.status, 409);
+  } finally {
+    restoreFetch();
+  }
+});
+
+Deno.test("mock API: POST /modules 400 on missing fields", async () => {
+  mockFetch({ "/modules": { method: "POST", status: 400 } });
+  try {
+    const res = await fetch("http://localhost/api/modules", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ id: "X" }),
+    });
+    assertEquals(res.status, 400);
+  } finally {
+    restoreFetch();
+  }
+});
+
+Deno.test("mock API: PUT /modules/:id updates nom", async () => {
+  const updated: Module = { id: "JIN702C", nom: "Optimisation avancée" };
+  mockFetch({
+    "/modules/JIN702C": { method: "PUT", status: 200, body: updated },
+  });
+  try {
+    const res = await fetch("http://localhost/api/modules/JIN702C", {
+      method: "PUT",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ nom: "Optimisation avancée" }),
+    });
+    assertEquals(res.status, 200);
+    const data: Module = await res.json();
+    assertEquals(data.nom, "Optimisation avancée");
+  } finally {
+    restoreFetch();
+  }
+});
+
+Deno.test("mock API: DELETE /modules/:id returns 204", async () => {
+  mockFetch({ "/modules/JIN702C": { method: "DELETE", status: 204 } });
+  try {
+    const res = await fetch("http://localhost/api/modules/JIN702C", {
+      method: "DELETE",
+    });
+    assertEquals(res.status, 204);
+  } finally {
+    restoreFetch();
+  }
+});
+
+// --- Mock DB ---
+
+Deno.test("mock DB: find module by id", () => {
+  const db = createMockDb({ tables: { modules: [...modules] } });
+  const m = db.findOne<Module>("modules", (m) => m.id === "JIN702C");
+  assertExists(m);
+  assertEquals(m.nom, "Optimisation");
+});
+
+Deno.test("mock DB: insert module", () => {
+  const db = createMockDb({ tables: { modules: [...modules] } });
+  db.insert<Module>("modules", { id: "NEW101", nom: "Nouveau" });
+  assertEquals(db.getTable("modules").length, 4);
+});
+
+Deno.test("mock DB: update module nom", () => {
+  const db = createMockDb({ tables: { modules: [...modules] } });
+  db.updateWhere<Module>("modules", (m) => m.id === "JIN702C", {
+    nom: "Updated",
+  });
+  assertEquals(
+    db.findOne<Module>("modules", (m) => m.id === "JIN702C")?.nom,
+    "Updated",
+  );
+});
+
+Deno.test("mock DB: delete module", () => {
+  const db = createMockDb({ tables: { modules: [...modules] } });
+  db.deleteWhere<Module>("modules", (m) => m.id === "JIN702C");
+  assertEquals(db.getTable("modules").length, 2);
+});

tests/unit/users_test.ts

@@ -1,216 +0,0 @@
-import { assertEquals } from "@std/assert";
-import { getFetchCalls, mockFetch, restoreFetch } from "../helpers/api_mock.ts";
-
-const BASE = "http://localhost/apps/admin/api/users";
-
-const users = [
-  { id: "dupont.jean", nom: "Dupont", prenom: "Jean", idRole: 1 },
-  { id: "martin.alice", nom: "Martin", prenom: "Alice", idRole: 2 },
-];
-
-// --- GET /users ---
-
-Deno.test("GET /users - returns all users", async () => {
-  mockFetch({ [BASE]: users });
-  try {
-    const res = await fetch(BASE);
-    assertEquals(res.status, 200);
-    const data = await res.json();
-    assertEquals(data.length, 2);
-    assertEquals(data[0].id, "dupont.jean");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("GET /users - filters by idRole", async () => {
-  const filtered = users.filter((u) => u.idRole === 1);
-  mockFetch({ [`${BASE}?idRole=1`]: filtered });
-  try {
-    const res = await fetch(`${BASE}?idRole=1`);
-    assertEquals(res.status, 200);
-    const data = await res.json();
-    assertEquals(data.length, 1);
-    assertEquals(data[0].idRole, 1);
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- POST /users ---
-
-Deno.test("POST /users - creates a user and returns 201", async () => {
-  const newUser = {
-    id: "durand.claire",
-    nom: "Durand",
-    prenom: "Claire",
-    idRole: 1,
-  };
-  mockFetch({ [BASE]: { method: "POST", status: 201, body: newUser } });
-  try {
-    const res = await fetch(BASE, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(newUser),
-    });
-    assertEquals(res.status, 201);
-    const data = await res.json();
-    assertEquals(data.id, "durand.claire");
-    assertEquals(data.nom, "Durand");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("POST /users - returns 409 on duplicate id", async () => {
-  mockFetch({
-    [BASE]: {
-      method: "POST",
-      status: 409,
-      body: { error: "Un utilisateur avec cet identifiant existe déjà" },
-    },
-  });
-  try {
-    const res = await fetch(BASE, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(users[0]),
-    });
-    assertEquals(res.status, 409);
-    const data = await res.json();
-    assertEquals(typeof data.error, "string");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("POST /users - returns 400 on missing fields", async () => {
-  mockFetch({ [BASE]: { method: "POST", status: 400 } });
-  try {
-    const res = await fetch(BASE, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ id: "x" }),
-    });
-    assertEquals(res.status, 400);
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- GET /users/{id} ---
-
-Deno.test("GET /users/{id} - returns a user by id", async () => {
-  mockFetch({ [`${BASE}/dupont.jean`]: users[0] });
-  try {
-    const res = await fetch(`${BASE}/dupont.jean`);
-    assertEquals(res.status, 200);
-    const data = await res.json();
-    assertEquals(data.id, "dupont.jean");
-    assertEquals(data.prenom, "Jean");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("GET /users/{id} - returns 404 for unknown id", async () => {
-  mockFetch({
-    [`${BASE}/inconnu`]: {
-      status: 404,
-      body: { error: "Ressource introuvable" },
-    },
-  });
-  try {
-    const res = await fetch(`${BASE}/inconnu`);
-    assertEquals(res.status, 404);
-    const data = await res.json();
-    assertEquals(typeof data.error, "string");
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- PUT /users/{id} ---
-
-Deno.test("PUT /users/{id} - updates a user", async () => {
-  const updated = { ...users[0], prenom: "Jean-Pierre" };
-  mockFetch({
-    [`${BASE}/dupont.jean`]: { method: "PUT", status: 200, body: updated },
-  });
-  try {
-    const res = await fetch(`${BASE}/dupont.jean`, {
-      method: "PUT",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ nom: "Dupont", prenom: "Jean-Pierre", idRole: 1 }),
-    });
-    assertEquals(res.status, 200);
-    const data = await res.json();
-    assertEquals(data.prenom, "Jean-Pierre");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("PUT /users/{id} - returns 404 for unknown id", async () => {
-  mockFetch({
-    [`${BASE}/inconnu`]: {
-      method: "PUT",
-      status: 404,
-      body: { error: "Ressource introuvable" },
-    },
-  });
-  try {
-    const res = await fetch(`${BASE}/inconnu`, {
-      method: "PUT",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ nom: "X", prenom: "Y", idRole: 1 }),
-    });
-    assertEquals(res.status, 404);
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- DELETE /users/{id} ---
-
-Deno.test("DELETE /users/{id} - deletes a user and returns 204", async () => {
-  mockFetch({
-    [`${BASE}/dupont.jean`]: { method: "DELETE", status: 204 },
-  });
-  try {
-    const res = await fetch(`${BASE}/dupont.jean`, { method: "DELETE" });
-    assertEquals(res.status, 204);
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("DELETE /users/{id} - returns 404 for unknown id", async () => {
-  mockFetch({
-    [`${BASE}/inconnu`]: {
-      method: "DELETE",
-      status: 404,
-      body: { error: "Ressource introuvable" },
-    },
-  });
-  try {
-    const res = await fetch(`${BASE}/inconnu`, { method: "DELETE" });
-    assertEquals(res.status, 404);
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- getFetchCalls ---
-
-Deno.test("GET /users - call is tracked", async () => {
-  mockFetch({ [BASE]: users });
-  try {
-    await fetch(BASE);
-    const calls = getFetchCalls();
-    assertEquals(calls.length, 1);
-    assertEquals(calls[0].method, "GET");
-  } finally {
-    restoreFetch();
-  }
-});