PolyMPR/tests/database/ue_modules_test.ts

// Integration tests for /ue-modules — Drizzle ORM direct on real DB

import { assertEquals, assertExists, assertRejects } from "@std/assert";
import {
  seedModules,
  seedPromotions,
  seedUeModules,
  seedUes,
  testDb,
  truncateAll,
} from "../helpers/db_integration.ts";
import { ueModules } from "$root/databases/schema.ts";
import { and, eq } from "npm:drizzle-orm@0.45.2";

Deno.test({
  name: "integration ue_modules: list all associations",
  async fn() {
    await truncateAll();
    await seedPromotions([{ id: "P1" }]);
    await seedModules([{ id: "M1", nom: "Mod A" }, { id: "M2", nom: "Mod B" }]);
    const [ue] = await seedUes([{ nom: "UE Info" }]);
    await seedUeModules([
      { idModule: "M1", idUE: ue.id, idPromo: "P1", coeff: 2.0 },
      { idModule: "M2", idUE: ue.id, idPromo: "P1", coeff: 3.0 },
    ]);
    const rows = await testDb.select().from(ueModules);
    assertEquals(rows.length, 2);
  },
  sanitizeResources: false,
  sanitizeOps: false,
});

Deno.test({
  name: "integration ue_modules: create and retrieve by composite key",
  async fn() {
    await truncateAll();
    await seedPromotions([{ id: "P1" }]);
    await seedModules([{ id: "M1", nom: "Mod A" }]);
    const [ue] = await seedUes([{ nom: "UE Maths" }]);

    const [created] = await testDb
      .insert(ueModules)
      .values({ idModule: "M1", idUE: ue.id, idPromo: "P1", coeff: 4.0 })
      .returning();
    assertExists(created);
    assertEquals(created.coeff, 4.0);

    const row = await testDb
      .select()
      .from(ueModules)
      .where(
        and(
          eq(ueModules.idModule, "M1"),
          eq(ueModules.idUE, ue.id),
          eq(ueModules.idPromo, "P1"),
        ),
      )
      .then((r) => r[0] ?? null);
    assertExists(row);
    assertEquals(row.coeff, 4.0);
  },
  sanitizeResources: false,
  sanitizeOps: false,
});

Deno.test({
  name:
    "integration ue_modules: get by composite key returns null when not found",
  async fn() {
    await truncateAll();
    const row = await testDb
      .select()
      .from(ueModules)
      .where(
        and(
          eq(ueModules.idModule, "GHOST"),
          eq(ueModules.idUE, 99),
          eq(ueModules.idPromo, "GHOST"),
        ),
      )
      .then((r) => r[0] ?? null);
    assertEquals(row, null);
  },
  sanitizeResources: false,
  sanitizeOps: false,
});

Deno.test({
  name: "integration ue_modules: duplicate composite key insert fails",
  async fn() {
    await truncateAll();
    await seedPromotions([{ id: "P1" }]);
    await seedModules([{ id: "M1", nom: "Mod A" }]);
    const [ue] = await seedUes([{ nom: "UE Info" }]);
    await seedUeModules([{
      idModule: "M1",
      idUE: ue.id,
      idPromo: "P1",
      coeff: 2.0,
    }]);
    await assertRejects(() =>
      testDb.insert(ueModules).values({
        idModule: "M1",
        idUE: ue.id,
        idPromo: "P1",
        coeff: 5.0,
      })
    );
  },
  sanitizeResources: false,
  sanitizeOps: false,
});

Deno.test({
  name: "integration ue_modules: update coeff",
  async fn() {
    await truncateAll();
    await seedPromotions([{ id: "P1" }]);
    await seedModules([{ id: "M1", nom: "Mod A" }]);
    const [ue] = await seedUes([{ nom: "UE Info" }]);
    await seedUeModules([{
      idModule: "M1",
      idUE: ue.id,
      idPromo: "P1",
      coeff: 2.0,
    }]);

    const [updated] = await testDb
      .update(ueModules)
      .set({ coeff: 6.0 })
      .where(
        and(
          eq(ueModules.idModule, "M1"),
          eq(ueModules.idUE, ue.id),
          eq(ueModules.idPromo, "P1"),
        ),
      )
      .returning();
    assertEquals(updated.coeff, 6.0);
  },
  sanitizeResources: false,
  sanitizeOps: false,
});

Deno.test({
  name: "integration ue_modules: delete removes the association",
  async fn() {
    await truncateAll();
    await seedPromotions([{ id: "P1" }]);
    await seedModules([{ id: "M1", nom: "Mod A" }]);
    const [ue] = await seedUes([{ nom: "UE Info" }]);
    await seedUeModules([{
      idModule: "M1",
      idUE: ue.id,
      idPromo: "P1",
      coeff: 2.0,
    }]);

    await testDb
      .delete(ueModules)
      .where(
        and(
          eq(ueModules.idModule, "M1"),
          eq(ueModules.idUE, ue.id),
          eq(ueModules.idPromo, "P1"),
        ),
      );
    const row = await testDb
      .select()
      .from(ueModules)
      .where(
        and(
          eq(ueModules.idModule, "M1"),
          eq(ueModules.idUE, ue.id),
          eq(ueModules.idPromo, "P1"),
        ),
      )
      .then((r) => r[0] ?? null);
    assertEquals(row, null);
  },
  sanitizeResources: false,
  sanitizeOps: false,
});