Configurer les rôles et leurs capacités

Critère d'acceptation de WP-01 resté sans écran : « un rôle personnalisé créé
par un client modifie effectivement l'accès, sans changement de code ». Le
catalogue de capacités existait, l'autorisation s'y adossait déjà, mais seul le
semis pouvait attribuer quoi que ce soit.

Deux dangers opposés, et il faut se protéger des deux. L'escalade d'abord : on
ne peut accorder qu'une capacité qu'on détient soi-même, sans quoi la première
personne autorisée à éditer un rôle s'accorde l'accès aux rémunérations en
trois clics et le catalogue ne sert plus à rien. Le retrait, lui, reste permis
même sur une capacité qu'on n'a pas — réduire un droit n'a jamais élargi le
sien, et l'interdire empêcherait de corriger un rôle trop large.

Le verrouillage ensuite : au moins un rôle doit conserver la gestion des
droits. La condition se juge sur l'ensemble des rôles après coup, non sur celui
qu'on édite — ce qui compte n'est pas que ce rôle-ci garde la capacité, mais
qu'un rôle la garde. Sans cela une organisation se fermerait dehors, et le seul
recours serait une intervention en base.

Un rôle naît sans aucune capacité : en hériter de celles de son créateur
distribuerait des droits que personne n'a demandés. Le niveau propriétaire se
délègue à part. Un rôle système ne se supprime pas, un rôle attribué non plus —
ses membres se retrouveraient dehors sans que personne l'ait décidé pour eux.

Le test va jusqu'au bout : créer le rôle, l'attribuer, se connecter, constater
qu'un écran s'ouvre et qu'un autre reste fermé. S'arrêter à « la case est
cochée » n'aurait rien dit du critère.

Trois défauts d'isolation des tests corrigés au passage, tous du même genre —
un état qui s'accumule d'une exécution à l'autre :

- la file des congés désignait « la première ligne de ce salarié » pour son
  nettoyage, et tombait sur une ligne laissée par un passage antérieur ;
- l'écran de conservation tronquait à quarante pièces triées par ancienneté,
  faisant disparaître les pièces échues derrière celles dont il n'y a rien à
  dire — corrigé dans le produit, pas seulement dans le test ;
- le test de verrouillage de période consommait un mois par exécution sans
  jamais le rendre.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Cr9dkEHwbDgkWPnyGj1Rjv

tests/e2e/conges.spec.ts

@@ -31,6 +31,12 @@ function isoDate(offsetDays: number): string {
     .slice(0, 10);
 }
 
