1018 lines
45 KiB
PHP
1018 lines
45 KiB
PHP
<?php
|
||
|
||
declare(strict_types=1);
|
||
|
||
use Finanzmanager\Models\AbgleichRegel;
|
||
use Finanzmanager\Models\Bankabruf;
|
||
use Finanzmanager\Models\Bankumsatz;
|
||
use Finanzmanager\Models\Bankzugang;
|
||
use Finanzmanager\Models\Buchung;
|
||
use Finanzmanager\Models\Einstellung;
|
||
use Finanzmanager\Models\Kategorie;
|
||
use Finanzmanager\Models\Konto;
|
||
use Finanzmanager\Services\Bankabgleich;
|
||
use Finanzmanager\Services\Crypto;
|
||
use Finanzmanager\Services\FinTsVerfahren;
|
||
|
||
/**
|
||
* Online-Banking ohne Bank: Geprüft wird alles, was um den FinTS-Dialog herum
|
||
* liegt – Verschlüsselung, Zeiträume, Dublettenerkennung, Regeln und der
|
||
* Abgleich. Der Dialog selbst braucht eine echte Bankverbindung und lässt sich
|
||
* hier nicht nachstellen.
|
||
*/
|
||
class BankingTest extends TestCase
|
||
{
|
||
protected string $testName = 'Test 16: Online-Banking und Abgleich';
|
||
|
||
private int $giro = 0;
|
||
private int $sparkonto = 0;
|
||
private int $strom = 0;
|
||
private int $miete = 0;
|
||
private int $zugang = 0;
|
||
|
||
public function run(): void
|
||
{
|
||
$this->mandantAnlegen();
|
||
$this->stammdaten();
|
||
|
||
$this->verschluesselungSchuetztDieZugangsdaten();
|
||
$this->zugangHaeltPinBeimSpeichern();
|
||
$this->tanVerfahrenLaesstSichWaehlen();
|
||
$this->tanVerfahrenUeberstehtDasSpeichern();
|
||
$this->zeitraumRichtetSichNachDemLetztenAbruf();
|
||
$this->stichtagBestimmtDenAbrufbeginn();
|
||
$this->umsaetzeKommenNurEinmalHerein();
|
||
$this->regelnGreifenNachPrioritaet();
|
||
$this->regelnRechnenSplitsAus();
|
||
$this->splitsHaltenDasVerhaeltnis();
|
||
$this->ungueltigesMusterWirdAbgewiesen();
|
||
$this->abgleichFindetVorhandeneBuchung();
|
||
$this->umbuchungWirdAuchVonDerGegenkontoseiteErkannt();
|
||
$this->uebernehmenErzeugtEineBuchung();
|
||
$this->regelmitSplitsErzeugtEineSplitbuchung();
|
||
$this->buchungOhneKategorieWirdGefunden();
|
||
$this->regelnKategorisierenBuchungenOhneKategorie();
|
||
$this->verwerfenUndZuruecksetzen();
|
||
$this->abrufprotokollHaeltDenVerlauf();
|
||
}
|
||
|
||
private function stammdaten(): void
|
||
{
|
||
$this->giro = Konto::anlegen([
|
||
'name' => 'Bankinggiro', 'kontoart' => 'bank', 'anfangssaldo' => 500,
|
||
'aktiv' => 1, 'iban' => 'DE02120300000000202051',
|
||
]);
|
||
$this->sparkonto = Konto::anlegen([
|
||
'name' => 'Bankingsparbuch', 'kontoart' => 'sparkonto', 'anfangssaldo' => 0, 'aktiv' => 1,
|
||
]);
|
||
|
||
$this->strom = Kategorie::findenOderAnlegenNachPfad('300 - Wohnen:Strom', 'ausgabe');
|
||
$this->miete = Kategorie::findenOderAnlegenNachPfad('300 - Wohnen:Miete', 'ausgabe');
|
||
|
||
$this->zugang = Bankzugang::anlegen([
|
||
'name' => 'Testbank',
|
||
'bankname' => 'Testbank AG',
|
||
'blz' => '12030000',
|
||
'fints_url' => 'https://banking.example.org/fints',
|
||
'benutzerkennung' => 'testkunde',
|
||
'pin' => 'geheim1234',
|
||
'abrufzeitraum' => 'letzter_abruf',
|
||
'aktiv' => 1,
|
||
]);
|
||
}
|
||
|
||
/** @param array<string,mixed> $daten */
|
||
private function umsatzAnlegen(array $daten): ?int
|
||
{
|
||
return Bankumsatz::anlegen([
|
||
'zugang_id' => $this->zugang,
|
||
// array_key_exists, nicht ??: Ein ausdrückliches null steht hier für
|
||
// „kein Konto zugeordnet“ und darf nicht auf das Giro zurückfallen.
|
||
'konto_id' => array_key_exists('konto_id', $daten) ? $daten['konto_id'] : $this->giro,
|
||
// Dieser Test kennt kein Bankkonto – die Umsätze müssen nur
|
||
// untereinander eindeutig sein, dafür reicht eine feste Kennung.
|
||
'extern_id' => $daten['extern_id'] ?? Bankumsatz::externId(
|
||
1,
|
||
(string)$daten['buchungstag'],
|
||
(float)$daten['betrag'],
|
||
(string)($daten['verwendungszweck'] ?? ''),
|
||
(string)($daten['empfaenger'] ?? '')
|
||
),
|
||
'buchungstag' => $daten['buchungstag'],
|
||
'wertstellung' => $daten['buchungstag'],
|
||
'betrag' => $daten['betrag'],
|
||
'empfaenger' => $daten['empfaenger'] ?? '',
|
||
'verwendungszweck' => $daten['verwendungszweck'] ?? '',
|
||
'buchungsart' => 'LASTSCHRIFT',
|
||
]);
|
||
}
|
||
|
||
private function verschluesselungSchuetztDieZugangsdaten(): void
|
||
{
|
||
if (!Crypto::einsatzbereit()) {
|
||
$this->assert(false, 'APP_KEY fehlt – ohne ihn lässt sich die Verschlüsselung nicht prüfen');
|
||
return;
|
||
}
|
||
|
||
$geheim = Crypto::verschluessle('meine-pin-1234');
|
||
|
||
$this->assert(Crypto::istVerschluesselt($geheim), 'Der Geheimtext trägt seine Kennung');
|
||
$this->assert(!str_contains($geheim, 'meine-pin'), 'Die PIN steht nicht im Klartext darin');
|
||
$this->assertEquals('meine-pin-1234', Crypto::entschluessle($geheim), 'Und kommt unverändert zurück');
|
||
|
||
// Zweimal dasselbe verschlüsselt ergibt zwei verschiedene Geheimtexte –
|
||
// jeder Durchgang zieht einen neuen Initialisierungsvektor.
|
||
$this->assert(
|
||
Crypto::verschluessle('meine-pin-1234') !== $geheim,
|
||
'Gleicher Klartext, anderer Geheimtext'
|
||
);
|
||
|
||
$this->assertEquals('', Crypto::verschluessle(''), 'Leeres bleibt leer');
|
||
$this->assertEquals(
|
||
'klartext-aus-altbestand',
|
||
Crypto::entschluessle('klartext-aus-altbestand'),
|
||
'Werte ohne Kennung werden durchgereicht'
|
||
);
|
||
|
||
$doppelt = Crypto::verschluessle($geheim);
|
||
$this->assertEquals($geheim, $doppelt, 'Zweimal verschlüsseln verschachtelt nicht');
|
||
}
|
||
|
||
private function zugangHaeltPinBeimSpeichern(): void
|
||
{
|
||
$roh = Bankzugang::find($this->zugang);
|
||
$this->assert(
|
||
!str_contains((string)$roh['pin'], 'geheim1234'),
|
||
'In der Datenbank steht die PIN nur verschlüsselt'
|
||
);
|
||
|
||
$mitPin = Bankzugang::zugangsdaten($this->zugang);
|
||
$this->assertEquals('geheim1234', $mitPin['pin'], 'Der Abrufdienst bekommt sie im Klartext');
|
||
|
||
// Ein leeres PIN-Feld heißt „unverändert“ – sonst verlöre jedes
|
||
// Speichern des Formulars die Zugangsdaten.
|
||
Bankzugang::speichern($this->zugang, [
|
||
'name' => 'Testbank',
|
||
'blz' => '12030000',
|
||
'fints_url' => 'https://banking.example.org/fints',
|
||
'benutzerkennung' => 'testkunde',
|
||
'pin' => '',
|
||
'abrufzeitraum' => 'sieben_tage',
|
||
'aktiv' => 1,
|
||
]);
|
||
|
||
$nachher = Bankzugang::zugangsdaten($this->zugang);
|
||
$this->assertEquals('geheim1234', $nachher['pin'], 'Leeres Feld behält die alte PIN');
|
||
$this->assertEquals('sieben_tage', $nachher['abrufzeitraum'], 'Der Zeitraum wurde übernommen');
|
||
|
||
$fehler = false;
|
||
try {
|
||
Bankzugang::speichern($this->zugang, [
|
||
'name' => 'Testbank', 'fints_url' => 'http://unverschluesselt.example.org',
|
||
]);
|
||
} catch (\InvalidArgumentException) {
|
||
$fehler = true;
|
||
}
|
||
$this->assert($fehler, 'Eine FinTS-Adresse ohne https wird abgewiesen');
|
||
|
||
Bankzugang::speichern($this->zugang, [
|
||
'name' => 'Testbank',
|
||
'blz' => '12030000',
|
||
'fints_url' => 'https://banking.example.org/fints',
|
||
'benutzerkennung' => 'testkunde',
|
||
'pin' => '',
|
||
'abrufzeitraum' => 'letzter_abruf',
|
||
'aktiv' => 1,
|
||
]);
|
||
}
|
||
|
||
/**
|
||
* Die Wahl des TAN-Verfahrens. Die Abfrage bei der Bank lässt sich hier
|
||
* nicht nachstellen – geprüft wird, was mit ihrem Ergebnis geschieht.
|
||
*/
|
||
private function tanVerfahrenLaesstSichWaehlen(): void
|
||
{
|
||
// So sieht eine abgefragte Liste aus.
|
||
$angebot = [
|
||
['id' => 913, 'name' => 'chipTAN QR', 'entkoppelt' => false,
|
||
'medium_noetig' => true, 'medien' => ['Karte 1', 'Karte 2'], 'hinweis' => ''],
|
||
['id' => 921, 'name' => 'pushTAN 2.0', 'entkoppelt' => true,
|
||
'medium_noetig' => false, 'medien' => [], 'hinweis' => ''],
|
||
];
|
||
|
||
FinTsVerfahren::uebernehmen($this->zugang, 913, 'Karte 2', $angebot);
|
||
|
||
$zugang = Bankzugang::zugangsdaten($this->zugang);
|
||
$this->assertEquals(913, (int)$zugang['tan_verfahren_id'], 'Die Kennung ist gespeichert');
|
||
$this->assertEquals('chipTAN QR', $zugang['tan_verfahren_name'], 'Der Name steht daneben');
|
||
$this->assertEquals('Karte 2', $zugang['tan_medium'], 'Das gewählte Medium ist gespeichert');
|
||
|
||
$roh = Bankzugang::find($this->zugang);
|
||
$this->assert(
|
||
!str_contains((string)$roh['tan_medium'], 'Karte 2'),
|
||
'Das TAN-Medium steht verschlüsselt in der Datenbank'
|
||
);
|
||
|
||
// Ein Verfahren, das die Bank nicht angeboten hat, wäre beim nächsten
|
||
// Abruf wirkungslos – also gleich abweisen.
|
||
$this->assert(
|
||
$this->wirftFehler(fn() => FinTsVerfahren::uebernehmen($this->zugang, 942, '', $angebot)),
|
||
'Eine unbekannte Verfahrenskennung wird abgewiesen'
|
||
);
|
||
|
||
$this->assert(
|
||
$this->wirftFehler(fn() => FinTsVerfahren::uebernehmen($this->zugang, 913, '', $angebot)),
|
||
'Ein Verfahren mit Medienzwang braucht ein Medium'
|
||
);
|
||
|
||
$this->assert(
|
||
$this->wirftFehler(fn() => FinTsVerfahren::uebernehmen($this->zugang, 913, 'Karte 9', $angebot)),
|
||
'Ein Medium, das die Bank nicht genannt hat, wird abgewiesen'
|
||
);
|
||
|
||
// Braucht das Verfahren kein Medium, wird ein mitgeschicktes verworfen:
|
||
// Manche Banken lehnen den Dialog ab, wenn eins dabei ist.
|
||
FinTsVerfahren::uebernehmen($this->zugang, 921, 'Karte 2', $angebot);
|
||
$zugang = Bankzugang::zugangsdaten($this->zugang);
|
||
$this->assertEquals(921, (int)$zugang['tan_verfahren_id'], 'Das entkoppelte Verfahren ist gewählt');
|
||
$this->assertEquals('', $zugang['tan_medium'], 'Ohne Medienzwang bleibt das Medium leer');
|
||
|
||
// Ohne vollständige Zugangsdaten wird die Bank gar nicht erst gefragt.
|
||
$ergebnis = FinTsVerfahren::abfragen(0);
|
||
$this->assertEquals('fehler', $ergebnis['status'], 'Ein unbekannter Zugang liefert einen Fehler');
|
||
$this->assertEquals([], $ergebnis['verfahren'], 'Und keine Liste');
|
||
|
||
FinTsVerfahren::uebernehmen($this->zugang, 913, 'Karte 1', $angebot);
|
||
}
|
||
|
||
/**
|
||
* Das Verfahren steht nicht im Zugangsformular. Ohne Vorbehalt setzte jedes
|
||
* Speichern die Wahl zurück – und der nächste Abruf verlangte wieder das
|
||
* falsche Verfahren.
|
||
*/
|
||
private function tanVerfahrenUeberstehtDasSpeichern(): void
|
||
{
|
||
Bankzugang::speichern($this->zugang, [
|
||
'name' => 'Testbank',
|
||
'blz' => '12030000',
|
||
'fints_url' => 'https://banking.example.org/fints',
|
||
'benutzerkennung' => 'testkunde',
|
||
'pin' => '',
|
||
'abrufzeitraum' => 'letzter_abruf',
|
||
'aktiv' => 1,
|
||
]);
|
||
|
||
$zugang = Bankzugang::zugangsdaten($this->zugang);
|
||
$this->assertEquals(913, (int)$zugang['tan_verfahren_id'], 'Das Speichern lässt die Kennung stehen');
|
||
$this->assertEquals('chipTAN QR', $zugang['tan_verfahren_name'], 'Und den Namen');
|
||
$this->assertEquals('Karte 1', $zugang['tan_medium'], 'Und das Medium');
|
||
}
|
||
|
||
/** Hilfsmittel: Wirft der Aufruf eine Ausnahme? */
|
||
private function wirftFehler(callable $aufruf): bool
|
||
{
|
||
try {
|
||
$aufruf();
|
||
} catch (\Throwable) {
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private function zeitraumRichtetSichNachDemLetztenAbruf(): void
|
||
{
|
||
$heute = new \DateTimeImmutable('2026-08-11');
|
||
|
||
[$von] = Bankzugang::startdatum('sieben_tage', null, $heute);
|
||
$this->assertEquals('2026-08-04', $von->format('Y-m-d'), 'Sieben Tage zurück');
|
||
|
||
[$von] = Bankzugang::startdatum('dreissig_tage', null, $heute);
|
||
$this->assertEquals('2026-07-12', $von->format('Y-m-d'), 'Dreißig Tage zurück');
|
||
|
||
[$von, $text] = Bankzugang::startdatum('letzter_abruf', '2026-08-09 22:15:00', $heute);
|
||
$this->assertEquals('2026-08-09', $von->format('Y-m-d'), 'Ab dem Tag des letzten Abrufs');
|
||
$this->assert(str_contains($text, '09.08.2026'), 'Und sagt es auch');
|
||
|
||
// Ohne vorherigen Abruf muss ein sinnvoller Anfang her, sonst käme
|
||
// entweder nichts oder alles.
|
||
[$von] = Bankzugang::startdatum('letzter_abruf', null, $heute);
|
||
$this->assertEquals('2025-08-11', $von->format('Y-m-d'), 'Beim ersten Mal ein Jahr zurück');
|
||
|
||
[$von] = Bankzugang::startdatum('quatsch', null, $heute);
|
||
$this->assertEquals('2025-08-11', $von->format('Y-m-d'), 'Unbekannte Vorgabe fällt zurück');
|
||
}
|
||
|
||
/**
|
||
* Der Stichtag: als Vorgabe des Zugangs und als einmalige Angabe beim Abruf.
|
||
*
|
||
* Die einmalige Angabe darf die gespeicherte Einstellung weder verwenden noch
|
||
* verändern – sonst wäre der nächste reguläre Abruf ein anderer als gedacht.
|
||
*/
|
||
private function stichtagBestimmtDenAbrufbeginn(): void
|
||
{
|
||
$heute = new \DateTimeImmutable('2026-08-11');
|
||
|
||
[$von, $text] = Bankzugang::startdatum('stichtag', null, $heute, '2026-01-01');
|
||
$this->assertEquals('2026-01-01', $von->format('Y-m-d'), 'Ab dem Stichtag');
|
||
$this->assert(str_contains($text, '01.01.2026'), 'Und das Protokoll sagt es');
|
||
|
||
// Aus der Zukunft liefert keine Bank etwas.
|
||
[$von] = Bankzugang::startdatum('stichtag', null, $heute, '2027-03-01');
|
||
$this->assertEquals('2026-08-11', $von->format('Y-m-d'), 'Ein Stichtag in der Zukunft wird auf heute gesetzt');
|
||
|
||
// Ohne brauchbares Datum bleibt nur die Regel ohne Vorgabe.
|
||
[$von] = Bankzugang::startdatum('stichtag', '2026-08-09 22:15:00', $heute, '');
|
||
$this->assertEquals('2026-08-09', $von->format('Y-m-d'), 'Ohne Datum wie „seit dem letzten Abruf“');
|
||
|
||
$this->assertNull(Bankzugang::stichtagDatum('31.02.2026'), 'Den 31. Februar gibt es nicht');
|
||
$this->assertNull(Bankzugang::stichtagDatum('irgendwann'), 'Text ist kein Datum');
|
||
$this->assertEquals(
|
||
'2026-08-13',
|
||
Bankzugang::stichtagDatum('13.08.2026')?->format('Y-m-d'),
|
||
'Auch die deutsche Schreibweise wird gelesen'
|
||
);
|
||
|
||
// Die Vorgabe des Zugangs …
|
||
Bankzugang::speichern($this->zugang, [
|
||
'name' => 'Testbank',
|
||
'blz' => '12030000',
|
||
'fints_url' => 'https://banking.example.org/fints',
|
||
'benutzerkennung' => 'testkunde',
|
||
'pin' => '',
|
||
'abrufzeitraum' => 'stichtag',
|
||
'abruf_stichtag' => '2026-01-01',
|
||
'aktiv' => 1,
|
||
]);
|
||
|
||
$zugang = Bankzugang::find($this->zugang);
|
||
$this->assertEquals('2026-01-01', (string)$zugang['abruf_stichtag'], 'Der Stichtag wurde gespeichert');
|
||
|
||
[$von] = Bankzugang::abrufBeginn($zugang, null, $heute);
|
||
$this->assertEquals('2026-01-01', $von->format('Y-m-d'), 'Der gespeicherte Stichtag gilt');
|
||
|
||
// … und die einmalige Angabe, die ihr vorgeht.
|
||
[$von] = Bankzugang::abrufBeginn($zugang, '2026-07-01', $heute);
|
||
$this->assertEquals('2026-07-01', $von->format('Y-m-d'), 'Der Stichtag des Laufs geht vor');
|
||
|
||
$this->assertEquals(
|
||
'2026-01-01',
|
||
(string)Bankzugang::find($this->zugang)['abruf_stichtag'],
|
||
'Und lässt die gespeicherte Vorgabe stehen'
|
||
);
|
||
|
||
$this->assert(
|
||
$this->wirftFehler(fn() => Bankzugang::speichern($this->zugang, [
|
||
'name' => 'Testbank',
|
||
'blz' => '12030000',
|
||
'fints_url' => 'https://banking.example.org/fints',
|
||
'benutzerkennung' => 'testkunde',
|
||
'pin' => '',
|
||
'abrufzeitraum' => 'stichtag',
|
||
'abruf_stichtag' => '',
|
||
'aktiv' => 1,
|
||
])),
|
||
'„Ab Stichtag“ ohne Datum wird abgewiesen'
|
||
);
|
||
|
||
// Zurück auf die Vorgabe – die folgenden Prüfungen rechnen damit.
|
||
Bankzugang::speichern($this->zugang, [
|
||
'name' => 'Testbank',
|
||
'blz' => '12030000',
|
||
'fints_url' => 'https://banking.example.org/fints',
|
||
'benutzerkennung' => 'testkunde',
|
||
'pin' => '',
|
||
'abrufzeitraum' => 'letzter_abruf',
|
||
'aktiv' => 1,
|
||
]);
|
||
}
|
||
|
||
private function umsaetzeKommenNurEinmalHerein(): void
|
||
{
|
||
$erste = $this->umsatzAnlegen([
|
||
'buchungstag' => '2026-08-03', 'betrag' => -84.20,
|
||
'empfaenger' => 'Stadtwerke Musterstadt', 'verwendungszweck' => 'Abschlag Strom 08/2026',
|
||
]);
|
||
|
||
$this->assertNotEmpty($erste, 'Der Umsatz wurde angelegt');
|
||
|
||
$zweite = $this->umsatzAnlegen([
|
||
'buchungstag' => '2026-08-03', 'betrag' => -84.20,
|
||
'empfaenger' => 'Stadtwerke Musterstadt', 'verwendungszweck' => 'Abschlag Strom 08/2026',
|
||
]);
|
||
|
||
$this->assertNull($zweite, 'Derselbe Umsatz kommt beim nächsten Abruf nicht noch einmal herein');
|
||
|
||
// Ein anderer Betrag ist ein anderer Umsatz, auch am selben Tag.
|
||
$dritte = $this->umsatzAnlegen([
|
||
'buchungstag' => '2026-08-03', 'betrag' => -12.00,
|
||
'empfaenger' => 'Stadtwerke Musterstadt', 'verwendungszweck' => 'Abschlag Strom 08/2026',
|
||
]);
|
||
$this->assertNotEmpty($dritte, 'Anderer Betrag, anderer Umsatz');
|
||
|
||
$this->assertEquals(2, Bankumsatz::anzahlOffen(), 'Zwei offene Umsätze');
|
||
}
|
||
|
||
private function regelnGreifenNachPrioritaet(): void
|
||
{
|
||
// Die unspezifische Regel hat die schlechtere Priorität und darf der
|
||
// genaueren nicht dazwischenkommen.
|
||
AbgleichRegel::anlegen([
|
||
'name' => 'Wohnen allgemein', 'feld' => 'beides', 'vergleich' => 'enthaelt',
|
||
'muster' => 'stadtwerke', 'kategorie_id' => $this->miete, 'prioritaet' => 200, 'aktiv' => 1,
|
||
]);
|
||
AbgleichRegel::anlegen([
|
||
'name' => 'Strom', 'feld' => 'verwendungszweck', 'vergleich' => 'enthaelt',
|
||
'muster' => 'Strom', 'kategorie_id' => $this->strom, 'prioritaet' => 10, 'aktiv' => 1,
|
||
]);
|
||
|
||
$umsatz = [
|
||
'empfaenger' => 'Stadtwerke Musterstadt',
|
||
'verwendungszweck' => 'Abschlag Strom 08/2026',
|
||
'betrag' => -84.20,
|
||
];
|
||
|
||
$regel = AbgleichRegel::passendeRegel($umsatz);
|
||
$this->assertNotEmpty($regel, 'Eine Regel passt');
|
||
$this->assertEquals('Strom', $regel['name'], 'Die mit der besseren Priorität gewinnt');
|
||
|
||
// Groß- und Kleinschreibung darf nicht entscheiden: Banken schreiben
|
||
// denselben Empfänger mal so, mal so.
|
||
$this->assertNotEmpty(
|
||
AbgleichRegel::passendeRegel(['empfaenger' => 'STADTWERKE MUSTERSTADT', 'verwendungszweck' => '', 'betrag' => -1]),
|
||
'Versalien treffen genauso'
|
||
);
|
||
|
||
// Das Feld schränkt ein: „nur Empfänger“ sieht den Verwendungszweck nicht.
|
||
$nurEmpfaenger = AbgleichRegel::anlegen([
|
||
'name' => 'Nur Empfänger', 'feld' => 'empfaenger', 'vergleich' => 'enthaelt',
|
||
'muster' => 'Abschlag', 'kategorie_id' => $this->miete, 'prioritaet' => 1, 'aktiv' => 1,
|
||
]);
|
||
$this->assertEquals(
|
||
'Strom',
|
||
AbgleichRegel::passendeRegel($umsatz)['name'],
|
||
'Ein Muster im falschen Feld greift nicht'
|
||
);
|
||
AbgleichRegel::loeschen($nurEmpfaenger);
|
||
|
||
// Betragsgrenzen rechnen mit Vorzeichen.
|
||
$grenze = AbgleichRegel::anlegen([
|
||
'name' => 'Kleine Beträge', 'feld' => 'beides', 'vergleich' => 'enthaelt',
|
||
'muster' => 'stadtwerke', 'betrag_von' => -20, 'betrag_bis' => 0,
|
||
'kategorie_id' => $this->miete, 'prioritaet' => 1, 'aktiv' => 1,
|
||
]);
|
||
$this->assertEquals(
|
||
'Strom',
|
||
AbgleichRegel::passendeRegel($umsatz)['name'],
|
||
'−84,20 liegt außerhalb von −20 bis 0'
|
||
);
|
||
$this->assertEquals(
|
||
'Kleine Beträge',
|
||
AbgleichRegel::passendeRegel(['empfaenger' => 'Stadtwerke', 'verwendungszweck' => '', 'betrag' => -12.0])['name'],
|
||
'−12,00 liegt darin'
|
||
);
|
||
AbgleichRegel::loeschen($grenze);
|
||
|
||
// Eine abgeschaltete Regel greift nicht mehr.
|
||
$regeln = AbgleichRegel::alle();
|
||
foreach ($regeln as $eintrag) {
|
||
if ($eintrag['name'] === 'Strom') {
|
||
AbgleichRegel::speichern((int)$eintrag['id'], [
|
||
'name' => 'Strom', 'feld' => 'verwendungszweck', 'vergleich' => 'enthaelt',
|
||
'muster' => 'Strom', 'kategorie_id' => $this->strom, 'prioritaet' => 10, 'aktiv' => 0,
|
||
]);
|
||
}
|
||
}
|
||
$this->assertEquals(
|
||
'Wohnen allgemein',
|
||
AbgleichRegel::passendeRegel($umsatz)['name'],
|
||
'Abgeschaltet rückt die nächste Regel nach'
|
||
);
|
||
|
||
foreach (AbgleichRegel::alle() as $eintrag) {
|
||
if ($eintrag['name'] === 'Strom') {
|
||
AbgleichRegel::speichern((int)$eintrag['id'], [
|
||
'name' => 'Strom', 'feld' => 'verwendungszweck', 'vergleich' => 'enthaelt',
|
||
'muster' => 'Strom', 'kategorie_id' => $this->strom, 'prioritaet' => 10, 'aktiv' => 1,
|
||
]);
|
||
}
|
||
}
|
||
}
|
||
|
||
private function regelnRechnenSplitsAus(): void
|
||
{
|
||
$id = AbgleichRegel::anlegen([
|
||
'name' => 'Geteilte Rechnung',
|
||
'feld' => 'empfaenger',
|
||
'vergleich' => 'beginnt',
|
||
'muster' => 'Vermieter',
|
||
'splits' => [
|
||
['kategorie_id' => $this->miete, 'anteil' => 0.6667],
|
||
['kategorie_id' => $this->strom, 'anteil' => 0.3333],
|
||
],
|
||
'prioritaet' => 5,
|
||
'aktiv' => 1,
|
||
]);
|
||
|
||
$regel = AbgleichRegel::find($id);
|
||
$umsatz = ['empfaenger' => 'Vermieter Meier', 'verwendungszweck' => 'Miete', 'betrag' => -1000.00];
|
||
|
||
$this->assert(AbgleichRegel::passt($regel, $umsatz), '„beginnt mit“ trifft');
|
||
$this->assert(
|
||
!AbgleichRegel::passt($regel, ['empfaenger' => 'Der Vermieter', 'verwendungszweck' => '', 'betrag' => -1]),
|
||
'Aber nicht mitten im Text'
|
||
);
|
||
|
||
$zuordnung = AbgleichRegel::anwenden($regel, $umsatz);
|
||
$this->assertEquals(2, count($zuordnung['splits']), 'Zwei Splitzeilen');
|
||
$this->assertEquals(-666.70, $zuordnung['splits'][0]['betrag'], 'Erste Zeile nach Anteil');
|
||
|
||
// Die letzte Zeile bekommt den Rest – sonst ginge bei krummen Anteilen
|
||
// ein Cent verloren und die Buchung ließe sich nicht speichern.
|
||
$summe = array_sum(array_column($zuordnung['splits'], 'betrag'));
|
||
$this->assertEquals(-1000.00, round($summe, 2), 'Die Splits ergeben den Buchungsbetrag');
|
||
|
||
AbgleichRegel::loeschen($id);
|
||
}
|
||
|
||
/**
|
||
* Der eigentliche Zweck des Schemas: Dieselbe Regel trifft bei jedem
|
||
* Buchungsbetrag dasselbe Verhältnis. Und die Anteile gelten zueinander –
|
||
* 60 zu 30 sind zwei Drittel zu einem Drittel, nicht 60 Prozent und ein
|
||
* Rest von 40.
|
||
*/
|
||
private function splitsHaltenDasVerhaeltnis(): void
|
||
{
|
||
$id = AbgleichRegel::anlegen([
|
||
'name' => 'Nebenkosten geteilt',
|
||
'feld' => 'empfaenger',
|
||
'vergleich' => 'enthaelt',
|
||
'muster' => 'Hausverwaltung',
|
||
'splits' => [
|
||
['kategorie_id' => $this->miete, 'anteil' => 0.60],
|
||
['kategorie_id' => $this->strom, 'anteil' => 0.30],
|
||
],
|
||
'aktiv' => 1,
|
||
]);
|
||
|
||
$regel = AbgleichRegel::find($id);
|
||
|
||
$klein = AbgleichRegel::anwenden($regel, ['empfaenger' => 'Hausverwaltung', 'betrag' => -300.00]);
|
||
$this->assertEquals(-200.00, $klein['splits'][0]['betrag'], 'Zwei Drittel von 300');
|
||
$this->assertEquals(-100.00, $klein['splits'][1]['betrag'], 'Ein Drittel von 300');
|
||
|
||
// Derselbe Schlüssel bei anderer Rechnungshöhe: Das Verhältnis bleibt.
|
||
$gross = AbgleichRegel::anwenden($regel, ['empfaenger' => 'Hausverwaltung', 'betrag' => -450.00]);
|
||
$this->assertEquals(-300.00, $gross['splits'][0]['betrag'], 'Zwei Drittel von 450');
|
||
$this->assertEquals(-150.00, $gross['splits'][1]['betrag'], 'Ein Drittel von 450');
|
||
|
||
// Auch ein Guthaben – eine Rückzahlung der Nebenkosten – wird geteilt.
|
||
$zurueck = AbgleichRegel::anwenden($regel, ['empfaenger' => 'Hausverwaltung', 'betrag' => 90.00]);
|
||
$this->assertEquals(60.00, $zurueck['splits'][0]['betrag'], 'Erstattung nach demselben Schlüssel');
|
||
$this->assertEquals(
|
||
90.00,
|
||
round(array_sum(array_column($zurueck['splits'], 'betrag')), 2),
|
||
'Auch hier ergeben die Zeilen den Buchungsbetrag'
|
||
);
|
||
|
||
// Was die Oberfläche zum Bearbeiten zurückbekommt, ist wieder Prozent.
|
||
$zeilen = AbgleichRegel::splitzeilen($regel);
|
||
$this->assertEquals(2, count($zeilen), 'Zwei Zeilen für das Formular');
|
||
$this->assertEquals(60.0, $zeilen[0]['prozent'], 'Der Anteil steht als Prozentwert');
|
||
$this->assertEquals($this->strom, $zeilen[1]['kategorie_id'], 'Mit seiner Kategorie');
|
||
|
||
AbgleichRegel::loeschen($id);
|
||
}
|
||
|
||
private function ungueltigesMusterWirdAbgewiesen(): void
|
||
{
|
||
$this->assert(
|
||
!AbgleichRegel::musterIstGueltig('regex', 'Miete('),
|
||
'Eine offene Klammer ist kein gültiger Ausdruck'
|
||
);
|
||
$this->assert(
|
||
AbgleichRegel::musterIstGueltig('regex', 'Miete|Nebenkosten'),
|
||
'Eine Alternative schon'
|
||
);
|
||
|
||
$fehler = false;
|
||
try {
|
||
AbgleichRegel::anlegen([
|
||
'name' => 'Kaputt', 'feld' => 'beides', 'vergleich' => 'regex',
|
||
'muster' => 'Miete(', 'aktiv' => 1,
|
||
]);
|
||
} catch (\InvalidArgumentException) {
|
||
$fehler = true;
|
||
}
|
||
$this->assert($fehler, 'Und wird gar nicht erst gespeichert');
|
||
|
||
$id = AbgleichRegel::anlegen([
|
||
'name' => 'Ausdruck', 'feld' => 'verwendungszweck', 'vergleich' => 'regex',
|
||
'muster' => 'Strom|Gas', 'kategorie_id' => $this->strom, 'prioritaet' => 50, 'aktiv' => 1,
|
||
]);
|
||
$this->assert(
|
||
AbgleichRegel::passt(
|
||
AbgleichRegel::find($id),
|
||
['empfaenger' => '', 'verwendungszweck' => 'Abschlag Gas 2026', 'betrag' => -50]
|
||
),
|
||
'Der reguläre Ausdruck trifft die Alternative'
|
||
);
|
||
AbgleichRegel::loeschen($id);
|
||
}
|
||
|
||
private function abgleichFindetVorhandeneBuchung(): void
|
||
{
|
||
Einstellung::set('banking_abgleich_tage', '5', 'banking');
|
||
|
||
// Von Hand erfasst, drei Tage vor dem Banktag – der Normalfall.
|
||
$buchungId = Buchung::anlegen([
|
||
'konto_id' => $this->giro, 'datum' => '2026-08-01', 'betrag' => -84.20,
|
||
'empfaenger' => 'Stadtwerke', 'kategorie_id' => $this->strom,
|
||
]);
|
||
|
||
$umsatz = Bankumsatz::liste(['status' => 'offen'])[0];
|
||
// Die Liste ist absteigend sortiert; gesucht ist der über 84,20.
|
||
foreach (Bankumsatz::liste(['status' => 'offen']) as $eintrag) {
|
||
if (abs((float)$eintrag['betrag'] + 84.20) < 0.005) {
|
||
$umsatz = $eintrag;
|
||
}
|
||
}
|
||
|
||
$treffer = Bankumsatz::passendeBuchung($umsatz);
|
||
$this->assertNotEmpty($treffer, 'Die vorhandene Buchung wird gefunden');
|
||
$this->assertEquals($buchungId, (int)$treffer['id'], 'Und zwar genau sie');
|
||
|
||
$vorschlag = Bankumsatz::vorschlag($umsatz);
|
||
$this->assertEquals('verbinden', $vorschlag['art'], 'Der Vorschlag lautet: verbinden');
|
||
|
||
// Außerhalb der Toleranz zählt sie nicht mehr.
|
||
Einstellung::set('banking_abgleich_tage', '1', 'banking');
|
||
$this->assertNull(
|
||
Bankumsatz::passendeBuchung($umsatz),
|
||
'Mit einem Tag Toleranz liegen drei Tage zu weit auseinander'
|
||
);
|
||
Einstellung::set('banking_abgleich_tage', '5', 'banking');
|
||
|
||
// Ein anderer Betrag passt nie.
|
||
$this->assertNull(
|
||
Bankumsatz::passendeBuchung(['konto_id' => $this->giro, 'buchungstag' => '2026-08-03', 'betrag' => -99.99, 'id' => 0]),
|
||
'Ein anderer Betrag ist eine andere Buchung'
|
||
);
|
||
|
||
Bankumsatz::verbinden((int)$umsatz['id'], $buchungId);
|
||
|
||
$nachher = Bankumsatz::find((int)$umsatz['id']);
|
||
$this->assertEquals('uebernommen', $nachher['status'], 'Der Umsatz gilt als erledigt');
|
||
$this->assertEquals($buchungId, (int)$nachher['buchung_id'], 'Und zeigt auf die Buchung');
|
||
$this->assertEquals(
|
||
1,
|
||
(int)Buchung::find($buchungId)['abgeglichen'],
|
||
'Die Buchung ist jetzt abgeglichen'
|
||
);
|
||
|
||
// Eine schon verbundene Buchung darf kein zweiter Umsatz greifen.
|
||
$zweiter = $this->umsatzAnlegen([
|
||
'buchungstag' => '2026-08-04', 'betrag' => -84.20,
|
||
'empfaenger' => 'Stadtwerke Musterstadt', 'verwendungszweck' => 'Zweite Lastschrift',
|
||
]);
|
||
$this->assertNull(
|
||
Bankumsatz::passendeBuchung(Bankumsatz::find((int)$zweiter)),
|
||
'Eine bereits verbundene Buchung wird nicht noch einmal vorgeschlagen'
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Eine Umbuchung gehört ihrem Ursprungskonto – hier dem Giro. Der
|
||
* Kontoauszug des Gegenkontos (Sparbuch) muss sie trotzdem finden, sonst
|
||
* bucht der automatische Abgleich sie dort ein zweites Mal.
|
||
*/
|
||
private function umbuchungWirdAuchVonDerGegenkontoseiteErkannt(): void
|
||
{
|
||
Einstellung::set('banking_abgleich_tage', '5', 'banking');
|
||
|
||
$umbuchungId = Buchung::anlegen([
|
||
'konto_id' => $this->giro, 'datum' => '2026-08-20', 'betrag' => -40.00,
|
||
'empfaenger' => 'Umbuchung Sparbuch', 'gegenkonto_id' => $this->sparkonto,
|
||
]);
|
||
|
||
// Die Bank bucht das Sparbuch erst einen Tag später – auf der
|
||
// Gegenkonto-Seite zählt der Betrag mit umgekehrtem Vorzeichen.
|
||
$umsatzId = Bankumsatz::anlegen([
|
||
'zugang_id' => $this->zugang,
|
||
'konto_id' => $this->sparkonto,
|
||
'extern_id' => 'test-gegenkonto-1',
|
||
'buchungstag' => '2026-08-21',
|
||
'wertstellung' => '2026-08-21',
|
||
'betrag' => 40.00,
|
||
'empfaenger' => 'Giro',
|
||
'buchungsart' => 'GUTSCHRIFT',
|
||
]);
|
||
$umsatz = Bankumsatz::find((int)$umsatzId);
|
||
|
||
$treffer = Bankumsatz::passendeBuchung($umsatz);
|
||
$this->assertNotEmpty($treffer, 'Die Umbuchung wird auch von der Gegenkontoseite gefunden');
|
||
$this->assertEquals($umbuchungId, (int)$treffer['id'], 'Und zwar genau sie');
|
||
|
||
$vorschlag = Bankumsatz::vorschlag($umsatz);
|
||
$this->assertEquals('verbinden', $vorschlag['art'], 'Der Vorschlag lautet: verbinden');
|
||
|
||
Bankumsatz::verbinden((int)$umsatzId, $umbuchungId);
|
||
$this->assertEquals(
|
||
1,
|
||
(int)Buchung::find($umbuchungId)['abgeglichen'],
|
||
'Die Umbuchung gilt jetzt als abgeglichen'
|
||
);
|
||
|
||
// Beide Kontoseiten gehören zur selben Umbuchung: Der Umsatz des
|
||
// Ursprungskontos findet sie, obwohl drüben schon ein Umsatz hängt.
|
||
$ursprung = Bankumsatz::anlegen([
|
||
'zugang_id' => $this->zugang,
|
||
'konto_id' => $this->giro,
|
||
'extern_id' => 'test-gegenkonto-2',
|
||
'buchungstag' => '2026-08-20',
|
||
'wertstellung' => '2026-08-20',
|
||
'betrag' => -40.00,
|
||
'empfaenger' => 'Sparbuch',
|
||
'buchungsart' => 'UEBERWEISUNG',
|
||
]);
|
||
$treffer = Bankumsatz::passendeBuchung(Bankumsatz::find((int)$ursprung));
|
||
$this->assertNotEmpty($treffer, 'Die Ursprungsseite findet die Umbuchung trotz Umsatz auf der Gegenseite');
|
||
$this->assertEquals($umbuchungId, (int)$treffer['id'], 'Und zwar dieselbe Umbuchung');
|
||
Bankumsatz::verbinden((int)$ursprung, $umbuchungId);
|
||
|
||
// Pro Kontoseite nur ein Umsatz: ein zweiter von drüben greift nicht mehr.
|
||
$doppelt = Bankumsatz::anlegen([
|
||
'zugang_id' => $this->zugang,
|
||
'konto_id' => $this->sparkonto,
|
||
'extern_id' => 'test-gegenkonto-3',
|
||
'buchungstag' => '2026-08-21',
|
||
'wertstellung' => '2026-08-21',
|
||
'betrag' => 40.00,
|
||
'empfaenger' => 'Giro',
|
||
'buchungsart' => 'GUTSCHRIFT',
|
||
]);
|
||
$this->assertNull(
|
||
Bankumsatz::passendeBuchung(Bankumsatz::find((int)$doppelt)),
|
||
'Eine Kontoseite nimmt nur einen Umsatz auf'
|
||
);
|
||
|
||
// Ein anderer Betrag auf der Gegenkontoseite passt nicht.
|
||
$this->assertNull(
|
||
Bankumsatz::passendeBuchung([
|
||
'konto_id' => $this->sparkonto, 'buchungstag' => '2026-08-21', 'betrag' => 12.34, 'id' => 0,
|
||
]),
|
||
'Ein anderer Betrag ist keine Umbuchung von drüben'
|
||
);
|
||
}
|
||
|
||
private function uebernehmenErzeugtEineBuchung(): void
|
||
{
|
||
$offen = Bankumsatz::liste(['status' => 'offen']);
|
||
$this->assertNotEmpty($offen, 'Es gibt noch offene Umsätze');
|
||
|
||
$umsatz = $offen[0];
|
||
$vorher = Buchung::anzahl();
|
||
|
||
$buchungId = Bankumsatz::uebernehmen((int)$umsatz['id'], [
|
||
'kategorie_id' => $this->strom,
|
||
]);
|
||
|
||
$this->assertEquals($vorher + 1, Buchung::anzahl(), 'Es gibt eine Buchung mehr');
|
||
|
||
$buchung = Buchung::find($buchungId);
|
||
$this->assertEquals((float)$umsatz['betrag'], (float)$buchung['betrag'], 'Mit dem Betrag des Umsatzes');
|
||
$this->assertEquals((string)$umsatz['buchungstag'], (string)$buchung['datum'], 'Und seinem Datum');
|
||
$this->assertEquals('fints', $buchung['quelle'], 'Die Quelle ist der Bankabruf');
|
||
$this->assertEquals(1, (int)$buchung['abgeglichen'], 'Was von der Bank kommt, gilt als abgeglichen');
|
||
$this->assertEquals($this->strom, (int)$buchung['kategorie_id'], 'Die Kategorie kam aus der Zuordnung');
|
||
|
||
// Ein zweites Übernehmen desselben Umsatzes muss auffallen.
|
||
$fehler = false;
|
||
try {
|
||
Bankumsatz::uebernehmen((int)$umsatz['id'], []);
|
||
} catch (\RuntimeException) {
|
||
$fehler = true;
|
||
}
|
||
$this->assert($fehler, 'Zweimal übernehmen geht nicht');
|
||
|
||
// Umsätze ohne Konto lassen sich nicht buchen – das Konto fehlt.
|
||
$ohneKonto = $this->umsatzAnlegen([
|
||
'konto_id' => null, 'buchungstag' => '2026-08-05', 'betrag' => -5.00,
|
||
'empfaenger' => 'Kiosk', 'verwendungszweck' => 'Ohne Kontozuordnung',
|
||
]);
|
||
$fehler = false;
|
||
try {
|
||
Bankumsatz::uebernehmen((int)$ohneKonto, []);
|
||
} catch (\RuntimeException) {
|
||
$fehler = true;
|
||
}
|
||
$this->assert($fehler, 'Ohne zugeordnetes Konto verweigert der Abgleich die Buchung');
|
||
|
||
// Mit Konto in der Zuordnung geht es dann doch.
|
||
$mitKonto = Bankumsatz::uebernehmen((int)$ohneKonto, ['konto_id' => $this->sparkonto]);
|
||
$this->assertEquals(
|
||
$this->sparkonto,
|
||
(int)Buchung::find($mitKonto)['konto_id'],
|
||
'Das Konto aus der Zuordnung zählt'
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Der ganze Weg: Eine Regel mit Splitschema trifft einen offenen Umsatz, und
|
||
* was der Vorschlag ausrechnet, wird auch so gebucht. Der Abgleichdialog
|
||
* reicht genau diese Zeilen weiter – tat er das nicht, landete der Umsatz
|
||
* ungeteilt im Kontoblatt, ohne dass jemand etwas davon merkte.
|
||
*/
|
||
private function regelmitSplitsErzeugtEineSplitbuchung(): void
|
||
{
|
||
$regelId = AbgleichRegel::anlegen([
|
||
'name' => 'Abschlag geteilt',
|
||
'feld' => 'empfaenger',
|
||
'vergleich' => 'enthaelt',
|
||
'muster' => 'Stadtwerke Nord',
|
||
'splits' => [
|
||
['kategorie_id' => $this->strom, 'anteil' => 0.75],
|
||
['kategorie_id' => $this->miete, 'anteil' => 0.25],
|
||
],
|
||
'prioritaet' => 1,
|
||
'aktiv' => 1,
|
||
]);
|
||
|
||
$umsatzId = $this->umsatzAnlegen([
|
||
'konto_id' => $this->giro, 'buchungstag' => '2026-08-07', 'betrag' => -240.00,
|
||
'empfaenger' => 'Stadtwerke Nord AG', 'verwendungszweck' => 'Abschlag August',
|
||
]);
|
||
|
||
$umsatz = Bankumsatz::find($umsatzId);
|
||
$vorschlag = Bankumsatz::vorschlag($umsatz);
|
||
|
||
$this->assertEquals('uebernehmen', $vorschlag['art'], 'Ohne passende Buchung wird übernommen');
|
||
$this->assertNotEmpty($vorschlag['regel'], 'Die Regel greift');
|
||
$this->assertEquals(2, count($vorschlag['zuordnung']['splits']), 'Der Vorschlag bringt zwei Zeilen mit');
|
||
|
||
$buchungId = Bankumsatz::uebernehmen($umsatzId, $vorschlag['zuordnung']);
|
||
$buchung = Buchung::find($buchungId);
|
||
|
||
$this->assertEquals(1, (int)$buchung['gesplittet'], 'Es entsteht eine Splitbuchung');
|
||
$this->assertNull($buchung['kategorie_id'], 'Die Zuordnung steckt in den Zeilen, nicht in der Buchung');
|
||
|
||
$splits = Buchung::splits($buchungId);
|
||
$this->assertEquals(2, count($splits), 'Zwei Splitzeilen im Kontoblatt');
|
||
$this->assertEquals(-180.00, (float)$splits[0]['betrag'], 'Drei Viertel von 240');
|
||
$this->assertEquals(-60.00, (float)$splits[1]['betrag'], 'Ein Viertel von 240');
|
||
$this->assertEquals($this->strom, (int)$splits[0]['kategorie_id'], 'Mit der Kategorie aus der Regel');
|
||
|
||
AbgleichRegel::loeschen($regelId);
|
||
}
|
||
|
||
/**
|
||
* Der Regel-Testlauf soll Lücken zeigen, die eine Regel schließen könnte –
|
||
* nicht den Abgleichsstatus. Deshalb zählt „ohne Kategorie“ unabhängig
|
||
* davon, ob eine Buchung aus einem Umsatz entstand oder manuell erfasst
|
||
* wurde, und eine Splitbuchung zählt nur, wenn wirklich keine Zeile eine
|
||
* Kategorie trägt.
|
||
*/
|
||
private function buchungOhneKategorieWirdGefunden(): void
|
||
{
|
||
$ohneKategorie = Buchung::anlegen([
|
||
'konto_id' => $this->giro, 'datum' => '2026-08-10', 'betrag' => -19.99,
|
||
'empfaenger' => 'Unbekannter Laden',
|
||
]);
|
||
$mitKategorie = Buchung::anlegen([
|
||
'konto_id' => $this->giro, 'datum' => '2026-08-10', 'betrag' => -30.00,
|
||
'empfaenger' => 'Bekannter Laden', 'kategorie_id' => $this->strom,
|
||
]);
|
||
$splitOhneKategorie = Buchung::anlegen(
|
||
['konto_id' => $this->giro, 'datum' => '2026-08-10', 'betrag' => -50.00, 'empfaenger' => 'Split ohne'],
|
||
[
|
||
['kategorie_id' => null, 'betrag' => -30.00],
|
||
['kategorie_id' => null, 'betrag' => -20.00],
|
||
]
|
||
);
|
||
$splitMitKategorie = Buchung::anlegen(
|
||
['konto_id' => $this->giro, 'datum' => '2026-08-10', 'betrag' => -50.00, 'empfaenger' => 'Split mit'],
|
||
[
|
||
['kategorie_id' => $this->strom, 'betrag' => -30.00],
|
||
['kategorie_id' => null, 'betrag' => -20.00],
|
||
]
|
||
);
|
||
$umbuchung = Buchung::anlegen([
|
||
'konto_id' => $this->giro, 'datum' => '2026-08-10', 'betrag' => -40.00,
|
||
'empfaenger' => 'Umbuchung', 'gegenkonto_id' => $this->sparkonto,
|
||
]);
|
||
|
||
$ids = array_column(Buchung::ohneKategorie(), 'id');
|
||
$ids = array_map('intval', $ids);
|
||
|
||
$this->assert(in_array($ohneKategorie, $ids, true), 'Buchung ohne jede Kategorie taucht auf');
|
||
$this->assert(in_array($splitOhneKategorie, $ids, true), 'Splitbuchung ohne kategorisierte Zeile taucht auf');
|
||
$this->assert(!in_array($mitKategorie, $ids, true), 'Kategorisierte Buchung fehlt in der Liste');
|
||
$this->assert(!in_array($splitMitKategorie, $ids, true), 'Teilweise kategorisierte Splitbuchung fehlt in der Liste');
|
||
$this->assert(!in_array($umbuchung, $ids, true), 'Eine Umbuchung braucht keine Kategorie');
|
||
}
|
||
|
||
/**
|
||
* Der Knopf soll die Lücken nicht nur zählen, sondern gleich schließen:
|
||
* Jede Buchung ohne Kategorie, auf die eine Regel passt, bekommt deren
|
||
* Zuordnung nachgetragen. Ohne Treffer bleibt die Buchung unverändert.
|
||
*/
|
||
private function regelnKategorisierenBuchungenOhneKategorie(): void
|
||
{
|
||
$regelId = AbgleichRegel::anlegen([
|
||
'name' => 'Stadtwerke Nachtrag', 'feld' => 'empfaenger', 'vergleich' => 'enthaelt',
|
||
'muster' => 'Stadtwerke Nachtrag', 'kategorie_id' => $this->strom, 'prioritaet' => 1, 'aktiv' => 1,
|
||
]);
|
||
$splitRegelId = AbgleichRegel::anlegen([
|
||
'name' => 'Vermieter Nachtrag geteilt', 'feld' => 'empfaenger', 'vergleich' => 'enthaelt',
|
||
'muster' => 'Vermieter Nachtrag',
|
||
'splits' => [
|
||
['kategorie_id' => $this->strom, 'anteil' => 0.5],
|
||
['kategorie_id' => $this->miete, 'anteil' => 0.5],
|
||
],
|
||
'prioritaet' => 1, 'aktiv' => 1,
|
||
]);
|
||
$treffervorher = (int)AbgleichRegel::find($regelId)['treffer'];
|
||
|
||
$trifft = Buchung::anlegen([
|
||
'konto_id' => $this->giro, 'datum' => '2026-08-11', 'betrag' => -55.00,
|
||
'empfaenger' => 'Stadtwerke Nachtrag GmbH',
|
||
]);
|
||
$trifftSplit = Buchung::anlegen([
|
||
'konto_id' => $this->giro, 'datum' => '2026-08-11', 'betrag' => -100.00,
|
||
'empfaenger' => 'Vermieter Nachtrag GmbH',
|
||
]);
|
||
$trifftNicht = Buchung::anlegen([
|
||
'konto_id' => $this->giro, 'datum' => '2026-08-11', 'betrag' => -12.00,
|
||
'empfaenger' => 'Ohne jede Regel',
|
||
]);
|
||
|
||
$ergebnis = Bankabgleich::regelnAufBuchungenOhneKategorieAnwenden();
|
||
|
||
$this->assertEquals($this->strom, (int)Buchung::find($trifft)['kategorie_id'], 'Die Kategorie wurde nachgetragen');
|
||
$this->assertNull(Buchung::find($trifftNicht)['kategorie_id'], 'Ohne Regel bleibt die Buchung unverändert');
|
||
|
||
$splitBuchung = Buchung::find($trifftSplit);
|
||
$this->assertEquals(1, (int)$splitBuchung['gesplittet'], 'Eine Splitregel macht die Buchung zur Splitbuchung');
|
||
$splits = Buchung::splits($trifftSplit);
|
||
$this->assertEquals(2, count($splits), 'Zwei Splitzeilen aus der Regel');
|
||
$this->assertEquals(-50.00, (float)$splits[0]['betrag'], 'Je zur Hälfte aufgeteilt');
|
||
|
||
$luecken = array_map('intval', array_column(Buchung::ohneKategorie(), 'id'));
|
||
$this->assert(in_array($trifftNicht, $luecken, true), 'Bleibt ohne Regeltreffer in der Lückenliste');
|
||
$this->assert(!in_array($trifft, $luecken, true), 'Verlässt die Lückenliste, sobald sie kategorisiert ist');
|
||
|
||
$this->assertGreaterThan($treffervorher, (int)AbgleichRegel::find($regelId)['treffer'], 'Der Treffer wird gezählt');
|
||
$this->assert($ergebnis['kategorisiert'] >= 2, 'Mindestens die zwei passenden Buchungen wurden kategorisiert');
|
||
|
||
AbgleichRegel::loeschen($regelId);
|
||
AbgleichRegel::loeschen($splitRegelId);
|
||
}
|
||
|
||
private function verwerfenUndZuruecksetzen(): void
|
||
{
|
||
$id = $this->umsatzAnlegen([
|
||
'buchungstag' => '2026-08-06', 'betrag' => -3.50,
|
||
'empfaenger' => 'Doppelbuchung', 'verwendungszweck' => 'Storniert',
|
||
]);
|
||
|
||
Bankumsatz::verwerfen((int)$id);
|
||
$this->assertEquals('verworfen', Bankumsatz::find((int)$id)['status'], 'Verworfen ist verworfen');
|
||
|
||
Bankumsatz::zuruecksetzen((int)$id);
|
||
$this->assertEquals('offen', Bankumsatz::find((int)$id)['status'], 'Und lässt sich zurückholen');
|
||
$this->assertNull(Bankumsatz::find((int)$id)['buchung_id'], 'Ohne Buchungsverweis');
|
||
}
|
||
|
||
private function abrufprotokollHaeltDenVerlauf(): void
|
||
{
|
||
$id = Bankabruf::beginnen($this->zugang);
|
||
|
||
$this->assertEquals('laeuft', Bankabruf::find($id)['status'], 'Ein neuer Abruf läuft');
|
||
$this->assertNull(Bankabruf::find($id)['beendet_am'], 'Und hat noch kein Ende');
|
||
|
||
Bankabruf::abschliessen($id, 'tan_offen', 0, 0, 'Wartet auf Freigabe.', ['12:00:00 Angemeldet.']);
|
||
$wartend = Bankabruf::find($id);
|
||
$this->assertEquals('tan_offen', $wartend['status'], 'Der Abruf wartet auf eine TAN');
|
||
$this->assertNull($wartend['beendet_am'], 'Ein wartender Abruf ist nicht beendet');
|
||
|
||
Bankabruf::abschliessen($id, 'erfolg', 7, 3, '7 neue Umsätze, 3 bereits bekannt.', ['12:01:00 Fertig.']);
|
||
$fertig = Bankabruf::find($id);
|
||
$this->assertEquals('erfolg', $fertig['status'], 'Danach ist er erfolgreich');
|
||
$this->assertEquals(7, (int)$fertig['neu'], 'Mit der Zahl der neuen Umsätze');
|
||
$this->assertNotEmpty($fertig['beendet_am'], 'Und einem Ende');
|
||
$this->assert(str_contains((string)$fertig['protokoll'], 'Fertig'), 'Das Protokoll steht dabei');
|
||
|
||
// Steckengebliebene Abrufe werden aufgeräumt, sonst blockieren sie die Anzeige.
|
||
$haenger = Bankabruf::beginnen($this->zugang);
|
||
\Finanzmanager\Database::execute(
|
||
'UPDATE bank_abrufe SET begonnen_am = DATE_SUB(NOW(), INTERVAL 5 HOUR) WHERE id = ?',
|
||
[$haenger]
|
||
);
|
||
$this->assertGreaterThan(0, Bankabruf::raeumeAlteAuf(2), 'Der Hänger wurde aufgeräumt');
|
||
$this->assertEquals(
|
||
'abgebrochen',
|
||
Bankabruf::find($haenger)['status'],
|
||
'Und gilt als abgebrochen'
|
||
);
|
||
}
|
||
}
|