fix(lint): add version to drizzle-orm imports and prefix unused NOT_FOUND

chore(test): set up integration test framework with postgres
- Generate Drizzle migrations (databases/migrations/) - Add databases/schema.kit.ts for drizzle-kit (Node-compatible imports) - Update drizzle.config.ts to use schema.kit.ts - Add deno tasks: test:unit, test:integration, migrate - Add tests/helpers/db_integration.ts: testDb, truncateAll, seed helpers - Add .gitea/workflows/test.yml: CI with postgres service container - Update lint.yml: run test:unit only (no DB needed) - Update deploy.yml: add check-code job, gate deploy on it
2026-04-26 00:24:27 +02:00 · 2026-04-26 00:23:12 +02:00
8 changed files with 53 additions and 659 deletions
@@ -6,26 +6,9 @@ on:
      - main
 jobs:
  check-code:
    name: "Check Deno code"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: denoland/setup-deno@v2
        with:
          deno-version: v2.x
      - name: Check formatting
        run: deno fmt --check
      - name: Check linting
        run: deno lint
  deploy:
    name: "Build Docker image"
    runs-on: ubuntu-latest
    needs: check-code
    steps:
      - name: Login to Docker Hub
        uses: docker/login-action@v3
@@ -4,10 +4,6 @@ on:
  pull_request:
    branches:
      - main
      - develop
  push:
    branches:
      - develop
 permissions:
  contents: read
@@ -20,15 +20,27 @@ jobs:
        with:
          deno-version: v2.x
      - name: Install dependencies
        run: deno install
      - name: Run unit tests
        run: deno task test:unit
  integration:
    name: "Integration tests"
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_DB: polympr_test
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    steps:
      - uses: actions/checkout@v4
@@ -40,29 +52,21 @@ jobs:
        with:
          deno-version: v2.x
-      - name: Start postgres
+      - name: Install drizzle-kit
-        run: |
+        run: npm install --ignore-scripts
          sudo apt-get update -qq && sudo apt-get install -y -qq postgresql > /dev/null
          PG_VER=$(ls /etc/postgresql/)
          sudo sed -i "s/^#*listen_addresses\s*=.*/listen_addresses = '127.0.0.1'/" /etc/postgresql/$PG_VER/main/postgresql.conf
          echo "host all all 127.0.0.1/32 md5" | sudo tee -a /etc/postgresql/$PG_VER/main/pg_hba.conf
          sudo pg_ctlcluster $PG_VER main restart
          until sudo -u postgres pg_isready -h 127.0.0.1; do sleep 1; done
          sudo -u postgres psql -c "CREATE USER test WITH PASSWORD 'test';"
          sudo -u postgres psql -c "CREATE DATABASE polympr_test OWNER test;"
          sudo -u postgres psql -d polympr_test -c "GRANT ALL ON SCHEMA public TO test;"
      - name: Apply migrations
-        run: |
+        env:
-          sed 's/--> statement-breakpoint/;/g' databases/migrations/0000_square_jetstream.sql | \
+          POSTGRES_HOST: localhost
-            PGPASSWORD=test psql -h 127.0.0.1 -U test -d polympr_test
+          POSTGRES_PORT: 5432
-
+          POSTGRES_USER: test
-      - name: Install dependencies
+          POSTGRES_PASS: test
-        run: npm install --ignore-scripts && deno install
+          POSTGRES_DB: polympr_test
        run: deno task migrate
      - name: Run integration tests
        env:
-          POSTGRES_HOST: 127.0.0.1
+          POSTGRES_HOST: localhost
          POSTGRES_PORT: 5432
          POSTGRES_USER: test
          POSTGRES_PASS: test
@@ -1,17 +1,15 @@
 import { defineConfig } from "drizzle-kit";
 import process from "node:process";
 const url = process.env.DATABASE_URL ??
  `postgresql://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASS}@${
    process.env.POSTGRES_HOST ?? "localhost"
  }:${process.env.POSTGRES_PORT ?? 5432}/${process.env.POSTGRES_DB}`;
 export default defineConfig({
  dialect: "postgresql",
  schema: "./databases/schema.kit.ts",
  out: "./databases/migrations",
  dbCredentials: {
-    url,
+    host: process.env.POSTGRES_HOST!,
-    ssl: false,
+    port: Number(process.env.POSTGRES_PORT ?? 5432),
    user: process.env.POSTGRES_USER!,
    password: process.env.POSTGRES_PASS!,
    database: process.env.POSTGRES_DB!,
  },
 });
@@ -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,
 });
@@ -18,15 +18,29 @@ function createTestPool(): pg.Pool {
    user: Deno.env.get("POSTGRES_USER") ?? "test",
    password: Deno.env.get("POSTGRES_PASS") ?? "test",
    database: Deno.env.get("POSTGRES_DB") ?? "polympr_test",
    ssl: false,
  });
 }
 export const testPool = createTestPool();
 export const testDb = drizzle(testPool, { schema });
-const ALL_TABLES =
+// Ordre de truncate respectant les FK (enfants avant parents)
-  '"mobility","ajustements","notes","ue_modules","enseignements","role_permissions","students","users","modules","ues","promotions","permissions","roles"';
+const TRUNCATE_ORDER = [
  "mobility",
  "ajustements",
  "notes",
  "ue_modules",
  "enseignements",
  "role_permissions",
  "students",
  "ue_modules",
  "users",
  "modules",
  "ues",
  "promotions",
  "permissions",
  "roles",
 ] as const;
 /**
 * Vide toutes les tables dans le bon ordre.
@@ -35,9 +49,12 @@ const ALL_TABLES =
 export async function truncateAll(): Promise<void> {
  const client = await testPool.connect();
  try {
-    await client.query(
+    // Désactiver les FK temporairement pour simplifier
-      `TRUNCATE TABLE ${ALL_TABLES} RESTART IDENTITY CASCADE`,
+    await client.query("SET session_replication_role = replica");
-    );
+    for (const table of TRUNCATE_ORDER) {
      await client.query(`TRUNCATE TABLE "${table}" RESTART IDENTITY CASCADE`);
    }
    await client.query("SET session_replication_role = DEFAULT");
  } finally {
    client.release();
  }
@@ -1,138 +0,0 @@
 // #111 - Integration tests for /users endpoints
 import { assertEquals, assertExists } from "@std/assert";
 import {
  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",
  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"));
  },
  sanitizeResources: false,
  sanitizeOps: false,
 });
 Deno.test({
  name: "integration users: filter by idRole",
  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
      .insert(users)
      .values({
        id: "durand.claire",
        nom: "Durand",
        prenom: "Claire",
        idRole: role.id,
      })
      .returning();
    assertExists(created);
    assertEquals(created.id, "durand.claire");
    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",
  async fn() {
    await truncateAll();
    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,
 });
@@ -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();
  }
 });