Phase 6 abgeschlossen: Aktenchat, Kanäle, Echtzeit, Benachrichtigungen
Ein Ereignisstrom mit Themen (/api/stream), in dem der Dateistrom aus Phase 5 aufgegangen ist. Zwei Prüfungen: beim Verbinden, welche Themen der Nutzer abonnieren darf, und je Ereignis wird der Inhalt mit seinen Rechten geladen. Das zweite ist nicht nur Vorsicht - eine Umklassifizierung wirkt dadurch in einer offenen Verbindung sofort. In der pg_notify-Nutzlast steht nie ein Inhalt, nur Thema, Art und Kennung. Der Aktenchat sendet optimistisch mit clientseitiger UUIDv7, die zugleich Idempotenzschlüssel ist. Antworten, vier feste Reaktionen, Bearbeiten mit sichtbarem editedAt, Zurückziehen mit Platzhalter - Löschen gibt es nicht, und eine Regel in der Datenbank hält das fest. Eine zurückgezogene Nachricht kommt ohne Text an, nicht ausgeblendet. Aktenzeichen im Text werden zu Vorschaukarten, serverseitig aufgelöst. Eine Akte, die der Leser nicht sehen darf, sieht darin genauso aus wie eine, die es gar nicht gibt. "Als Vermerk übernehmen" steht sichtbar an jeder Nachricht. Der Vermerk gehört dem Verfasser, nicht dem Übernehmenden; ein Systemeintrag nennt den Ursprung, damit der Wortlaut später nicht für die Akte geschrieben wirkt. Bei den Discord-Benachrichtigungen entscheidet die Web-App, wer was erfährt, und der Worker liefert nur aus. Die Alternative hätte geheissen, die Sichtbarkeitsprüfung im Worker ein zweites Mal zu bauen. In meta steht ein Titel nur, wenn er hinaus darf - ab Stufe 3 keiner. Postausgang als Tabelle, angestossen über LISTEN, mit Takt als Sicherheitsnetz. Nebenbei riss das Budget der Fallakte erneut (122 kB). Drei Schritte zurück auf 119,6: Chattexte in eine eigene i18n-Datei, ein gemeinsames AddPanel statt viermal derselbe Aufklapp-Code, und eine eigene UUIDv7 statt des Pakets - die Sortierbarkeit, auf der die Nachlieferung beruht, steht damit im eigenen Code und hat Tests. Unterwegs habe ich NotifyMode und User.notifyMode ein zweites Mal angelegt, obwohl es beides seit dem Grundgerüst gibt. Die Migration schlug fehl und die Datenbank musste von Hand aufgeräumt werden; die Lehre steht in docs/13. 155 Tests im Web-Paket, 15 in der Datenbank, 7 im Worker, 32 e2e.
This commit is contained in:
Harlekin
@@ -0,0 +1,175 @@
|
||||
// @vitest-environment node
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
||||
import { db } from '@/lib/db'
|
||||
import { enqueueCaseNotification } from '@/lib/notify/enqueue'
|
||||
import type { Prisma } from '@afis/db'
|
||||
|
||||
/**
|
||||
* Discord kennt unsere Klassifizierung nicht.
|
||||
*
|
||||
* Deshalb entscheidet **diese Anwendung**, wer eine Meldung bekommt und was
|
||||
* darin stehen darf; der Worker liefert nur aus. Diese Tests prüfen genau die
|
||||
* beiden Zusicherungen, auf denen das beruht.
|
||||
*/
|
||||
const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
|
||||
const suite = url ? describe : describe.skip
|
||||
|
||||
const marke = `notify-${Date.now()}`
|
||||
|
||||
suite('Benachrichtigungen', () => {
|
||||
const nutzer = {
|
||||
autor: `${marke}-autor`,
|
||||
stufe1: `${marke}-stufe1`,
|
||||
stufe4: `${marke}-stufe4`,
|
||||
aus: `${marke}-aus`,
|
||||
ausgeschlossen: `${marke}-ausgeschlossen`,
|
||||
}
|
||||
let geheimId = ''
|
||||
let geheimNummer = ''
|
||||
|
||||
async function empfaengerVon(kind: string): Promise<string[]> {
|
||||
const zeilen = await db.notificationOutbox.findMany({
|
||||
where: { caseId: geheimId, kind },
|
||||
select: { recipientId: true },
|
||||
})
|
||||
return zeilen
|
||||
.map((z) => z.recipientId)
|
||||
.filter((id): id is string => id !== null)
|
||||
.sort()
|
||||
}
|
||||
|
||||
beforeAll(async () => {
|
||||
const vorlage = await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
|
||||
})
|
||||
|
||||
// Eine Rolle mit Stufe 4, damit die Rechteauflösung etwas zu tun hat.
|
||||
const rolle = await db.roleMapping.create({
|
||||
data: {
|
||||
discordRoleId: `${marke}-rolle`,
|
||||
label: 'Prüfstufe 4',
|
||||
clearanceLevel: 4,
|
||||
permissions: [],
|
||||
grantsMembership: true,
|
||||
category: 'CLEARANCE',
|
||||
},
|
||||
})
|
||||
|
||||
for (const [name, id] of Object.entries(nutzer)) {
|
||||
await db.user.create({
|
||||
data: {
|
||||
id,
|
||||
username: id,
|
||||
displayName: id,
|
||||
notifyMode: name === 'aus' ? 'OFF' : 'ALL',
|
||||
...(name === 'stufe4' || name === 'ausgeschlossen'
|
||||
? { roles: { create: { discordRoleId: rolle.discordRoleId } } }
|
||||
: {}),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
const akte = await db.case.create({
|
||||
data: {
|
||||
caseNumber: `Meld-2026-${String(Date.now()).slice(-4)}`,
|
||||
title: 'Streng vertraulicher Vorgang',
|
||||
templateId: vorlage.id,
|
||||
templateKey: vorlage.key,
|
||||
createdById: nutzer.autor,
|
||||
classification: 4,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
geheimId = akte.id
|
||||
geheimNummer = akte.caseNumber
|
||||
|
||||
await db.caseExclusion.create({
|
||||
data: { caseId: akte.id, userId: nutzer.ausgeschlossen, reason: 'Betroffener' },
|
||||
})
|
||||
})
|
||||
|
||||
afterAll(async () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
it('schreibt nur an die, die die Akte auch sehen dürfen', async () => {
|
||||
await db.$transaction(async (tx) => {
|
||||
await enqueueCaseNotification(tx as Prisma.TransactionClient, {
|
||||
kind: 'entry.new',
|
||||
caseId: geheimId,
|
||||
caseNumber: geheimNummer,
|
||||
classification: 4,
|
||||
title: 'Streng vertraulicher Vorgang',
|
||||
actorId: nutzer.autor,
|
||||
actorName: 'Autor',
|
||||
})
|
||||
})
|
||||
|
||||
const ziele = await empfaengerVon('entry.new')
|
||||
|
||||
// Stufe 4 bekommt die Meldung.
|
||||
expect(ziele).toContain(nutzer.stufe4)
|
||||
// Stufe 1 nicht — die Akte gibt es für ihn nicht.
|
||||
expect(ziele).not.toContain(nutzer.stufe1)
|
||||
// Wer abgeschaltet hat, bekommt nichts.
|
||||
expect(ziele).not.toContain(nutzer.aus)
|
||||
// Der Ausschluss schlägt auch die Stufe.
|
||||
expect(ziele).not.toContain(nutzer.ausgeschlossen)
|
||||
// Und der Auslöser bekommt keine Meldung über sich selbst.
|
||||
expect(ziele).not.toContain(nutzer.autor)
|
||||
})
|
||||
|
||||
it('lässt den Titel ab Stufe 3 weg', async () => {
|
||||
const zeile = await db.notificationOutbox.findFirstOrThrow({
|
||||
where: { caseId: geheimId, kind: 'entry.new' },
|
||||
select: { meta: true },
|
||||
})
|
||||
const meta = zeile.meta as { caseNumber?: string; title?: string | null }
|
||||
|
||||
// Das Aktenzeichen darf hinaus, der Titel nicht: Discord kennt unsere
|
||||
// Klassifizierung nicht, der Link führt zur App, die selbst prüft.
|
||||
expect(meta.caseNumber).toBe(geheimNummer)
|
||||
expect(meta.title).toBeNull()
|
||||
})
|
||||
|
||||
it('legt eine Zeile für den allgemeinen Kanal an, ohne Empfänger', async () => {
|
||||
const allgemein = await db.notificationOutbox.findMany({
|
||||
where: { caseId: geheimId, kind: 'entry.new', recipientId: null },
|
||||
})
|
||||
expect(allgemein).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('nimmt bei niedriger Stufe den Titel mit', async () => {
|
||||
const offen = await db.case.create({
|
||||
data: {
|
||||
caseNumber: `Offn-2026-${String(Date.now()).slice(-4)}`,
|
||||
title: 'Harmloser Vorgang',
|
||||
templateId: (await db.documentTemplate.findFirstOrThrow({
|
||||
where: { key: `${marke}-vorlage` },
|
||||
})).id,
|
||||
templateKey: `${marke}-vorlage`,
|
||||
createdById: nutzer.autor,
|
||||
classification: 1,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
|
||||
await db.$transaction(async (tx) => {
|
||||
await enqueueCaseNotification(tx as Prisma.TransactionClient, {
|
||||
kind: 'entry.new',
|
||||
caseId: offen.id,
|
||||
caseNumber: offen.caseNumber,
|
||||
classification: 1,
|
||||
title: 'Harmloser Vorgang',
|
||||
actorId: nutzer.autor,
|
||||
actorName: 'Autor',
|
||||
})
|
||||
})
|
||||
|
||||
const zeile = await db.notificationOutbox.findFirstOrThrow({
|
||||
where: { caseId: offen.id },
|
||||
select: { meta: true },
|
||||
})
|
||||
expect((zeile.meta as { title?: string | null }).title).toBe('Harmloser Vorgang')
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,225 @@
|
||||
// @vitest-environment node
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
||||
import { db } from '@/lib/db'
|
||||
import { visibleChannelWhere, visibleMessageWhere } from '@/lib/access/chatFilter'
|
||||
import { adoptAsEntry, listMessages, sendMessage } from '@/lib/chat/service'
|
||||
import { resolveCasePreviews } from '@/lib/chat/preview'
|
||||
import { AccessError } from '@/lib/errors'
|
||||
import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
|
||||
|
||||
/**
|
||||
* Der Chat erbt die Sichtbarkeit seines Ortes. Der heikelste Teil ist die
|
||||
* Vorschaukarte: ein Aktenzeichen im Text darf einem zu niedrig eingestuften
|
||||
* Leser nichts über die Akte verraten — auch nicht, ob es sie gibt.
|
||||
*/
|
||||
const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
|
||||
const suite = url ? describe : describe.skip
|
||||
|
||||
const marke = `chat-${Date.now()}`
|
||||
|
||||
function perms(
|
||||
userId: string,
|
||||
clearanceLevel: number,
|
||||
options: { isAdmin?: boolean; permissions?: Permission[] } = {},
|
||||
): EffectivePermissions {
|
||||
return {
|
||||
userId,
|
||||
clearanceLevel,
|
||||
permissions: new Set<Permission>(options.permissions ?? []),
|
||||
isAdmin: options.isAdmin ?? false,
|
||||
hasMembership: true,
|
||||
}
|
||||
}
|
||||
|
||||
suite('Aktenchat und Kanäle', () => {
|
||||
const nutzer = { stufe1: `${marke}-stufe1`, stufe4: `${marke}-stufe4` }
|
||||
let offenNummer = ''
|
||||
let geheimNummer = ''
|
||||
let offenId = ''
|
||||
let geheimId = ''
|
||||
let kanalOffen = ''
|
||||
let kanalGeheim = ''
|
||||
|
||||
beforeAll(async () => {
|
||||
const vorlage = await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
|
||||
})
|
||||
for (const id of Object.values(nutzer)) {
|
||||
await db.user.create({ data: { id, username: id, displayName: id } })
|
||||
}
|
||||
|
||||
const gemeinsam = {
|
||||
templateId: vorlage.id,
|
||||
templateKey: vorlage.key,
|
||||
createdById: nutzer.stufe4,
|
||||
}
|
||||
const offen = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
caseNumber: `Chat-2026-${String(Date.now()).slice(-4)}`,
|
||||
title: 'Offener Vorgang',
|
||||
classification: 1,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
const geheim = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
caseNumber: `Gehm-2026-${String(Date.now()).slice(-4)}`,
|
||||
title: 'Streng vertraulich',
|
||||
classification: 4,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
offenNummer = offen.caseNumber
|
||||
geheimNummer = geheim.caseNumber
|
||||
offenId = offen.id
|
||||
geheimId = geheim.id
|
||||
|
||||
const k1 = await db.channel.create({
|
||||
data: {
|
||||
key: `${marke}-allgemein`.slice(0, 40),
|
||||
name: 'Allgemein',
|
||||
minClearance: 0,
|
||||
createdById: nutzer.stufe4,
|
||||
},
|
||||
})
|
||||
const k2 = await db.channel.create({
|
||||
data: {
|
||||
key: `${marke}-leitung`.slice(0, 40),
|
||||
name: 'Leitung',
|
||||
minClearance: 4,
|
||||
createdById: nutzer.stufe4,
|
||||
},
|
||||
})
|
||||
kanalOffen = k1.key
|
||||
kanalGeheim = k2.key
|
||||
})
|
||||
|
||||
afterAll(async () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
it('verbirgt den Chat einer zu hoch eingestuften Akte', async () => {
|
||||
await sendMessage(perms(nutzer.stufe4, 4), {
|
||||
id: `${marke}-geheim-1`,
|
||||
scope: { kind: 'case', caseNumber: geheimNummer },
|
||||
body: 'Interner Stand',
|
||||
})
|
||||
|
||||
// Nicht "leere Liste", sondern: es gibt den Ort für ihn nicht.
|
||||
await expect(
|
||||
listMessages(perms(nutzer.stufe1, 1), { kind: 'case', caseNumber: geheimNummer }),
|
||||
).rejects.toThrow(AccessError)
|
||||
|
||||
const sichtbar = await db.chatMessage.findMany({
|
||||
where: { AND: [visibleMessageWhere(perms(nutzer.stufe1, 1)), { caseId: geheimId }] },
|
||||
select: { id: true },
|
||||
})
|
||||
expect(sichtbar).toHaveLength(0)
|
||||
})
|
||||
|
||||
it('verbirgt einen Kanal über der eigenen Stufe', async () => {
|
||||
const kanaele = await db.channel.findMany({
|
||||
where: {
|
||||
AND: [
|
||||
visibleChannelWhere(perms(nutzer.stufe1, 1)),
|
||||
{ key: { in: [kanalOffen, kanalGeheim] } },
|
||||
],
|
||||
},
|
||||
select: { key: true },
|
||||
})
|
||||
expect(kanaele.map((k) => k.key)).toEqual([kanalOffen])
|
||||
})
|
||||
|
||||
it('verrät über die Vorschaukarte nichts über eine verborgene Akte', async () => {
|
||||
const fuerStufe1 = await resolveCasePreviews(perms(nutzer.stufe1, 1), [
|
||||
offenNummer,
|
||||
geheimNummer,
|
||||
'AfiS-1999-0001',
|
||||
])
|
||||
|
||||
// Sichtbar: mit Titel. Verborgen: ohne alles — und genauso wie eine Akte,
|
||||
// die es gar nicht gibt.
|
||||
expect(fuerStufe1.get(offenNummer)).toMatchObject({ visible: true, title: 'Offener Vorgang' })
|
||||
expect(fuerStufe1.get(geheimNummer)).toEqual({ caseNumber: geheimNummer, visible: false })
|
||||
expect(fuerStufe1.get('AfiS-1999-0001')).toEqual({
|
||||
caseNumber: 'AfiS-1999-0001',
|
||||
visible: false,
|
||||
})
|
||||
|
||||
const fuerStufe4 = await resolveCasePreviews(perms(nutzer.stufe4, 4), [geheimNummer])
|
||||
expect(fuerStufe4.get(geheimNummer)).toMatchObject({ visible: true })
|
||||
})
|
||||
|
||||
it('behandelt dieselbe Kennung zweimal gesendet als eine Nachricht', async () => {
|
||||
const id = `${marke}-doppelt`
|
||||
const scope = { kind: 'case' as const, caseNumber: offenNummer }
|
||||
|
||||
await sendMessage(perms(nutzer.stufe1, 1), { id, scope, body: 'Einmal' })
|
||||
await sendMessage(perms(nutzer.stufe1, 1), { id, scope, body: 'Nochmal' })
|
||||
|
||||
const treffer = await db.chatMessage.findMany({ where: { id }, select: { body: true } })
|
||||
expect(treffer).toHaveLength(1)
|
||||
// Der erste Text bleibt: das zweite Absenden war ein Wiederholungsversuch,
|
||||
// keine Änderung.
|
||||
expect(treffer[0]?.body).toBe('Einmal')
|
||||
})
|
||||
|
||||
it('löst Erwähnungen serverseitig auf', async () => {
|
||||
const id = `${marke}-erwaehnung`
|
||||
await sendMessage(perms(nutzer.stufe4, 4), {
|
||||
id,
|
||||
scope: { kind: 'case', caseNumber: offenNummer },
|
||||
// Der zweite Name gibt es nicht — er darf nicht in mentions landen.
|
||||
body: `Bitte schauen @${nutzer.stufe1} und @niemand`,
|
||||
})
|
||||
|
||||
const nachricht = await db.chatMessage.findUniqueOrThrow({
|
||||
where: { id },
|
||||
select: { mentions: true },
|
||||
})
|
||||
expect(nachricht.mentions).toEqual([nutzer.stufe1])
|
||||
})
|
||||
|
||||
it('macht aus einer Nachricht einen Vermerk und lässt sie stehen', async () => {
|
||||
const id = `${marke}-uebernahme`
|
||||
const p = perms(nutzer.stufe4, 4, { permissions: ['entry.create', 'case.edit'] })
|
||||
await sendMessage(p, {
|
||||
id,
|
||||
scope: { kind: 'case', caseNumber: offenNummer },
|
||||
body: 'Der Zeuge widerruft seine Aussage.',
|
||||
})
|
||||
|
||||
const { entryId } = await adoptAsEntry(p, id)
|
||||
|
||||
const eintrag = await db.caseEntry.findUniqueOrThrow({ where: { id: entryId } })
|
||||
expect(eintrag.body).toBe('Der Zeuge widerruft seine Aussage.')
|
||||
// Der Vermerk gehört dem Verfasser, nicht dem, der ihn übernommen hat.
|
||||
expect(eintrag.authorId).toBe(nutzer.stufe4)
|
||||
expect(eintrag.type).toBe('NOTE')
|
||||
|
||||
const nachricht = await db.chatMessage.findUniqueOrThrow({ where: { id } })
|
||||
expect(nachricht.adoptedEntryId).toBe(entryId)
|
||||
|
||||
// Ein Systemeintrag nennt den Ursprung, damit später niemand denkt, der
|
||||
// Wortlaut sei für die Akte geschrieben worden.
|
||||
const hinweis = await db.caseEntry.findFirst({
|
||||
where: { caseId: offenId, type: 'SYSTEM', body: { contains: 'Aktenchat' } },
|
||||
select: { id: true },
|
||||
})
|
||||
expect(hinweis).not.toBeNull()
|
||||
|
||||
// Zweimal übernehmen erzeugt keinen zweiten Vermerk.
|
||||
expect((await adoptAsEntry(p, id)).entryId).toBe(entryId)
|
||||
})
|
||||
|
||||
it('macht aus einer Kanalnachricht keinen Vermerk', async () => {
|
||||
const id = `${marke}-kanal`
|
||||
const p = perms(nutzer.stufe4, 4, { permissions: ['entry.create', 'case.edit'] })
|
||||
await sendMessage(p, { id, scope: { kind: 'channel', key: kanalOffen }, body: 'Absprache' })
|
||||
|
||||
// Ein Vermerk gehört in eine Akte. Ein Kanal hat keine.
|
||||
await expect(adoptAsEntry(p, id)).rejects.toThrow(AccessError)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,44 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { extractMentionNames, splitBody } from '@/lib/chat/mentions'
|
||||
import { extractCaseNumbers } from '@/lib/chat/view'
|
||||
|
||||
describe('Erwähnungen und Aktenzeichen im Text', () => {
|
||||
it('findet Erwähnungen und normalisiert die Schreibweise', () => {
|
||||
expect(extractMentionNames('Hallo @Vogel und @vogel und @kranz_j')).toEqual([
|
||||
'vogel',
|
||||
'kranz_j',
|
||||
])
|
||||
})
|
||||
|
||||
it('zerlegt den Text, statt HTML daraus zu bauen', () => {
|
||||
// Kein dangerouslySetInnerHTML für Nutzerinhalte, siehe docs/07.
|
||||
const stuecke = splitBody('Siehe AfiS-2026-0042, @vogel weiss mehr')
|
||||
expect(stuecke.map((s) => s.kind)).toEqual(['text', 'caseNumber', 'text', 'mention', 'text'])
|
||||
expect(stuecke[1]).toMatchObject({ kind: 'caseNumber', value: 'AfiS-2026-0042' })
|
||||
})
|
||||
|
||||
it('lässt Auszeichnungszeichen als Text stehen', () => {
|
||||
const stuecke = splitBody('<script>alert(1)</script>')
|
||||
expect(stuecke).toEqual([{ kind: 'text', value: '<script>alert(1)</script>' }])
|
||||
})
|
||||
|
||||
it('macht aus einer Überlappung nicht zwei Stücke', () => {
|
||||
// `@AfiS-2026-0001` ist beides. Der erste Treffer gewinnt, sonst stünde
|
||||
// ein Teil des Textes doppelt da.
|
||||
const stuecke = splitBody('@AfiS-2026-0001')
|
||||
const zusammen = stuecke.map((s) => s.value).join('')
|
||||
expect(zusammen).toBe('@AfiS-2026-0001')
|
||||
})
|
||||
|
||||
it('erkennt gewachsene Präfixe im Aktenzeichen', () => {
|
||||
expect(extractCaseNumbers('AKT-PA-2026-62843 und AfiS-2026-0007')).toEqual([
|
||||
'AKT-PA-2026-62843',
|
||||
'AfiS-2026-0007',
|
||||
])
|
||||
})
|
||||
|
||||
it('hält Text ohne Treffer zusammen', () => {
|
||||
expect(splitBody('nur Text')).toEqual([{ kind: 'text', value: 'nur Text' }])
|
||||
expect(extractCaseNumbers('kein Zeichen hier')).toEqual([])
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,47 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { uuidv7 } from '@/lib/uuidv7'
|
||||
|
||||
/**
|
||||
* Auf der Sortierbarkeit dieser Kennungen beruhen zwei Dinge: die
|
||||
* Nachlieferung verpasster Nachrichten (`id > seit`) und die Reihenfolge im
|
||||
* Chat. Bricht sie, kommen Nachrichten durcheinander an oder gehen bei einem
|
||||
* Wiederverbinden verloren — beides fällt spät und unangenehm auf.
|
||||
*/
|
||||
describe('UUIDv7', () => {
|
||||
it('hat die richtige Form, Version und Variante', () => {
|
||||
const id = uuidv7()
|
||||
expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)
|
||||
})
|
||||
|
||||
it('trägt den Zeitstempel in den ersten 48 Bit', () => {
|
||||
// Muss über allem liegen, was vorherige Aufrufe schon vergeben haben:
|
||||
// der Zähler im Modul geht bewusst nie zurück.
|
||||
const zeitpunkt = Date.now() + 60_000
|
||||
const id = uuidv7(zeitpunkt)
|
||||
const hex = id.replace(/-/g, '').slice(0, 12)
|
||||
expect(Number.parseInt(hex, 16)).toBe(zeitpunkt)
|
||||
})
|
||||
|
||||
it('bleibt innerhalb derselben Millisekunde sortierbar', () => {
|
||||
// Ohne Zähler kämen zwei schnell hintereinander gesendete Nachrichten in
|
||||
// zufälliger Reihenfolge an.
|
||||
const zeitpunkt = Date.now()
|
||||
const ids = Array.from({ length: 500 }, () => uuidv7(zeitpunkt))
|
||||
expect([...ids].sort()).toEqual(ids)
|
||||
expect(new Set(ids).size).toBe(ids.length)
|
||||
})
|
||||
|
||||
it('sortiert über Millisekunden hinweg', () => {
|
||||
const frueh = uuidv7(1_700_000_000_000)
|
||||
const spaet = uuidv7(1_700_000_000_001)
|
||||
expect(frueh < spaet).toBe(true)
|
||||
})
|
||||
|
||||
it('fällt bei einer zurückspringenden Uhr nicht zurück', () => {
|
||||
// Sommerzeit, NTP-Korrektur: die Reihenfolge ist wichtiger als der genaue
|
||||
// Zeitpunkt, sonst überholt eine neue Nachricht eine alte.
|
||||
const vorher = uuidv7(1_800_000_000_000)
|
||||
const nachher = uuidv7(1_700_000_000_000)
|
||||
expect(nachher > vorher).toBe(true)
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user