test: Erfassungsweg und Eindeutigkeit der Quellen absichern

E2E über den Weg, der in M2 zählt: schnell erfassen, einsortieren,
abhaken — und nachsehen, dass Erledigtes aus der Standardansicht fällt,
aber mit Filter wieder auftaucht.

Der Integrationstest deckt jetzt auch ab, was die Integrationen ab M6
brauchen: dieselbe Quelle mit derselben Kennung nur einmal, dieselbe
Kennung bei anderer Quelle erlaubt, mehrere Aufgaben ohne Quellverweis
nebeneinander, und ein Upsert aktualisiert statt zu doppeln.

Dazu der Nachweis, dass Aufgaben das Löschen ihres Projekts und ihres
Bereichs überleben und dabei nur die Zuordnung verlieren.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

scripts/integrationstest.ts

@@ -44,8 +44,11 @@ const kennung = `zzz-test-${Date.now()}`
 const testEmail = `${kennung}@example.invalid`
 
 async function aufraeumen(): Promise<void> {
-  // Reihenfolge egal, die Kaskaden erledigen den Rest; der Audit-Eintrag
-  // hängt bewusst an keinem Benutzer mehr.
+  // Erst die Aufgaben, dann Projekt und Bereich – sonst blieben Verweise
+  // stehen, die den Bereich am Löschen hindern.
+  await db.aufgabe.deleteMany({ where: { titel: { startsWith: kennung } } })
+  await db.aufgabe.deleteMany({ where: { quelleRef: { startsWith: kennung } } })
+  await db.projekt.deleteMany({ where: { name: { startsWith: kennung } } })
   await db.auditEintrag.deleteMany({ where: { benutzerEmail: testEmail } })
   await db.benutzer.deleteMany({ where: { email: testEmail } })
   await db.bereich.deleteMany({ where: { name: { startsWith: kennung } } })
@@ -174,6 +177,120 @@ async function main(): Promise<void> {
     'Verknüpfte Konten verschwinden mit dem Benutzer',
     (await db.konto.count({ where: { providerAccountId: kennung } })) === 0,
   )
+
+  // --- Aufgaben: Standardwerte und Inbox -----------------------------------
+  const aufgabe = await db.aufgabe.create({
+    data: { titel: `${kennung} Angebot schreiben` },
+  })
+  pruefe('Aufgabe anlegen', aufgabe.id.length > 0)
+  pruefe(
+    'Ohne Angabe ist eine Aufgabe offen, normal und von Hand erfasst',
+    aufgabe.status === 'OFFEN' &&
+      aufgabe.typ === 'AUFGABE' &&
+      aufgabe.prioritaet === 3 &&
+      aufgabe.quelle === 'MANUELL',
+  )
+  pruefe('Ohne Bereich liegt sie in der Inbox', aufgabe.bereichId === null)
+
+  // --- Eindeutigkeit der Quelle -------------------------------------------
+  // Von Hand erfasste Aufgaben haben quelleRef = null. PostgreSQL sieht
+  // NULL-Werte als verschieden an, deshalb behindern sie sich nicht.
+  const zweiteOhneRef = await db.aufgabe.create({
+    data: { titel: `${kennung} Noch eine von Hand` },
+  })
+  pruefe(
+    'Mehrere Aufgaben ohne Quellverweis sind erlaubt',
+    zweiteOhneRef.id !== aufgabe.id,
+  )
+
+  await db.aufgabe.create({
+    data: {
+      titel: `${kennung} Ticket 4711`,
+      quelle: 'ZAMMAD',
+      quelleRef: `${kennung}-4711`,
+      quelleUrl: 'https://zammad.example.invalid/4711',
+    },
+  })
+  await scheitert('Dieselbe Quelle mit derselben Kennung nur einmal', () =>
+    db.aufgabe.create({
+      data: {
+        titel: `${kennung} Ticket 4711 doppelt`,
+        quelle: 'ZAMMAD',
+        quelleRef: `${kennung}-4711`,
+      },
+    }),
+  )
+
+  // Dieselbe Kennung bei anderer Quelle ist dagegen in Ordnung.
+  const andereQuelle = await db.aufgabe.create({
+    data: {
+      titel: `${kennung} Telegram 4711`,
+      quelle: 'TELEGRAM',
+      quelleRef: `${kennung}-4711`,
+    },
+  })
+  pruefe('Dieselbe Kennung bei anderer Quelle ist erlaubt', andereQuelle.id.length > 0)
+
+  // So werden Integrationen es tun: upsert statt anlegen.
+  const gewandelt = await db.aufgabe.upsert({
+    where: {
+      quelle_quelleRef: { quelle: 'ZAMMAD', quelleRef: `${kennung}-4711` },
+    },
+    update: { titel: `${kennung} Ticket 4711 aktualisiert` },
+    create: {
+      titel: `${kennung} Ticket 4711 neu`,
+      quelle: 'ZAMMAD',
+      quelleRef: `${kennung}-4711`,
+    },
+  })
+  pruefe(
+    'Ein Upsert über [quelle, quelleRef] aktualisiert statt zu doppeln',
+    gewandelt.titel.endsWith('aktualisiert') &&
+      (await db.aufgabe.count({
+        where: { quelle: 'ZAMMAD', quelleRef: `${kennung}-4711` },
+      })) === 1,
+  )
+
+  // --- Projekt: Zuordnung überlebt das Löschen nicht, die Aufgabe schon ----
+  const projekt = await db.projekt.create({ data: { name: `${kennung} Website` } })
+  await db.aufgabe.update({
+    where: { id: aufgabe.id },
+    data: { projektId: projekt.id },
+  })
+
+  await scheitert('Projektname ist eindeutig', () =>
+    db.projekt.create({ data: { name: projekt.name } }),
+  )
+
+  await db.projekt.delete({ where: { id: projekt.id } })
+  const nachProjektLoeschung = await db.aufgabe.findUnique({
+    where: { id: aufgabe.id },
+    select: { id: true, projektId: true },
+  })
+  pruefe('Die Aufgabe überlebt das Löschen ihres Projekts', nachProjektLoeschung !== null)
+  pruefe(
+    'Nur die Zuordnung zum Projekt wird gelöst',
+    nachProjektLoeschung?.projektId === null,
+  )
+
+  // --- Bereich: dasselbe Verhalten ----------------------------------------
+  const bereich2 = await db.bereich.create({
+    data: { name: `${kennung}-zweiter`, farbe: '#16a34a' },
+  })
+  await db.aufgabe.update({
+    where: { id: aufgabe.id },
+    data: { bereichId: bereich2.id },
+  })
+  await db.bereich.delete({ where: { id: bereich2.id } })
+
+  const nachBereichLoeschung = await db.aufgabe.findUnique({
+    where: { id: aufgabe.id },
+    select: { bereichId: true },
+  })
+  pruefe(
+    'Beim Löschen eines Bereichs fällt die Aufgabe zurück in die Inbox',
+    nachBereichLoeschung?.bereichId === null,
+  )
 }
 
 let abbruch: unknown = null