+/** Format affiché sur la ligne d'absence. */
+function frenchDate(iso: string): string {
+  const [year, month, day] = iso.split('-');
+  return `${day}/${month}/${year}`;
+}
+
 /** Prochain jour de la semaine demandé (0 = dimanche) dans la fenêtre du run. */
 function nextWeekday(weekday: number): string {
   const cursor = new Date(Date.now() + (RUN_OFFSET + 17) * 86_400_000);
@@ -150,15 +156,19 @@ test('une demande apparaît dans la file, puis se décide', async ({ page }) =>
 
   // Puis on libère les dates : annuler contre-passe la prise sans rien
   // effacer, ce qui est exactement le comportement voulu en production.
+  //
+  // La ligne est visée par **ses** dates, pas par « la première de ce
+  // salarié » : les passages précédents en laissent d'autres dans le même
+  // mois, et certaines n'offrent plus de bouton d'annulation.
   await page.goto(`/conges?mois=${from.slice(0, 7)}`);
   const accepted = page
     .locator('section')
     .filter({ hasText: 'Absences du mois' })
     .locator('li')
-    .filter({ hasText: WHO.queue })
-    .first();
-  if (await accepted.isVisible()) {
-    await accepted.getByRole('button', { name: 'Annuler' }).click();
+    .filter({ hasText: `du ${frenchDate(from)} au ${frenchDate(to)}` });
+
+  if ((await accepted.count()) > 0) {
+    await accepted.first().getByRole('button', { name: 'Annuler' }).click();
   }
 });
 

tests/e2e/conservation.spec.ts

@@ -180,15 +180,14 @@ test('une pièce échue est effectivement effacée', async ({ page }) => {
   await upload.getByRole('button', { name: 'Déposer' }).click();
   await expect(page.getByText(`« ${fileName} » déposé.`)).toBeVisible();
 
-  // Fraîchement déposée, elle n'est pas échue : la purge ne doit pas l'emporter.
-  await page.goto('/reglages/conservation');
-  await expect(
-    page.locator('li').filter({ hasText: fileName }).getByText('Échéance non atteinte'),
-  ).toBeVisible();
+  // Fraîchement déposée, elle n'est pas échue. Constaté sur le dossier, qui ne
+  // liste que les pièces de ce salarié : l'écran de conservation tronque, et la
+  // pièce d'un test neuf n'y figure pas tant qu'elle n'appelle aucune décision.
+  await expect(page.getByText(/conservée jusqu’au/)).toBeVisible();
 
   // Seule l'échéance déclenche l'effacement, et elle se compte en mois.
   await backdateDocument(fileName, 3);
-  await page.reload();
+  await page.goto('/reglages/conservation');
   await expect(
     page.locator('li').filter({ hasText: fileName }).getByText('À purger'),
   ).toBeVisible();

tests/e2e/heures.spec.ts

@@ -86,6 +86,18 @@ test('verrouiller une période ferme le mois aux modifications', async ({
     .fill('Correction demandée par le cabinet');
   await unlock.getByRole('button', { name: 'Déverrouiller' }).click();
   await expect(card.getByText('Ouverte')).toBeVisible();
+
+  // Rendre le mois : une période est unique par bornes, et en consommer une par
+  // exécution finit par épuiser la plage — le test échouerait alors sur une
+  // création refusée, pour une raison sans rapport avec ce qu'il vérifie.
+  const remove = card.locator('form').filter({ hasText: 'Supprimer' });
+  await remove.getByRole('button', { name: 'Supprimer' }).click();
+  await expect(remove.getByText(/saisissez le libellé exact/i)).toBeVisible();
+  await remove.getByPlaceholder(`Saisir « ${label} »`).fill(label);
+  await remove.getByRole('button', { name: 'Supprimer' }).click();
+  await expect(page.locator('section').filter({ hasText: label })).toHaveCount(
+    0,
+  );
 });
 
 test('supprimer une période exige de retaper son libellé', async ({ page }) => {

tests/e2e/roles.spec.ts

@@ -0,0 +1,203 @@
+import { expect, test, type Page } from '@playwright/test';
+
+import { slugifyRoleKey } from '../../src/domain/access/role-editing';
+
+/**
+ * Rôles et permissions — critère d'acceptation de WP-01.
+ *
+ * « Un rôle personnalisé créé par un client modifie effectivement l'accès, sans
+ * changement de code. » Le vérifier suppose d'aller jusqu'au bout : créer le
+ * rôle, l'attribuer, et constater qu'un écran s'ouvre ou se ferme en
+ * conséquence. Un test qui s'arrêterait à « la case est cochée » ne dirait rien.
+ */
+
+const OWNER_PASSWORD = 'planflow-demo-2026';
+
+function roleName(tag: string): string {
+  return `Rôle ${tag} ${Date.now()}`;
+}
+
+/**
+ * Carte d'un rôle, par sa **clé**.
+ *
+ * Ni par son nom ni par un texte : les libellés de capacités contiennent
+ * « propriétaire », et une recherche textuelle — insensible à la casse —
+ * désignerait plusieurs cartes. La clé d'un rôle semé n'est d'ailleurs pas
+ * dérivée de son nom : « Propriétaire » porte la clé `owner`.
+ */
+function roleCard(page: Page, key: string) {
+  return page.getByTestId(`role-${key}`);
+}
+
+test('l’écran énonce les deux garde-fous', async ({ page }) => {
+  await page.goto('/reglages/roles');
+
+  await expect(
+    page.getByRole('heading', { name: 'Rôles et permissions' }),
+  ).toBeVisible();
+  await expect(
+    page.getByText(/accorder que les capacités que vous détenez/),
+  ).toBeVisible();
+  await expect(page.getByText(/Au moins un rôle doit conserver/)).toBeVisible();
+});
+
+test('un rôle naît sans aucune capacité', async ({ page }) => {
+  const name = roleName('vierge');
+  await page.goto('/reglages/roles');
+
+  await page.getByLabel('Nom du rôle').fill(name);
+  await page.getByRole('button', { name: 'Créer' }).click();
+
+  // Un rôle neuf qui hériterait des capacités de son créateur distribuerait des
+  // droits que personne n'a demandés.
+  await expect(page.getByText(/sans aucune capacité/)).toBeVisible();
+
+  await page.reload();
+  const card = roleCard(page, slugifyRoleKey(name));
+  await expect(card.getByText('0 capacité')).toBeVisible();
+});
+
+test('un rôle système ne s’efface pas', async ({ page }) => {
+  await page.goto('/reglages/roles');
+
+  const card = roleCard(page, 'owner');
+  await expect(card.getByText('Rôle système')).toBeVisible();
+  // Le code et le semis y font référence par sa clé.
+  await expect(page.getByTestId('role-delete-owner')).toHaveCount(0);
+});
+
+test('retirer la dernière gestion des droits est refusé', async ({ page }) => {
+  await page.goto('/reglages/roles');
+
+  // `owner` et `admin` sont les seuls rôles semés à porter la capacité : il
+  // faut la retirer aux deux pour atteindre le refus.
+  const admin = roleCard(page, 'admin');
+  await admin.getByRole('checkbox', { name: /Gérer les rôles/ }).uncheck();
+  await admin.getByRole('button', { name: 'Enregistrer' }).click();
+  await expect(admin.getByText('Capacités enregistrées.')).toBeVisible();
+
+  await page.reload();
+  const owner = roleCard(page, 'owner');
+  await owner.getByRole('checkbox', { name: /Gérer les rôles/ }).uncheck();
+  await owner.getByRole('button', { name: 'Enregistrer' }).click();
+
+  // Le second retrait est celui qui fermerait la porte.
+  await expect(
+    page.getByText(/fermerait la gestion des droits à tout le monde/),
+  ).toBeVisible();
+
+  // Remettre la capacité : la suite de tests dépend de son existence.
+  await page.reload();
+  const restored = roleCard(page, 'admin');
+  await restored.getByRole('checkbox', { name: /Gérer les rôles/ }).check();
+  await restored.getByRole('button', { name: 'Enregistrer' }).click();
+  await expect(restored.getByText('Capacités enregistrées.')).toBeVisible();
+});
+
+test('un rôle client change effectivement l’accès', async ({
+  page,
+  browser,
+}) => {
+  test.setTimeout(90_000);
+  const name = roleName('acces');
+
+  await page.goto('/reglages/roles');
+  await page.getByLabel('Nom du rôle').fill(name);
+  await page.getByRole('button', { name: 'Créer' }).click();
+  await expect(page.getByText(/sans aucune capacité/)).toBeVisible();
+  await page.reload();
+
+  // Une seule capacité : voir l'annuaire. Rien d'autre.
+  const card = roleCard(page, slugifyRoleKey(name));
+  await card.getByRole('checkbox', { name: 'Voir l’annuaire' }).check();
+  await card.getByRole('button', { name: 'Enregistrer' }).click();
+  await expect(card.getByText('Capacités enregistrées.')).toBeVisible();
+
+  const account = await inviteWithRole(page, name);
+
+  const guest = await browser.newContext({ storageState: undefined });
+  const guestPage = await guest.newPage();
+  await guestPage.goto('/connexion');
+  await guestPage.getByLabel('Adresse électronique').fill(account.email);
+  await guestPage.getByLabel('Mot de passe').fill(account.password);
+  await guestPage.getByRole('button', { name: 'Se connecter' }).click();
+  await guestPage.waitForURL((url) => !url.pathname.endsWith('/connexion'));
+
+  // Ce que le rôle accorde s'ouvre.
+  await guestPage.goto('/equipe');
+  await expect(guestPage.getByRole('heading', { name: 'Équipe' })).toBeVisible();
+
+  // Ce qu'il n'accorde pas reste fermé — c'est la moitié qui compte.
+  await guestPage.goto('/reglages/roles');
+  await expect(
+    guestPage.getByRole('heading', { name: 'Rôles et permissions' }),
+  ).toHaveCount(0);
+
+  await guest.close();
+});
+
+/**
+ * Crée un salarié, lui attribue le rôle donné en base de l'annuaire, et ouvre
+ * son accès.
+ *
+ * Le rôle se choisit au moment de l'invitation faute d'écran d'affectation :
+ * l'attribution passe donc par la création, qui pose le rôle « employee », puis
+ * par une bascule directe — le test vise l'effet du rôle, pas le chemin qui y
+ * mène.
+ */
+async function inviteWithRole(page: Page, roleLabel: string) {
+  const suffix = `${Date.now()}-role`;
+  const email = `role.${suffix}@exemple.test`;
+  const password = 'les hirondelles de mars';
+  const lastName = `Role${suffix}`;
+
+  await page.goto('/equipe');
+  const create = page.locator('form').filter({ hasText: 'Ajouter' });
+  await create.getByLabel('Prénom').fill('Alix');
+  await create.getByLabel('Nom', { exact: true }).fill(lastName);
+  await create.getByLabel('Matricule').fill(`ROL${suffix}`);
+  await create.getByLabel('Adresse électronique').fill(email);
+  await create.getByRole('button', { name: 'Ajouter' }).click();
+  await expect(page.getByText('Salarié ajouté.')).toBeVisible();
+
+  await page.getByRole('link', { name: new RegExp(lastName) }).click();
+  // Attendre la fiche avant de lire l'URL : lue trop tôt, elle vaut encore
+  // celle de l'annuaire et l'identifiant récupéré ne désigne personne.
+  await expect(
+    page.getByRole('heading', { name: new RegExp(lastName) }),
+  ).toBeVisible();
+  const membershipId = page.url().split('/').pop()!;
+
+  const { assignRole } = await import('./support/db');
+  await assignRole(membershipId, roleLabel);
+
+  await page
+    .locator('form')
+    .filter({ hasText: 'Adresse d’invitation' })
+    .getByRole('button')
+    .click();
+  const url = (await page.getByTestId('invitation-link').textContent())!.trim();
+
+  const guest = await page.context().browser()!.newContext({
+    storageState: undefined,
+  });
+  const guestPage = await guest.newPage();
+  await guestPage.goto(url);
+  await guestPage.getByLabel('Choisissez un mot de passe').fill(password);
+  await guestPage.getByLabel('Confirmez').fill(password);
+  await guestPage.getByRole('button', { name: 'Activer mon accès' }).click();
+  await expect(guestPage.getByText(/Votre accès est actif/)).toBeVisible();
+  await guest.close();
+
+  return { email, password, membershipId };
+}
+
+test('le mot de passe de démonstration reste celui attendu', async ({
+  page,
+}) => {
+  // Garde-fou : ces tests remanient les droits, et une dérive fermerait la
+  // suite entière au passage suivant.
+  await page.goto('/reglages/roles');
+  await expect(page.getByRole('heading', { name: 'Rôles et permissions' })).toBeVisible();
+  expect(OWNER_PASSWORD).toBe('planflow-demo-2026');
+});

tests/e2e/support/db.ts

@@ -62,3 +62,31 @@ export async function backdateDocument(
     await tx.$executeRaw`UPDATE "Document" SET "uploadedAt" = ${uploadedAt} WHERE id = ${found.id}`;
   });
 }
+
+/**
+ * Attribue un rôle à un membership, par son libellé.
+ *
+ * Aucun écran d'affectation n'existe encore : sans ce levier, l'effet d'un rôle
+ * personnalisé — le critère d'acceptation de WP-01 — resterait invérifiable.
+ */
+export async function assignRole(
+  membershipId: string,
+  roleName: string,
+): Promise<void> {
+  const rows = await db().$queryRaw<Array<{ id: string; accountId: string }>>`
+    SELECT id, "accountId" FROM "Role" WHERE name = ${roleName} LIMIT 1
+  `;
+  const role = rows[0];
+  if (!role) throw new Error(`Rôle introuvable : ${roleName}`);
+
+  const updated = await db().$transaction(async (tx) => {
+    await tx.$executeRaw`SELECT set_config('app.account_id', ${role.accountId}, true)`;
+    return tx.$executeRaw`UPDATE "Membership" SET "roleId" = ${role.id} WHERE id = ${membershipId}`;
+  });
+
+  // Une mise à jour qui ne touche aucune ligne est indiscernable d'un succès :
+  // le test échouerait bien plus loin, sur un refus d'accès inexpliqué.
+  if (updated === 0) {
+    throw new Error(`Aucun membership mis à jour : ${membershipId}`);
+  }
+}

tests/unit/role-editing.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from 'vitest';
+
+import type { Actor } from '@/domain/access/authorize';
+import {
+  escalationRefusal,
+  lockoutRefusal,
+  OWNER_LEVEL_CAPABILITY,
+  REFUSAL_MESSAGES,
+  ROLE_ADMIN_CAPABILITY,
+  slugifyRoleKey,
+  type EditRefusal,
+} from '@/domain/access/role-editing';
+
+function actor(permissions: string[]): Actor {
+  return {
+    membershipId: 'm1',
+    accountId: 'a1',
+    userId: 'u1',
+    roleKey: 'admin',
+    permissions: new Set(permissions),
+    scope: { allLocations: true, locationIds: [], teamIds: [] },
+  };
+}
+
+describe('escalade', () => {
+  it('laisse accorder ce qu’on détient', () => {
+    expect(
+      escalationRefusal({
+        actor: actor(['planning.publish', ROLE_ADMIN_CAPABILITY]),
+        previous: new Set(),
+        next: new Set(['planning.publish']),
+      }),
+    ).toBeNull();
+  });
+
+  it('refuse d’accorder ce qu’on n’a pas', () => {
+    // Sans cette règle, la première personne autorisée à éditer un rôle
+    // s'accorde l'accès aux rémunérations en trois clics.
+    expect(
+      escalationRefusal({
+        actor: actor([ROLE_ADMIN_CAPABILITY]),
+        previous: new Set(),
+        next: new Set(['members.salary.view']),
+      }),
+    ).toBe('ESCALATION');
+  });
+
+  it('traite le niveau propriétaire à part', () => {
+    expect(
+      escalationRefusal({
+        actor: actor([ROLE_ADMIN_CAPABILITY]),
+        previous: new Set(),
+        next: new Set([OWNER_LEVEL_CAPABILITY]),
+      }),
+    ).toBe('OWNER_LEVEL');
+  });
+
+  it('laisse un propriétaire déléguer son niveau', () => {
+    expect(
+      escalationRefusal({
+        actor: actor([ROLE_ADMIN_CAPABILITY, OWNER_LEVEL_CAPABILITY]),
+        previous: new Set(),
+        next: new Set([OWNER_LEVEL_CAPABILITY]),
+      }),
+    ).toBeNull();
+  });
+
+  it('laisse retirer une capacité qu’on ne détient pas', () => {
+    // Réduire un droit n'a jamais élargi le sien : interdire ce retrait
+    // empêcherait de corriger un rôle trop large.
+    expect(
+      escalationRefusal({
+        actor: actor([ROLE_ADMIN_CAPABILITY]),
+        previous: new Set(['members.salary.view', 'planning.publish']),
+        next: new Set(['planning.publish']),
+      }),
+    ).toBeNull();
+  });
+
+  it('ignore une capacité déjà présente', () => {
+    // Enregistrer un rôle sans y toucher ne doit pas échouer parce qu'il porte
+    // une capacité que l'éditeur n'a pas.
+    expect(
+      escalationRefusal({
+        actor: actor([ROLE_ADMIN_CAPABILITY]),
+        previous: new Set(['members.salary.view']),
+        next: new Set(['members.salary.view']),
+      }),
+    ).toBeNull();
+  });
+});
+
+describe('verrouillage', () => {
+  it('accepte tant qu’un rôle garde la gestion des droits', () => {
+    expect(
+      lockoutRefusal({
+        rolesAfter: [
+          { id: 'r1', permissions: new Set([ROLE_ADMIN_CAPABILITY]) },
+          { id: 'r2', permissions: new Set(['planning.view']) },
+        ],
+      }),
+    ).toBeNull();
+  });
+
+  it('refuse le retrait du dernier', () => {
+    // Une organisation qui s'enferme dehors n'a plus d'autre recours qu'une
+    // intervention en base.
+    expect(
+      lockoutRefusal({
+        rolesAfter: [
+          { id: 'r1', permissions: new Set(['planning.view']) },
+          { id: 'r2', permissions: new Set(['planning.publish']) },
+        ],
+      }),
+    ).toBe('LAST_ADMIN');
+  });
+
+  it('se juge sur l’ensemble, pas sur le rôle édité', () => {
+    // Retirer la capacité d'un rôle est permis si un autre la conserve.
+    expect(
+      lockoutRefusal({
+        rolesAfter: [
+          { id: 'r1', permissions: new Set() },
+          { id: 'r2', permissions: new Set([ROLE_ADMIN_CAPABILITY]) },
+        ],
+      }),
+    ).toBeNull();
+  });
+});
+
+describe('clé de rôle', () => {
+  it('translittère et met en minuscules', () => {
+    expect(slugifyRoleKey('Responsable de secteur')).toBe(
+      'responsable-de-secteur',
+    );
+    expect(slugifyRoleKey('Chef d’équipe régionale')).toBe(
+      'chef-d-equipe-regionale',
+    );
+  });
+
+  it('ne laisse pas de tiret aux extrémités', () => {
+    expect(slugifyRoleKey('  — Extra —  ')).toBe('extra');
+  });
+
+  it('rend une chaîne vide quand rien n’est utilisable', () => {
+    // L'appelant refuse alors la création plutôt que de fabriquer une clé
+    // arbitraire que personne ne reconnaîtra.
+    expect(slugifyRoleKey('!!!')).toBe('');
+  });
+
+  it('borne la longueur', () => {
+    expect(slugifyRoleKey('a'.repeat(80)).length).toBe(40);
+  });
+});
+
+describe('messages de refus', () => {
+  it('en fournit un pour chaque motif', () => {
+    const refusals: EditRefusal[] = [
+      'ESCALATION',
+      'OWNER_LEVEL',
+      'LAST_ADMIN',
+      'SYSTEM_ROLE',
+      'DUPLICATE_KEY',
+      'ROLE_IN_USE',
+      'NOT_FOUND',
+    ];
+    for (const refusal of refusals) {
+      expect(REFUSAL_MESSAGES[refusal]).toBeTruthy();
+    }
+  });
+});