betreuungs-cockpit/e2e/dauerzahlung.spec.ts

import { expect, test } from '@playwright/test'
import { PrismaClient } from '@prisma/client'
import { anmelden } from './hilfen'

/**
 * Dauerzahlungen zu einem Vertrag — gegen die echte Anwendung.
 *
 * Die Einheitstests nageln die Belegzustände fest. Hier geht es um das, was
 * sie nicht sehen: Kommt die Zuordnung in der Datenbank an, verschwindet die
 * Buchung wirklich aus „Beleg fehlt", und trägt die abweichende Zahlung
 * sichtbar die Warnung?
 *
 * Der Test legt Vertrag und Buchungen selbst an und räumt sie weg.
 */

const GESELLSCHAFT = 'Prüfhausen Rentenversicherung'
const VERTRAG = 'Prüfhausen Rente (Test)'

async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
  const db = new PrismaClient()
  try {
    return await arbeit(db)
  } finally {
    await db.$disconnect()
  }
}

async function aufraeumen(): Promise<void> {
  await mitDb(async (db) => {
    await db.buchung.deleteMany({ where: { gegenstelle: GESELLSCHAFT } })
    await db.vertrag.deleteMany({ where: { bezeichnung: VERTRAG } })
  })
}

/**
 * Sechs passende Monatsraten plus eine, die zehnmal so hoch ist.
 * Die letzte ist der eigentliche Prüffall.
 */
async function testdatenAnlegen(): Promise<void> {
  await mitDb(async (db) => {
    const betreute = await db.betreute.findMany({
      where: { geloeschtAm: null },
      select: { id: true },
    })

    for (const person of betreute) {
      const vertrag = await db.vertrag.create({
        data: {
          betreuteId: person.id,
          bezeichnung: VERTRAG,
          gesellschaft: GESELLSCHAFT,
          art: 'RENTENVERSICHERUNG_PRIVAT',
          beitragCent: 4250n,
          rhythmus: 'MONATLICH',
        },
        select: { id: true },
      })

      const konto = await db.konto.findFirst({
        where: { betreuteId: person.id, geloeschtAm: null },
        select: { id: true },
      })

      const gemeinsam = {
        betreuteId: person.id,
        kontoId: konto?.id ?? null,
        richtung: 'AUSGABE' as const,
        kategorie: 'VERSICHERUNG' as const,
        betrifftBetreute: true,
        gegenstelle: GESELLSCHAFT,
      }

      for (let monat = 1; monat <= 6; monat++) {
        await db.buchung.create({
          data: {
            ...gemeinsam,
            datum: new Date(Date.UTC(2026, monat - 1, 1)),
            betragCent: 4250n,
          },
        })
      }

      // Die Ausreißerin: schon zugeordnet, aber zehnmal so hoch.
      await db.buchung.create({
        data: {
          ...gemeinsam,
          datum: new Date(Date.UTC(2026, 6, 1)),
          betragCent: 42_500n,
          vertragId: vertrag.id,
        },
      })
    }
  })
}

test.describe('Dauerzahlungen', () => {
  test.beforeAll(async () => {
    await aufraeumen()
    await testdatenAnlegen()
  })

  test.afterAll(async () => {
    await aufraeumen()
  })

  test('ordnet alle Zahlungen einer Gruppe in einem Schritt zu', async ({ page }) => {
    await anmelden(page)
    await page.goto('/finanzen/wiederkehrend')

    // Der Vertrag liegt vor, also steht die Gruppe unter „schon zugeordnet".
    const eintrag = page.locator('li', { hasText: VERTRAG }).first()
    await expect(eintrag).toBeVisible()

    // Sechs offene Zahlungen — die siebte hängt schon am Vertrag.
    const knopf = eintrag.getByRole('button', { name: /6 Zahlungen als belegt zuordnen/ })
    await expect(knopf).toBeVisible()
    await knopf.click()

    // Die Rückmeldung ist der neue Zustand, nicht eine Meldung: Sind alle
    // Zahlungen zugeordnet, verschwindet der Knopf und die Gruppe meldet
    // sich als vollständig.
    await expect(eintrag).toContainText('Alle 7 Zahlungen sind dem Vertrag zugeordnet')
    await expect(eintrag.getByRole('button', { name: /als belegt zuordnen/ })).toHaveCount(0)
  })

  test('zeigt die Zahlungen danach als durch Vertrag belegt', async ({ page }) => {
    await anmelden(page)
    await page.goto('/finanzen/buchungen')

    const zeilen = page.locator('tr', { hasText: GESELLSCHAFT })
    await expect(zeilen.first()).toBeVisible()

    // Die passenden Raten gelten als belegt …
    await expect(page.getByText('durch Vertrag belegt').first()).toBeVisible()
    // … und keine davon steht mehr als „Beleg fehlt".
    const zeileMitFehlt = page.locator('tr', { hasText: GESELLSCHAFT }).filter({
      hasText: 'Beleg fehlt',
    })
    await expect(zeileMitFehlt).toHaveCount(0)
  })

  test('markiert die abweichende Zahlung zur Prüfung, statt sie durchzuwinken', async ({
    page,
  }) => {
    // Die Zusage, auf der alles steht: Die Zuordnung darf keine Hintertür
    // sein, durch die eine verzehnfachte Prämie unbemerkt als belegt gilt.
    await anmelden(page)
    await page.goto('/finanzen/buchungen')

    const ausreisser = page.locator('tr', { hasText: '425,00' })
    await expect(ausreisser).toContainText('Betrag prüfen')
  })

  test('nimmt die Zuordnung aus der Kachel auf „Heute“ heraus', async ({ page }) => {
    await anmelden(page)
    await page.goto('/heute')

    // Die sechs zugeordneten Zahlungen dürfen dort nicht mehr auftauchen.
    const kachel = page.locator('section, div').filter({ hasText: 'Unverbuchte Belege' }).last()
    await expect(kachel).not.toContainText(GESELLSCHAFT)
  })

  test('fällt zurück in „Beleg fehlt“, wenn der Vertrag verschwindet', async ({ page }) => {
    // Ein Nachweis, der auf etwas zeigt, das es nicht mehr gibt, wäre
    // schlimmer als gar keiner.
    await mitDb(async (db) => {
      await db.vertrag.deleteMany({ where: { bezeichnung: VERTRAG } })
    })

    await anmelden(page)
    await page.goto('/finanzen/buchungen')

    const zeilen = page.locator('tr', { hasText: GESELLSCHAFT })
    await expect(zeilen.first()).toContainText('Beleg fehlt')
  })
})