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>

e2e/aufgaben.spec.ts

@@ -0,0 +1,154 @@
+import { PrismaPg } from '@prisma/adapter-pg'
+import { expect, test, type Page } from '@playwright/test'
+import { PrismaClient } from '../src/generated/prisma/client.js'
+
+/**
+ * Der Weg, der in M2 wirklich zählt: erfassen, einsortieren, abhaken.
+ *
+ * Alle Testdaten tragen ein gemeinsames Präfix und werden am Ende entfernt,
+ * damit die Entwicklungsdatenbank hinterher aussieht wie vorher.
+ */
+
+const EMAIL = process.env.ADMIN_EMAIL ?? ''
+const PASSWORT = process.env.ADMIN_PASSWORT ?? ''
+const PRAEFIX = `E2E-${Date.now()}`
+
+const verbindung = process.env.DATABASE_URL ?? ''
+const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: verbindung }) })
+
+test.describe('Aufgaben', () => {
+  test.skip(
+    !EMAIL || !PASSWORT || !verbindung,
+    'Ohne ADMIN_EMAIL, ADMIN_PASSWORT und DATABASE_URL gibt es kein Testkonto.',
+  )
+
+  test.afterAll(async () => {
+    await db.aufgabe.deleteMany({ where: { titel: { startsWith: PRAEFIX } } })
+    await db.projekt.deleteMany({ where: { name: { startsWith: PRAEFIX } } })
+    await db.auditEintrag.deleteMany({ where: { aktion: { startsWith: 'aufgabe.' } } })
+    await db.$disconnect()
+  })
+
+  async function anmelden(seite: Page): Promise<void> {
+    await seite.goto('/anmelden')
+    await seite.getByLabel('E-Mail-Adresse').fill(EMAIL)
+    await seite.getByLabel('Passwort').fill(PASSWORT)
+    await seite.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
+    await expect(seite.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
+  }
+
+  test('erfasst schnell, sortiert ein und hakt ab', async ({ page }) => {
+    const titel = `${PRAEFIX} Angebot schreiben`
+    await anmelden(page)
+
+    // --- Erfassen: ein Feld genügt --------------------------------------
+    await page.goto('/inbox')
+    await page.getByLabel('Neue Aufgabe').fill(titel)
+    await page.getByRole('button', { name: 'Erfassen' }).click()
+
+    const zeile = page.locator('li').filter({ hasText: titel })
+    await expect(zeile).toBeVisible()
+    // Ohne Bereich liegt sie in der Inbox – genau das ist der Unterschied.
+    await expect(zeile.getByText('Inbox')).toBeVisible()
+
+    // --- Einsortieren ----------------------------------------------------
+    const bereich = await db.bereich.findFirst({
+      where: { aktiv: true },
+      orderBy: { reihenfolge: 'asc' },
+      select: { id: true, name: true },
+    })
+    expect(bereich).not.toBeNull()
+
+    await zeile.getByLabel('Einsortieren nach').selectOption(bereich!.id)
+    await expect(page.getByText(`liegt jetzt in ${bereich!.name}`)).toBeVisible()
+
+    // Aus der Inbox ist sie damit verschwunden.
+    await page.goto('/inbox')
+    await expect(page.locator('li').filter({ hasText: titel })).toHaveCount(0)
+
+    // --- Abhaken ---------------------------------------------------------
+    await page.goto('/aufgaben')
+    const inListe = page.locator('li').filter({ hasText: titel })
+    await expect(inListe).toBeVisible()
+    await inListe.getByRole('button', { name: 'Als erledigt abhaken' }).click()
+
+    // Erledigtes fällt aus der Standardansicht heraus.
+    await page.goto('/aufgaben')
+    await expect(page.locator('li').filter({ hasText: titel })).toHaveCount(0)
+
+    // Mit Filter "Alle" ist sie wieder da.
+    await page.goto('/aufgaben?status=ERLEDIGT')
+    await expect(page.locator('li').filter({ hasText: titel })).toBeVisible()
+
+    const gespeichert = await db.aufgabe.findFirst({ where: { titel } })
+    expect(gespeichert?.status).toBe('ERLEDIGT')
+    expect(gespeichert?.erledigtAm).not.toBeNull()
+  })
+
+  test('macht aus einer Idee eine Aufgabe', async ({ page }) => {
+    const titel = `${PRAEFIX} Blog aufsetzen`
+    await anmelden(page)
+
+    await page.goto('/ideen')
+    await page.getByLabel('Neue Idee').fill(titel)
+    await page.getByRole('button', { name: 'Erfassen' }).click()
+
+    const zeile = page.locator('li').filter({ hasText: titel })
+    await expect(zeile).toBeVisible()
+
+    await zeile.getByRole('button', { name: 'Zur Aufgabe machen' }).click()
+    await expect(page.getByText('ist jetzt eine Aufgabe')).toBeVisible()
+
+    const danach = await db.aufgabe.findFirst({ where: { titel } })
+    expect(danach?.typ).toBe('AUFGABE')
+
+    // Aus der Ideenliste ist sie damit verschwunden.
+    await page.goto('/ideen')
+    await expect(page.locator('li').filter({ hasText: titel })).toHaveCount(0)
+  })
+
+  test('filtert nach Bereich und über die Adresszeile', async ({ page }) => {
+    await anmelden(page)
+    const bereich = await db.bereich.findFirst({
+      where: { aktiv: true },
+      select: { id: true, name: true },
+    })
+
+    const drin = `${PRAEFIX} Gehört dazu`
+    const draussen = `${PRAEFIX} Gehört nicht dazu`
+    await db.aufgabe.createMany({
+      data: [
+        { titel: drin, bereichId: bereich!.id },
+        { titel: draussen, bereichId: null },
+      ],
+    })
+
+    await page.goto(`/aufgaben?bereich=${bereich!.id}`)
+    await expect(page.locator('li').filter({ hasText: drin })).toBeVisible()
+    await expect(page.locator('li').filter({ hasText: draussen })).toHaveCount(0)
+
+    // Nur Inbox zeigt genau die andere.
+    await page.goto('/aufgaben?bereich=inbox')
+    await expect(page.locator('li').filter({ hasText: draussen })).toBeVisible()
+    await expect(page.locator('li').filter({ hasText: drin })).toHaveCount(0)
+  })
+
+  test('zeigt den Fortschritt eines Projekts', async ({ page }) => {
+    const projektName = `${PRAEFIX} Website neu`
+    const projekt = await db.projekt.create({ data: { name: projektName } })
+    await db.aufgabe.createMany({
+      data: [
+        { titel: `${PRAEFIX} Entwurf`, projektId: projekt.id, status: 'ERLEDIGT' },
+        { titel: `${PRAEFIX} Umsetzung`, projektId: projekt.id, status: 'OFFEN' },
+        // Verworfenes zählt bewusst gar nicht mit.
+        { titel: `${PRAEFIX} Verworfen`, projektId: projekt.id, status: 'VERWORFEN' },
+      ],
+    })
+
+    await anmelden(page)
+    await page.goto(`/projekte/${projekt.id}`)
+
+    await expect(page.getByRole('heading', { name: projektName })).toBeVisible()
+    await expect(page.getByText('1 von 2 erledigt (50 %)')).toBeVisible()
+  })
+})