Rollenwechsel in Discord auf beiden Seiten pruefen

Der Worker ist die einzige Stelle, an der Discord-Rollen in die Datenbank
kommen. Damit haengt jede Befoerderung, Herabstufung und jeder Rauswurf an
syncMember und enforceMembership - geprueft war davon bisher nur der
vollstaendige Entzug.

Neu abgedeckt: Rollen werden getauscht statt angehaeuft, eine leere
Rollenliste raeumt wirklich alles ab, ein Rueckkehrer wird wieder aktiv,
und ein unveraendertes Mitglied loest keine Meldung aus - sonst wuerfe der
Fuenf-Minuten-Abgleich reihum jeden Zwischenspeicher weg.

Auf der Web-Seite dazu die Gegenrichtung: eine Befoerderung wirkt sofort,
die Stufe kommt aus der hoechsten Rolle und nicht aus der zuletzt
eingetragenen, und eine im Adminbereich geaenderte Rollenzuordnung wirkt
auch dann, wenn sich beim Nutzer selbst keine Zeile aendert.

Der Notify-Test stellt seine Voraussetzung jetzt selbst her. Er erbte die
zu loeschende Zeile von einem frueheren Test und waere still umgefallen,
sobald der etwas anderes tut: ohne Loeschung kein Ausloeser, ohne
Ausloeser keine Meldung.

web/tests/entzug.test.ts

@@ -3,7 +3,7 @@ import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { Client } from 'pg'
 import { db } from '@/lib/db'
 import { loadSession, createSession } from '@/lib/auth/session'
-import { invalidateUser, resolvePermissions } from '@/lib/auth/effective'
+import { invalidateAll, invalidateUser, resolvePermissions } from '@/lib/auth/effective'
 
 /**
  * Was passiert, wenn jemand seinen Zugriff verliert.
@@ -70,11 +70,78 @@ suite('Entzug des Zugriffs', () => {
     expect(danach.hasMembership).toBe(false)
   })
 
+  it('gibt eine Beförderung sofort weiter', async () => {
+    // Die Gegenrichtung zur Herabstufung: wer eine höhere Rolle bekommt, muss
+    // auch mehr sehen dürfen, sobald der Zwischenspeicher fällt.
+    await db.userRole.deleteMany({ where: { userId: nutzer } })
+    invalidateUser(nutzer)
+    expect((await resolvePermissions(nutzer)).clearanceLevel).toBe(0)
+
+    await db.userRole.create({ data: { userId: nutzer, discordRoleId: rolleHoch } })
+    invalidateUser(nutzer)
+
+    const danach = await resolvePermissions(nutzer)
+    expect(danach.clearanceLevel).toBe(4)
+    expect(danach.permissions.has('case.read')).toBe(true)
+    expect(danach.hasMembership).toBe(true)
+  })
+
+  it('nimmt die höchste Stufe aller Rollen, nicht die zuletzt vergebene', async () => {
+    // Wer befördert wird, behält meist seine alten Rollen. Käme die Stufe aus
+    // der zuletzt eingetragenen Zeile, hinge das Ergebnis an der Reihenfolge,
+    // in der Discord die Rollen liefert.
+    await db.userRole.deleteMany({ where: { userId: nutzer } })
+    await db.userRole.createMany({
+      data: [
+        { userId: nutzer, discordRoleId: rolleGast },
+        { userId: nutzer, discordRoleId: rolleHoch },
+      ],
+    })
+    invalidateUser(nutzer)
+
+    expect((await resolvePermissions(nutzer)).clearanceLevel).toBe(4)
+  })
+
+  it('wirkt auch, wenn nicht die Rolle sich ändert, sondern was sie gewährt', async () => {
+    // Der andere Weg zur Herabstufung: die Leitung nimmt einer Rolle im
+    // Adminbereich die Stufe. Dann ändert sich keine einzige UserRole-Zeile.
+    await db.userRole.deleteMany({ where: { userId: nutzer } })
+    await db.userRole.create({ data: { userId: nutzer, discordRoleId: rolleHoch } })
+    invalidateUser(nutzer)
+    expect((await resolvePermissions(nutzer)).clearanceLevel).toBe(4)
+
+    await db.roleMapping.update({
+      where: { discordRoleId: rolleHoch },
+      data: { clearanceLevel: 1, permissions: [] },
+    })
+    invalidateAll()
+
+    const danach = await resolvePermissions(nutzer)
+    expect(danach.clearanceLevel).toBe(1)
+    expect(danach.permissions.has('case.read')).toBe(false)
+
+    // Zurücksetzen, damit die folgenden Prüfungen ihre Grundlage behalten.
+    await db.roleMapping.update({
+      where: { discordRoleId: rolleHoch },
+      data: { clearanceLevel: 4, permissions: ['case.read'] },
+    })
+    invalidateAll()
+  })
+
   it('meldet jede Rollenänderung über den Kanal, der den Zwischenspeicher leert', async () => {
     // Das ist der Grund, warum eine Herabstufung in unter einer Sekunde wirkt
     // und nicht erst nach der Verfallszeit von 60 Sekunden. Ohne diesen
     // Auslöser bliebe die alte Stufe stehen, obwohl sie in der Datenbank
     // längst weg ist.
+    // Voraussetzung selbst herstellen: ein Test, der die Zeile von einem
+    // frueheren erbt, faellt still um, sobald der etwas anders macht - dann
+    // loescht `deleteMany` nichts, es feuert kein Ausloeser, und es sieht nach
+    // einem kaputten Kanal aus.
+    await db.userRole.createMany({
+      data: [{ userId: nutzer, discordRoleId: rolleGast }],
+      skipDuplicates: true,
+    })
+
     const horcher = new Client({ connectionString: url })
     await horcher.connect()
     try {