import { describe, expect, it } from 'vitest'; import { parseProject } from '@/domain/model/schema'; import { buildSignalPlan } from '@/domain/plan/signalPlan'; import { validateProject } from '@/domain/validation/engine'; /* * Befunde 17 und 42, behoben in Fassung 5.11.0. * * MEHRDEUTIGE KENNUNGEN WERDEN AUFGELOEST, NICHT GERATEN. * * Kommt eine Signalgruppen- oder Zufahrtskennung zweimal vor, bekam bisher die * ZWEITE eine neue Kennung, die erste behielt die alte - und alles, was auf die * alte verwies, fiel damit der ERSTEN zu: Konfliktbeziehungen, Phasen, * Verkehrsstaerken und Fahrlinien bei den Signalgruppen, `armId` von * Signalgruppen und Haltlinien bei den Zufahrten. Welche der beiden gemeint * war, steht in der Datei nirgends; der Verweis ist nicht falsch, sondern * MEHRDEUTIG. * * Genau dieselbe Bauart hat das Modul fuer Haltlinien (Befunde 34 und 47) und * fuer Konfliktkennungen (Befund 2) bereits als Fehler abgestellt; der Grundsatz * steht woertlich in schema.ts bei `haltlinienMehrdeutig`. * * WAS DER ALTSTAND ANRICHTETE - beides in der gefaehrlichen Richtung: * * (a) Signalgruppen. Die zweite Beziehung derselben Richtung fiel in die * Paardoppelung von `parseConflicts` und wurde mit "Die Konfliktbeziehung * ist doppelt erfasst" verworfen - eine Aussage, die nicht stimmte: Es waren * zwei verschiedene Beziehungen zweier verschiedener Stroeme. Welche * Vermassung ueberlebte, entschied allein die Reihenfolge in der Datei; * stand der kuerzere Raeumweg vorn, blieb der kuerzere stehen. Die zweite * Gruppe stand danach ohne jede Konfliktbeziehung da - `intergreenBetween` * liefert dann 0, und `pruefeFeindlichInPhase` schweigt: Kraftfahrzeugstrom * und gequerte Furt koennen gleichzeitig Freigabe bekommen, ohne einen * einzigen Befund. * * (b) Zufahrten. Beide Stroeme hingen scheinbar an derselben Zufahrt. Damit * entfiel der Hinweis `leistungsfaehigkeit.abbiegerfaktor-pauschal` - die * Regel schliesst Partner derselben, ERFASSTEN Zufahrt aus (rules.ts) -, * und die pauschale Abminderung 0,9 fuer einen bedingt vertraeglichen * Linksabbieger blieb unkommentiert. * * GEGEN DEN ALTSTAND schlagen die Faelle mit doppelter Kennung fehl; die beiden * Gegenproben mit verschiedenen Kennungen bestehen dort ebenso. */ const DATUM = new Date('2026-01-01T00:00:00Z'); /** Ein Lageplan mit genau einer Haltlinie und einer Fahrlinie, beide verwiesen. */ function lageplan(armId: string, signalGroupId: string): Record { return { bild: null, kalibrierung: { von: { x: 0, y: 0 }, bis: { x: 100, y: 0 }, laengeMeter: 100, herkunft: 'gemessen', }, haltlinien: [ { id: 'hl-1', name: 'HL Nord', art: 'zufahrt', armId, von: { x: 0, y: 0 }, bis: { x: 7, y: 0 }, }, ], linien: [ { id: 'pl-1', name: 'Nord geradeaus', mode: 'kfz', movement: 'geradeaus', breiteMeter: 3.5, punkte: [ { x: 3.5, y: 0 }, { x: 3.5, y: 60 }, ], haltlinieId: 'hl-1', startT: 0, signalGroupId, }, ], }; } /** Der Ausloeser aus Befund 17, woertlich. */ function dateiMitDoppelterGruppenkennung(): Record { return { signalGroups: [ { id: 'X', name: 'K1', mode: 'kfz', movement: 'geradeaus' }, { id: 'X', name: 'K2', mode: 'kfz', movement: 'links' }, { id: 'F', name: 'Furt', mode: 'fuss', movement: 'querung' }, ], conflicts: [ { id: 'cf-1', fromId: 'X', toId: 'F', clearingDistance: 20, enteringDistance: 8 }, { id: 'cf-2', fromId: 'X', toId: 'F', clearingDistance: 35, enteringDistance: 8 }, { id: 'cf-3', fromId: 'F', toId: 'X', clearingDistance: 12, enteringDistance: 6 }, ], phases: [{ id: 'ph-1', name: 'Phase 1', signalGroupIds: ['X', 'F'] }], demands: [ { signalGroupId: 'X', volume: 400, heavyVehicleShare: 0.05 }, { signalGroupId: 'X', volume: 900, heavyVehicleShare: 0.05 }, ], lageplan: lageplan('arm-nord', 'X'), }; } /** Der Ausloeser aus Befund 42: zwei Zufahrten der Kennung "A". */ function dateiMitZufahrtskennungen(zweite: string): Record { return { intersection: { name: 'Musterkreuzung', arms: [ { id: 'A', name: 'Nord', lanes: 2 }, { id: zweite, name: 'Süd', lanes: 2 }, ], }, signalGroups: [ { id: 'sg-k1', name: 'K1', mode: 'kfz', movement: 'links', armId: 'A' }, { id: 'sg-k2', name: 'K2', mode: 'kfz', movement: 'geradeaus', armId: zweite }, ], phases: [{ id: 'ph-1', name: 'Phase 1', signalGroupIds: ['sg-k1', 'sg-k2'] }], demands: [ { signalGroupId: 'sg-k1', volume: 300, heavyVehicleShare: 0.05 }, { signalGroupId: 'sg-k2', volume: 500, heavyVehicleShare: 0.05 }, ], lageplan: lageplan(zweite, 'sg-k2'), }; } describe('Befund 17 - doppelte Signalgruppenkennung', () => { it('vergibt die zweite Kennung neu und nennt die Folge fuer die Verweise', () => { const { project, issues } = parseProject(dateiMitDoppelterGruppenkennung(), DATUM); // Vorbedingung: Beide Gruppen bleiben erhalten und sind unterscheidbar. expect(project.signalGroups).toHaveLength(3); expect(project.signalGroups[0]!.id).not.toBe(project.signalGroups[1]!.id); const meldung = issues.find((i) => i.message.includes('Signalgruppenkennung "X"')); expect(meldung?.severity).toBe('fehler'); // Wie bei der Haltlinienkennung: Die Meldung sagt, was mit den Verweisen // geschieht - "neu vergeben" allein verschweigt den eigentlichen Verlust. expect(meldung?.message).toContain('steht in der Datei nicht'); }); it('loest die Konfliktbeziehungen auf, statt eine als "doppelt erfasst" zu verwerfen', () => { const { project, issues } = parseProject(dateiMitDoppelterGruppenkennung(), DATUM); // Keine der drei Beziehungen laesst sich einem Strom zuordnen: Alle drei // nennen "X". Geraten wird nichts. expect(project.conflicts).toHaveLength(0); // Die falsche Aussage des Altstands. Es waren zwei verschiedene // Beziehungen zweier verschiedener Stroeme, keine Doppelerfassung. expect(issues.map((i) => i.message).join(' | ')).not.toContain('doppelt erfasst'); const konfliktmeldungen = issues.filter((i) => i.path.startsWith('conflicts')); expect(konfliktmeldungen).toHaveLength(3); for (const m of konfliktmeldungen) { expect(m.message).toContain('mehrfach vergebene Signalgruppenkennung'); } }); it('loest Phasenzuordnung, Verkehrsstaerke und Fahrlinie auf', () => { const { project, issues } = parseProject(dateiMitDoppelterGruppenkennung(), DATUM); // Die Phase behaelt die eindeutige Furt und verliert die mehrdeutige "X". expect(project.phases[0]!.signalGroupIds).toEqual(['F']); expect(project.demands).toHaveLength(0); expect(project.lageplan.linien[0]!.signalGroupId).toBeNull(); const pfade = issues.filter((i) => i.message.includes('mehrfach vergebene')).map((i) => i.path); expect(pfade).toContain('phases[0]'); expect(pfade).toContain('demands[0]'); expect(pfade).toContain('lageplan.linien[0].signalGroupId'); }); it('laesst eindeutige Kennungen unangetastet (Gegenprobe)', () => { const roh = dateiMitDoppelterGruppenkennung(); (roh['signalGroups'] as Record[])[1]!['id'] = 'Y'; (roh['conflicts'] as Record[])[1]!['fromId'] = 'Y'; (roh['phases'] as Record[])[0]!['signalGroupIds'] = ['X', 'Y', 'F']; (roh['demands'] as Record[])[1]!['signalGroupId'] = 'Y'; const { project, issues } = parseProject(roh, DATUM); expect(project.conflicts).toHaveLength(3); expect(project.phases[0]!.signalGroupIds).toEqual(['X', 'Y', 'F']); expect(project.demands).toHaveLength(2); expect(project.lageplan.linien[0]!.signalGroupId).toBe('X'); expect(issues.filter((i) => i.message.includes('mehrfach vergebene'))).toHaveLength(0); }); }); describe('Befund 42 - doppelte Zufahrtskennung', () => { it('hebt die Zuordnung der Signalgruppen und Haltlinien auf', () => { const { project, issues } = parseProject(dateiMitZufahrtskennungen('A'), DATUM); // Vorbedingung: Beide Zufahrten bleiben erhalten und sind unterscheidbar. expect(project.intersection.arms).toHaveLength(2); expect(project.intersection.arms[0]!.id).not.toBe(project.intersection.arms[1]!.id); // Kein Strom haengt danach an einer geratenen Zufahrt. expect(project.signalGroups.map((g) => g.armId)).toEqual([null, null]); expect(project.lageplan.haltlinien[0]!.armId).toBeNull(); const meldung = issues.find((i) => i.message.includes('Zufahrtskennung "A"')); expect(meldung?.message).toContain('steht in der Datei nicht'); const pfade = issues.filter((i) => i.message.includes('mehrfach vergebene')).map((i) => i.path); expect(pfade).toContain('signalGroups[0].armId'); expect(pfade).toContain('signalGroups[1].armId'); expect(pfade).toContain('lageplan.haltlinien[0].armId'); }); it('bringt den Hinweis zum pauschalen Abbiegerfaktor zurueck', () => { const { project } = parseProject(dateiMitZufahrtskennungen('A'), DATUM); const bericht = validateProject(project, buildSignalPlan(project), DATUM); expect(bericht.findings.map((f) => f.rule)).toContain( 'leistungsfaehigkeit.abbiegerfaktor-pauschal', ); }); it('haelt zwei verschiedene Zufahrtskennungen auseinander (Gegenprobe)', () => { const { project, issues } = parseProject(dateiMitZufahrtskennungen('B'), DATUM); expect(project.signalGroups.map((g) => g.armId)).toEqual(['A', 'B']); expect(project.lageplan.haltlinien[0]!.armId).toBe('B'); expect(issues.filter((i) => i.message.includes('Zufahrtskennung'))).toHaveLength(0); const bericht = validateProject(project, buildSignalPlan(project), DATUM); expect(bericht.findings.map((f) => f.rule)).toContain( 'leistungsfaehigkeit.abbiegerfaktor-pauschal', ); }); });