244 lines
16 KiB
JavaScript
244 lines
16 KiB
JavaScript
import test from 'node:test'
|
||
import assert from 'node:assert/strict'
|
||
import { readFileSync } from 'node:fs'
|
||
import { loadModule } from './load.mjs'
|
||
|
||
// Reine Daten und Ableitungen des Kellers (src/lib/hustlerKeller.js, Hustler-Pixelwelt T10, Spec E12/E13): Einpassen der Szene, Lage der Dinge, Arne nach Status,
|
||
// Raum-Reiter, Scout, Punkte-Anzeige, Zeilenmodell eines Bot-Leads.
|
||
|
||
const K = await loadModule('src/lib/hustlerKeller.js')
|
||
const V = await loadModule('src/lib/botleadsView.js')
|
||
const { SZENE, kellerEinpassen, FENSTER, DAMPF, BUCH_STEMPEL, ROHRPOST, SCHUBLADE, MAUS_STREIFEN, ARNE_RUHE, LEDS, REITER, raumIcon, scoutFuer, punkteInfo, eintragModell, arneAnsicht } = K
|
||
const { ROOM_FILTERS } = V
|
||
|
||
const read = (p) => readFileSync(new URL('../../' + p, import.meta.url), 'utf8')
|
||
const ohneKommentare = (css) => css.replace(/\/\*[\s\S]*?\*\//g, '')
|
||
const kellerCss = ohneKommentare(read('src/styles/hustler/keller.css'))
|
||
const uiCss = ohneKommentare(read('src/styles/hustler/hustler-keller-ui.css'))
|
||
const klassen = (css) => new Set((css.replace(/url\([^)]*\)/g, '').match(/\.hk-[A-Za-z0-9_-]+/g) ?? []).map((k) => k.slice(1)))
|
||
const CSS = new Set([...klassen(kellerCss), ...klassen(uiCss)])
|
||
const KEYFRAMES = new Set([...kellerCss.matchAll(/@keyframes\s+([\w-]+)/g)].map((m) => m[1]))
|
||
const px = (s) => Number.parseFloat(s)
|
||
|
||
function tiefEingefroren(wert, pfad) {
|
||
if (wert === null || typeof wert !== 'object') return
|
||
assert.ok(Object.isFrozen(wert), `${pfad} ist nicht eingefroren`)
|
||
for (const [k, v] of Object.entries(wert)) tiefEingefroren(v, `${pfad}.${k}`)
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// Szene
|
||
|
||
test('kellerEinpassen: „cover“ links verankert, Maßstab = größeres Seitenverhältnis, Vorgabe ohne Messung', () => {
|
||
assert.deepEqual(SZENE, { breite: 640, hoehe: 360 })
|
||
assert.deepEqual(kellerEinpassen(1280, 720), { s: 2, x: 0, y: 0 })
|
||
assert.deepEqual(kellerEinpassen(1920, 1080), { s: 3, x: 0, y: 0 })
|
||
// breiter als hoch: der Maßstab folgt der Höhe, links bleibt verankert (x nie positiv, nur ein Teil des Überstands wandert)
|
||
const schmal = kellerEinpassen(1280, 900)
|
||
assert.equal(schmal.s, 2.5)
|
||
assert.equal(schmal.x, -48)
|
||
assert.equal(schmal.y, 0)
|
||
// sehr breit: der Maßstab folgt der Breite, die Szene steht tiefer (der untere Rand bleibt, höchstens 36 Szenen-Pixel gehen unten verloren)
|
||
const breit = kellerEinpassen(2560, 720)
|
||
assert.equal(breit.s, 4)
|
||
assert.equal(breit.x, 0)
|
||
assert.equal(breit.y, -576)
|
||
// Handy hochkant
|
||
const handy = kellerEinpassen(390, 844)
|
||
assert.ok(Math.abs(handy.s - 844 / 360) < 1e-9)
|
||
assert.ok(handy.x < 0 && handy.x > -(640 * handy.s - 390))
|
||
assert.equal(handy.y, 0)
|
||
// ohne brauchbare Größe: Vorgabe der Vorlage
|
||
for (const [b, h] of [[0, 0], [NaN, 720], [1280, NaN], [-1, 700], [1280, 0], [undefined, undefined], ['1280', '720']]) {
|
||
assert.deepEqual(kellerEinpassen(b, h), { s: 2, x: 0, y: 0 }, `${b} x ${h}`)
|
||
}
|
||
})
|
||
|
||
test('kellerEinpassen: die Szene deckt den Rahmen immer ganz (cover) und liegt nie rechts vom linken Rand', () => {
|
||
for (const [b, h] of [[1280, 720], [1920, 1080], [1048, 720], [390, 844], [768, 1024], [2560, 1440], [3440, 1440], [320, 568], [1000, 300]]) {
|
||
const { s, x, y } = kellerEinpassen(b, h)
|
||
assert.ok(640 * s >= b - 1e-9 && 360 * s >= h - 1e-9, `${b} x ${h}: Szene kleiner als der Rahmen`)
|
||
assert.ok(x <= 0 && x + 640 * s >= b - 1e-9, `${b} x ${h}: Lücke links oder rechts (x ${x})`)
|
||
assert.ok(y <= 0 && y + 360 * s >= h - 1e-9, `${b} x ${h}: Lücke oben oder unten (y ${y})`)
|
||
}
|
||
})
|
||
|
||
test('Lage der Dinge: alles liegt in der 640 x 360 großen Szene, Arne am Pult steht auf der Laufline, Daten sind eingefroren', () => {
|
||
for (const [name, o] of Object.entries({ FENSTER, DAMPF, BUCH_STEMPEL, ROHRPOST, SCHUBLADE, MAUS_STREIFEN, ARNE_RUHE })) {
|
||
assert.equal(o.position, 'absolute', name)
|
||
assert.ok(px(o.left) >= 0 && px(o.top) >= 0 && px(o.left) < 640 && px(o.top) < 360, name)
|
||
assert.match(o.left, /^\d+px$/); assert.match(o.top, /^\d+px$/)
|
||
}
|
||
// Maße der Vorlage (BotLeads.dc.html)
|
||
assert.deepEqual([FENSTER.left, FENSTER.top, FENSTER.width, FENSTER.height, FENSTER.overflow], ['23px', '34px', '46px', '29px', 'hidden'])
|
||
assert.deepEqual([ROHRPOST.left, ROHRPOST.top], ['130px', '224px'])
|
||
assert.deepEqual([SCHUBLADE.left, SCHUBLADE.top], ['214px', '279px'])
|
||
assert.deepEqual([BUCH_STEMPEL.left, BUCH_STEMPEL.top], ['60px', '252px'])
|
||
assert.deepEqual([DAMPF.left, DAMPF.top], ['26px', '247px'])
|
||
assert.deepEqual([MAUS_STREIFEN.left, MAUS_STREIFEN.top, MAUS_STREIFEN.width, MAUS_STREIFEN.height], ['30px', '336px', '238px', '24px'])
|
||
assert.equal(px(MAUS_STREIFEN.top) + px(MAUS_STREIFEN.height), 360)
|
||
// Haus-Figur 24 x 32: die Füße stehen auf der Laufline (318), Mitte beim Halt am Pult (128)
|
||
assert.equal(px(ARNE_RUHE.top) + 32, 318)
|
||
assert.equal(px(ARNE_RUHE.left) + 12, 128)
|
||
for (const [name, o] of Object.entries({ SZENE, FENSTER, DAMPF, BUCH_STEMPEL, ROHRPOST, SCHUBLADE, MAUS_STREIFEN, ARNE_RUHE, LEDS, REITER })) tiefEingefroren(o, name)
|
||
})
|
||
|
||
test('Blinkpunkte: sechs, jeder mit Keyframes aus keller.css (hk-k-k-led-…), Maße und Takte der Vorlage', () => {
|
||
assert.deepEqual(LEDS.map((l) => l.name), ['weiche-gruen', 'weiche-bernstein', 'sicherung-1', 'sicherung-2', 'sicherung-3', 'verteiler'])
|
||
for (const l of LEDS) {
|
||
const m = /^(hk-k-k-led-[a-z0-9-]+) (\d+)ms steps\(1,end\) infinite$/.exec(l.stil.animation)
|
||
assert.ok(m, l.stil.animation)
|
||
assert.equal(m[1], `hk-k-k-led-${l.name}`)
|
||
assert.ok(KEYFRAMES.has(m[1]), `${m[1]} fehlt in keller.css`)
|
||
assert.equal(l.stil.height, '2px')
|
||
assert.match(l.stil.background, /^#[0-9a-f]{6}$/)
|
||
assert.ok(px(l.stil.left) < 640 && px(l.stil.top) < 360)
|
||
}
|
||
assert.deepEqual(LEDS.map((l) => px(l.stil.animation.split(' ')[1])), [1800, 2600, 3000, 2200, 3400, 2000])
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// Arne
|
||
|
||
const eintrag = (status) => (status === 'grau' ? { status: 'grau', task: '', lastTs: null, connected: false, counters: {} } : { status, task: '', lastTs: null, connected: true, counters: {} })
|
||
|
||
test('arneAnsicht: arbeitet ⇒ Ablauf-Schleife; sonst Haus-Figur nach Status (warten, schlafen, nicht), Fehler mit Marker', () => {
|
||
const arbeit = arneAnsicht({ arne: eintrag('arbeitet') })
|
||
assert.deepEqual(arbeit, { status: 'arbeitet', arbeitet: true, pose: 'arbeiten', alarm: false, punkte: false, zzz: false, label: 'Arne, Haiku, arbeitet' })
|
||
assert.deepEqual(arneAnsicht({ arne: eintrag('wartet') }), { status: 'wartet', arbeitet: false, pose: 'warten', alarm: false, punkte: true, zzz: false, label: 'Arne, Haiku, wartet auf Auftrag' })
|
||
assert.deepEqual(arneAnsicht({ arne: eintrag('leerlauf') }), { status: 'leerlauf', arbeitet: false, pose: 'schlafen', alarm: false, punkte: false, zzz: true, label: 'Arne, Haiku, Leerlauf' })
|
||
assert.deepEqual(arneAnsicht({ arne: eintrag('grau') }), { status: 'grau', arbeitet: false, pose: 'nicht', alarm: false, punkte: false, zzz: false, label: 'Arne, Haiku, noch nicht angeschlossen' })
|
||
assert.deepEqual(arneAnsicht({ arne: eintrag('fehler') }), { status: 'fehler', arbeitet: false, pose: 'nicht', alarm: true, punkte: false, zzz: false, label: 'Arne, Haiku, Fehler' })
|
||
})
|
||
|
||
test('arneAnsicht: nur „arbeitet“ arbeitet; ohne Tabelle, ohne Eintrag oder mit Unsinn schläft Arne (Leerlauf)', () => {
|
||
for (const workers of [undefined, null, {}, [], 'x', 5, { otto: eintrag('arbeitet') }, { arne: null }, { arne: 'arbeitet' }, { arne: { status: 'irgendwas' } }, { arne: {} }]) {
|
||
const a = arneAnsicht(workers)
|
||
assert.equal(a.arbeitet, false, JSON.stringify(workers))
|
||
assert.equal(a.status, 'leerlauf')
|
||
assert.equal(a.pose, 'schlafen')
|
||
assert.equal(a.alarm, false)
|
||
}
|
||
// ein Eintrag anderer Hustler ändert nichts: nur arne zählt
|
||
assert.equal(arneAnsicht({ arne: eintrag('wartet'), otto: eintrag('arbeitet'), ali: eintrag('fehler') }).status, 'wartet')
|
||
// arbeitet und gleichzeitig nicht angeschlossen: grau gewinnt (figurZustand)
|
||
assert.equal(arneAnsicht({ arne: { ...eintrag('arbeitet'), connected: false } }).status, 'grau')
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------------------------------------------
|
||
// Register-Buch
|
||
|
||
test('REITER: Reihenfolge, Werte und Beschriftungen von ROOM_FILTERS, kurze sichtbare Namen, Symbol und Farbe je Reiter aus keller.css', () => {
|
||
assert.deepEqual(REITER.map((r) => r.value), ROOM_FILTERS.map((f) => f.value))
|
||
assert.deepEqual(REITER.map((r) => r.label), ROOM_FILTERS.map((f) => f.label))
|
||
assert.deepEqual(REITER.map((r) => r.kurz), ['Alle', 'Ärzte', 'Handwerk', 'Selbstständige', 'Läden'])
|
||
assert.deepEqual(REITER.map((r) => r.icon), ['hk-ic hk-ic-alle', 'hk-ic hk-ic-raum-aerzte', 'hk-ic hk-ic-raum-handwerk', 'hk-ic hk-ic-raum-selbst', 'hk-ic hk-ic-raum-laden'])
|
||
assert.deepEqual(REITER.map((r) => r.klasse), ['hk-reiter hk-reiter-alle', 'hk-reiter hk-reiter-aerzte', 'hk-reiter hk-reiter-handwerk', 'hk-reiter hk-reiter-selbst', 'hk-reiter hk-reiter-laden'])
|
||
for (const r of REITER) for (const k of `${r.icon} ${r.klasse}`.split(' ')) assert.ok(CSS.has(k), `${k} fehlt im CSS`)
|
||
})
|
||
|
||
test('raumIcon: Symbol je Raum, ein unbekannter Raum zeigt den Aktenstapel', () => {
|
||
assert.equal(raumIcon('aerzte'), 'hk-ic hk-ic-raum-aerzte')
|
||
assert.equal(raumIcon('handwerk'), 'hk-ic hk-ic-raum-handwerk')
|
||
assert.equal(raumIcon('selbst'), 'hk-ic hk-ic-raum-selbst')
|
||
assert.equal(raumIcon('laden'), 'hk-ic hk-ic-raum-laden')
|
||
for (const unbekannt of ['', 'netz', 'xyz', 'constructor', '__proto__', undefined, null, 3, {}]) assert.equal(raumIcon(unbekannt), 'hk-ic hk-ic-alle', String(unbekannt))
|
||
for (const room of ['aerzte', 'handwerk', 'selbst', 'laden', '']) for (const k of raumIcon(room).split(' ')) assert.ok(CSS.has(k), k)
|
||
})
|
||
|
||
test('scoutFuer: Raum → Hustler der Etage „Ohne Website“ (aerzte → Ali, handwerk → Hanna, selbst → Sven, laden → Lea), sonst leer', () => {
|
||
assert.equal(scoutFuer('aerzte'), 'Ali')
|
||
assert.equal(scoutFuer('handwerk'), 'Hanna')
|
||
assert.equal(scoutFuer('selbst'), 'Sven')
|
||
assert.equal(scoutFuer('laden'), 'Lea')
|
||
// Räume anderer Etagen (Rita im Netz, Arne im Archiv) und alles Unbekannte haben keinen Scout
|
||
for (const room of ['netz', 'archiv', 'bruecke', 'waage', '', 'xyz', 'constructor', undefined, null, 7]) assert.equal(scoutFuer(room), '', String(room))
|
||
})
|
||
|
||
test('punkteInfo: Zahl, Balkenbreite (48 und 96 px) und Farbe (ab 75 gut, ab 55 mittel, darunter schlecht, ohne Zahl leer)', () => {
|
||
assert.deepEqual(punkteInfo(82), { text: '82', breite: 39, breiteGross: 79, farbe: 'gut' })
|
||
assert.deepEqual(punkteInfo(75), { text: '75', breite: 36, breiteGross: 72, farbe: 'gut' })
|
||
assert.equal(punkteInfo(74).farbe, 'mittel')
|
||
assert.equal(punkteInfo(55).farbe, 'mittel')
|
||
assert.equal(punkteInfo(54).farbe, 'schlecht')
|
||
assert.deepEqual(punkteInfo(0), { text: '0', breite: 0, breiteGross: 0, farbe: 'schlecht' })
|
||
assert.deepEqual(punkteInfo(100), { text: '100', breite: 48, breiteGross: 96, farbe: 'gut' })
|
||
assert.equal(punkteInfo(81.6).text, '82') // gerundet wie scoreLabel in botleadRow
|
||
// der Balken bleibt im Rahmen, der Text nennt die Zahl des Dienstes
|
||
assert.deepEqual(punkteInfo(130), { text: '130', breite: 48, breiteGross: 96, farbe: 'gut' })
|
||
assert.deepEqual(punkteInfo(-5), { text: '-5', breite: 0, breiteGross: 0, farbe: 'schlecht' })
|
||
for (const nichts of [undefined, null, NaN, Infinity, 'x', '82', {}]) assert.deepEqual(punkteInfo(nichts), { text: '–', breite: 0, breiteGross: 0, farbe: 'leer' }, String(nichts))
|
||
})
|
||
|
||
const ITEM = {
|
||
id: 'p1', room: 'handwerk', roomLabel: 'Handwerk', name: 'Elektro Beispiel GmbH', postalCode: '67655', city: 'Kaiserslautern', score: 82,
|
||
reason: 'keine veröffentlichte Mail', sourceUrl: 'https://beispiel-elektro.de/impressum', phone: '0631 111', phoneSource: 'https://beispiel-elektro.de/impressum',
|
||
isHealth: false, foundAt: '2026-10-19T20:00:00Z', gekuerzt: false,
|
||
}
|
||
|
||
test('eintragModell: Zeilenmodell von botleadRow plus Raum-Symbol, Scout, Punkte, Grund mit Erklärung, Telefon-Symbol und Label', () => {
|
||
const m = eintragModell(ITEM)
|
||
assert.deepEqual({ ...m, punkte: undefined }, {
|
||
...V.botleadRow(ITEM),
|
||
raum: 'handwerk', raumIcon: 'hk-ic hk-ic-raum-handwerk', scout: 'Hanna', punkte: undefined,
|
||
grundIcon: 'hk-ic hk-ic-brief-x', erklaerung: 'Auf der Website steht keine E-Mail-Adresse. Ohne veröffentlichte Adresse schreibt der Hustler nie.',
|
||
telefonIcon: 'hk-ic hk-ic-telefon',
|
||
label: 'Elektro Beispiel GmbH, 67655 Kaiserslautern, 82 Punkte, keine veröffentlichte Mail, gefunden am 19.10.2026',
|
||
})
|
||
assert.deepEqual(m.punkte, punkteInfo(82))
|
||
assert.equal(m.sourceHref, 'https://beispiel-elektro.de/impressum')
|
||
assert.equal(m.phone, '0631 111')
|
||
})
|
||
|
||
test('eintragModell: Heilberuf nie mit Nummer (Schloss), unsichere Quelle ohne Link, ohne Quelle der Nummer „nicht verfügbar“, gekürzt mit Schere', () => {
|
||
const praxis = eintragModell({ ...ITEM, id: 'p2', room: 'aerzte', roomLabel: 'Ärzte & Praxen', isHealth: true, sourceUrl: 'javascript:alert(1)' })
|
||
assert.equal(praxis.phone, 'bewusst nicht gespeichert')
|
||
assert.equal(praxis.telefonIcon, 'hk-ic hk-ic-schloss')
|
||
assert.equal(praxis.sourceHref, '')
|
||
assert.equal(praxis.scout, 'Ali')
|
||
// ein Altbestand mit Nummer und Quelle verrät sie bei einem Heilberuf trotzdem nicht
|
||
assert.equal(eintragModell({ ...ITEM, isHealth: true }).phone, 'bewusst nicht gespeichert')
|
||
assert.equal(eintragModell({ ...ITEM, phoneSource: '' }).phone, 'nicht verfügbar')
|
||
assert.equal(eintragModell({ ...ITEM, phoneSource: '' }).telefonIcon, 'hk-ic hk-ic-telefon')
|
||
assert.equal(eintragModell({ ...ITEM, sourceUrl: 'https://user:pw@evil.example/' }).sourceHref, '')
|
||
assert.equal(eintragModell({ ...ITEM, sourceUrl: 'http://alt.example/kontakt' }).sourceHref, 'http://alt.example/kontakt')
|
||
const kuerz = eintragModell({ ...ITEM, name: '[gekürzt]', gekuerzt: true, phone: '', phoneSource: '', sourceUrl: '' })
|
||
assert.equal(kuerz.gekuerzt, true)
|
||
assert.equal(kuerz.telefonIcon, 'hk-ic hk-ic-schere')
|
||
assert.ok(kuerz.label.startsWith('[gekürzt] (gekürzt), '))
|
||
// jedes Symbol des Modells gibt es im CSS
|
||
for (const m of [eintragModell(ITEM), praxis, kuerz]) for (const k of `${m.raumIcon} ${m.grundIcon} ${m.telefonIcon}`.split(' ')) assert.ok(CSS.has(k), k)
|
||
})
|
||
|
||
test('eintragModell: fehlende oder kaputte Werte ergeben Platzhalter, nie undefined, NaN oder einen Fehler', () => {
|
||
for (const kaputt of [null, undefined, 42, 'x', [], {}, { room: 5, score: 'x', reason: null, name: 7 }]) {
|
||
const m = eintragModell(kaputt)
|
||
assert.equal(m.title, 'nicht verfügbar')
|
||
assert.equal(m.scoreLabel, '–')
|
||
assert.equal(m.reason, '–')
|
||
assert.equal(m.raum, '')
|
||
assert.equal(m.raumIcon, 'hk-ic hk-ic-alle')
|
||
assert.equal(m.scout, '')
|
||
assert.deepEqual(m.punkte, { text: '–', breite: 0, breiteGross: 0, farbe: 'leer' })
|
||
assert.equal(m.grundIcon, 'hk-ic hk-ic-akte') // Grund „–“ ist nicht bekannt: neutrales Symbol
|
||
assert.equal(m.sourceHref, '')
|
||
assert.ok(!/undefined|NaN/.test(JSON.stringify(m)), JSON.stringify(m))
|
||
assert.equal(typeof m.label, 'string')
|
||
}
|
||
// unbekannter Raum und unbekannter Grund
|
||
const m = eintragModell({ ...ITEM, room: 'xyz', reason: 'irgendein neuer Grund' })
|
||
assert.equal(m.scout, '')
|
||
assert.equal(m.raumIcon, 'hk-ic hk-ic-alle')
|
||
assert.equal(m.grundIcon, 'hk-ic hk-ic-akte')
|
||
assert.match(m.erklaerung, /Der Hustler schreibt diesem Betrieb nicht/)
|
||
})
|
||
|
||
test('hustlerKeller.js: rein (kein React, kein DOM, kein CSS und keine Bilder), nur Importe aus src/lib', () => {
|
||
const src = read('src/lib/hustlerKeller.js').replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|\s)\/\/.*$/gm, '$1')
|
||
const importe = [...src.matchAll(/^\s*import\b[^'"]*['"]([^'"]+)['"]/gm)].map((m) => m[1])
|
||
assert.deepEqual(importe.sort(), ['./botleadGruende.js', './botleadsView.js', './hustlerSicht.js', './workersRoster.js'])
|
||
assert.doesNotMatch(src, /\b(?:window|document|fetch|localStorage)\b/)
|
||
assert.doesNotMatch(src, /innerHTML/)
|
||
assert.doesNotMatch(src, /\.(?:css|png|svg|jpg)['"]/)
|
||
})
|