refactor(test): improve fetch mock and update fixture types

Add support for HTTP methods, status codes, body and headers in the fetch
mock. Track calls and expose getFetchCalls for assertions. Update fixture
interfaces to use string IDs, add ImportResult and ApiError types, and
provide standard error constants. Adjust fixture data to match new types.

tests/helpers/api_mock.ts

@@ -1,47 +1,94 @@
-// Mock de fetch() pour les tests
+// Mock de fetch() pour les tests — supporte méthodes HTTP et status codes
+
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
+
+export interface MockRoute {
+  method?: HttpMethod;
+  status?: number;
+  body?: unknown;
+  headers?: Record<string, string>;
+}
 
 // deno-lint-ignore no-explicit-any
 let _originalFetch: ((input: any, init?: any) => Promise<Response>) | null =
   null;
+let _calls: { url: string; method: string; body?: unknown }[] = [];
 
 /**
- * Remplace globalThis.fetch par un mock qui retourne des réponses
- * pré-configurées selon l'URL.
+ * Remplace globalThis.fetch par un mock configurable.
  *
- * @param routes - Map URL pattern → données de réponse (sera sérialisé en JSON)
+ * Usage simple (GET 200 par défaut) :
+ *   mockFetch({ "/students": studentsData })
+ *
+ * Usage avancé (méthode + status) :
+ *   mockFetch({ "/students": { method: "POST", status: 201, body: newStudent } })
  */
 export function mockFetch(
-  routes: Record<string, unknown>,
+  routes: Record<string, unknown | MockRoute>,
 ): void {
   _originalFetch = globalThis.fetch;
+  _calls = [];
 
-  globalThis.fetch = (
+  globalThis.fetch = async (
     input: string | URL | Request,
-    _init?: RequestInit,
+    init?: RequestInit,
   ): Promise<Response> => {
     const url = typeof input === "string"
       ? input
       : input instanceof URL
       ? input.toString()
       : input.url;
+    const method = (init?.method ?? "GET").toUpperCase();
 
-    for (const [pattern, data] of Object.entries(routes)) {
-      if (url.includes(pattern)) {
-        return Promise.resolve(
-          new Response(JSON.stringify(data), {
-            status: 200,
-            headers: { "Content-Type": "application/json" },
-          }),
-        );
+    // Parse le body si présent
+    let reqBody: unknown = undefined;
+    if (init?.body) {
+      try {
+        reqBody = JSON.parse(init.body as string);
+      } catch {
+        reqBody = init.body;
       }
     }
 
-    return Promise.resolve(
-      new Response(JSON.stringify({ error: "Not Found" }), {
-        status: 404,
-        headers: { "Content-Type": "application/json" },
-      }),
-    );
+    _calls.push({ url, method, body: reqBody });
+
+    for (const [pattern, config] of Object.entries(routes)) {
+      if (!url.includes(pattern)) continue;
+
+      // Config simple : la valeur est directement le body de réponse (GET 200)
+      if (!isRouteConfig(config)) {
+        return new Response(JSON.stringify(config), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      // Config avancée : vérifier la méthode si spécifiée
+      if (config.method && config.method !== method) continue;
+
+      const status = config.status ?? 200;
+
+      // 204 : pas de body
+      if (status === 204) {
+        return new Response(null, { status: 204 });
+      }
+
+      return new Response(
+        config.body !== undefined ? JSON.stringify(config.body) : null,
+        {
+          status,
+          headers: {
+            "Content-Type": "application/json",
+            ...config.headers,
+          },
+        },
+      );
+    }
+
+    return new Response(JSON.stringify({ error: "Not Found" }), {
+      status: 404,
+      headers: { "Content-Type": "application/json" },
+    });
   };
 }
 
@@ -53,4 +100,20 @@ export function restoreFetch(): void {
     globalThis.fetch = _originalFetch;
     _originalFetch = null;
   }
+  _calls = [];
+}
+
+/**
+ * Retourne la liste des appels fetch interceptés.
+ */
+export function getFetchCalls(): { url: string; method: string; body?: unknown }[] {
+  return [..._calls];
+}
+
+function isRouteConfig(value: unknown): value is MockRoute {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const v = value as Record<string, unknown>;
+  return "status" in v || "method" in v || "body" in v;
 }