Merge origin/main in feature/terminplaner-tp2 (Analyse-Cockpit, Subdomain-Sperre, Projekte)
Konflikte: funktionen.js folgt der Aufteilung aus main (fn-util.js, analyse.js); der Link
'Zu Verträge' der Analyse-Seite kommt jetzt auch in analyse.js aus vertraege-link.js.
Checkout und Team-Ansicht übernehmen assertOwnProject(..., { forNewOrder: true }) und
includeArchived aus main. Test-Pins der absoluten Importe nachgezogen.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Opus 5.5 committed
commit
af63b69ec1
56 files changed
+4583
-717
No files matched your search
@@ -0,0 +1,404 @@
|
||||
import { test } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { headerHtml, tabsHtml, overviewHtml, summaryHtml, kpisHtml, sparkHtml, chartHtml, chartTipText, contactsHtml, rankCardHtml, basisHtml, heatTeaserHtml, skeletonHtml, errorHtml, settingsHtml } from '../public/analyse-cards.js'
|
||||
|
||||
// Testdaten: Form wie analytics/src/stats.js (gleiche Helfer wie test/analyseInsights.test.js)
|
||||
const isoDay = (from, n) => new Date(Date.UTC(+from.slice(0, 4), +from.slice(5, 7) - 1, +from.slice(8, 10) + n)).toISOString().slice(0, 10)
|
||||
const days = (from, n, pv) => Array.from({ length: n }, (_, i) => ({ day: isoDay(from, i), pv: typeof pv === 'function' ? pv(i, isoDay(from, i)) : pv }))
|
||||
const rich = (rows) => rows.map((d) => ({ ...d, visitors: 80, contacts: 6, avgSec: 100 }))
|
||||
const count = (html, re) => (html.match(re) || []).length
|
||||
const t = { pv: 6930, visitors: 2410, contacts: 188, consentRate: 0.61, engaged: 1800, avgSec: 108, avgScroll: 64 }
|
||||
const prev = {
|
||||
from: '2026-08-06', to: '2026-09-04', complete: true,
|
||||
totals: { pv: 6080, visitors: 2200, contacts: 143, consentRate: 0.6, engaged: 1500, avgSec: 114, avgScroll: 60 },
|
||||
series: rich(days('2026-08-06', 30, 203)),
|
||||
contacts: [{ key: 'tel', count: 80 }, { key: 'mail', count: 40 }, { key: 'wa', count: 23 }],
|
||||
}
|
||||
const stats = (over = {}) => ({
|
||||
range: 30, from: '2026-09-05', to: '2026-10-04', firstDay: '2026-07-01',
|
||||
today: { day: '2026-10-05', pv: 42, visitors: 20, contacts: 1 },
|
||||
totals: t,
|
||||
series: rich(days('2026-09-05', 30, (i) => (i === 14 ? 371 : 231))),
|
||||
pages: [{ key: '/', count: 3200 }, { key: '/preise', count: 1310 }, { key: '/kontakt', count: 900 }],
|
||||
refs: [{ key: 'google.com', count: 880 }, { key: '', count: 700 }, { key: 'instagram.com', count: 400 }, { key: 'l.facebook.com', count: 290 }],
|
||||
countries: [{ key: 'DE', count: 6000 }, { key: 'AT', count: 600 }, { key: '', count: 330 }],
|
||||
devices: [{ key: 'm', count: 4590 }, { key: 'd', count: 2200 }, { key: 't', count: 140 }],
|
||||
contacts: [{ key: 'tel', count: 96 }, { key: 'mail', count: 52 }, { key: 'wa', count: 30 }, { key: 'out', count: 10 }],
|
||||
banner: { shown: 3950, accept: 2410, reject: 1540 },
|
||||
previous: prev,
|
||||
...over,
|
||||
})
|
||||
const full = stats()
|
||||
const zeroTotals = { pv: 0, visitors: 0, contacts: 0, consentRate: 0, engaged: 0, avgSec: null, avgScroll: null }
|
||||
const zero = {
|
||||
range: 30, from: '2026-09-05', to: '2026-10-04', firstDay: '',
|
||||
totals: zeroTotals,
|
||||
series: days('2026-09-05', 30, 0).map((d) => ({ ...d, visitors: 0, contacts: 0, avgSec: null })),
|
||||
pages: [], refs: [], countries: [], devices: [], contacts: [], banner: { shown: 0, accept: 0, reject: 0 },
|
||||
previous: { from: '2026-08-06', to: '2026-09-04', complete: false, totals: zeroTotals, series: [], contacts: [] },
|
||||
}
|
||||
const OLD = { totals: { pv: 612, visitors: 214, contacts: 18, consentRate: 0.62 }, series: [{ day: '2026-09-17', pv: 20 }, { day: '2026-09-18', pv: 30 }], pages: [], refs: [], countries: [], devices: [], contacts: [], banner: { shown: 1, accept: 1, reject: 0 } }
|
||||
const project = (over = {}) => ({ projectId: 'p1', projectName: 'Boulderhalle Überhang', analyse: { state: 'active', devMode: false, accentColor: '#1d4ed8', avvVersion: '2026-10-02', legal: { avv: '/rechtliches/avv-website-analyse-2026-10-02.html', lb: '/rechtliches/leistungsbeschreibung-website-analyse-2026-10-02.html' }, activatedAt: '2026-10-01T22:30:00.000Z' }, ...over })
|
||||
|
||||
test('overviewHtml: volle Daten – Kacheln mit Chips, Vorzeitraum-Linie, Kontakte, Quote', () => {
|
||||
const h = overviewHtml(full)
|
||||
assert.match(h, /▲ 14 %/); assert.match(h, /vs\. 6\.080/); assert.match(h, /class="an-prev"/)
|
||||
assert.match(h, /Ø Zeit pro Seite/); assert.match(h, /1:48/); assert.match(h, /Ø 64 % gescrollt/)
|
||||
assert.match(h, /Auf 100 Besucher kommen 7,8 Kontakt-Aktionen \(davor 6,5\)\./)
|
||||
assert.match(h, /61 % haben dem Banner zugestimmt \(2\.410 von 3\.950 Entscheidungen\)/)
|
||||
assert.match(h, /Das Wichtigste · 5\. Sep\. – 4\. Okt\./)
|
||||
assert.match(h, /<b>14 % mehr<\/b>/) // Satz aus summarize
|
||||
assert.match(h, /Länderdaten: IP-Geolocation by <a href="https:\/\/db-ip\.com" target="_blank" rel="noopener">DB-IP<\/a>/)
|
||||
assert.match(h, /data-rank="seen"/); assert.match(h, /data-rank="who"/); assert.match(h, /data-tab="heatmap"/)
|
||||
assert.doesNotMatch(h, /undefined|NaN|Infinity|null/)
|
||||
})
|
||||
|
||||
test('overviewHtml: alter Collector ohne previous/firstDay – keine Chips, kein Fehler', () => {
|
||||
const h = overviewHtml(OLD)
|
||||
assert.doesNotMatch(h, /▲|▼|undefined|NaN|null/); assert.doesNotMatch(h, /class="an-prev"/)
|
||||
assert.doesNotMatch(h, /an-delta/); assert.doesNotMatch(h, /Vergleich ab/)
|
||||
assert.doesNotMatch(h, /Ø \d+ % gescrollt/) // kein avgScroll
|
||||
assert.match(h, /<b class="an-v">612<\/b>/)
|
||||
assert.equal(count(h, /<svg class="an-spark"/g), 1) // nur Seitenaufrufe haben eine Reihe (series hat nur pv)
|
||||
})
|
||||
|
||||
test('overviewHtml: Website ohne Aufrufe – Leerzustand, keine NaN/Infinity', () => {
|
||||
const h = overviewHtml(zero)
|
||||
assert.match(h, /Sobald ein paar mehr Besuche da sind/); assert.match(h, /Noch hat niemand über das Banner entschieden\./)
|
||||
assert.match(h, /Noch keine Kontakt-Aktionen\. Sie zählen, wenn jemand auf deiner Website auf Telefonnummer, E-Mail-Adresse oder WhatsApp tippt\./)
|
||||
assert.doesNotMatch(h, /NaN|Infinity|undefined|null/)
|
||||
assert.doesNotMatch(h, /an-delta|Vergleich ab/) // firstDay '' => kein Datum
|
||||
assert.match(overviewHtml({}), /Sobald ein paar mehr Besuche da sind/) // sogar eine leere Antwort bricht nichts
|
||||
assert.doesNotMatch(overviewHtml({}), /NaN|Infinity|undefined|null/)
|
||||
})
|
||||
|
||||
test('summaryHtml: Satz und Hinweise mit Symbol; Leerzustand unter 30 Aufrufen', () => {
|
||||
const h = summaryHtml(full)
|
||||
assert.match(h, /Deine Website wurde in den letzten 30 Tagen <b>6\.930-mal<\/b> aufgerufen/)
|
||||
assert.equal(count(h, /<li>/g), 4); assert.match(h, /<svg class="an-ico"/)
|
||||
assert.equal(count(h, /aria-hidden="true"><\/svg>/g), 0) // alle Symbole der Hinweise sind belegt
|
||||
assert.match(h, /178-mal hat dich jemand direkt kontaktiert, meist per Telefon \(96\)\./) // ohne die 10 Links nach außen
|
||||
const few = summaryHtml(stats({ totals: { ...t, pv: 12 } }))
|
||||
assert.match(few, /Sobald ein paar mehr Besuche da sind, steht hier das Wichtigste über deine Website in zwei, drei Sätzen\./)
|
||||
assert.doesNotMatch(few, /<ul/)
|
||||
assert.match(summaryHtml({ totals: { pv: 3 } }), /<h3 class="an-eyebrow">Das Wichtigste<\/h3>/) // ohne from/to kein Zeitraum
|
||||
})
|
||||
|
||||
test('kpisHtml: Chips, Vorwerte, Mini-Verläufe, Zeit mit Scrolltiefe', () => {
|
||||
const h = kpisHtml(full)
|
||||
assert.equal(count(h, /class="an-card an-kpi"/g), 4)
|
||||
assert.equal(count(h, /an-delta up/g), 3); assert.equal(count(h, /an-delta down/g), 1)
|
||||
assert.match(h, /▲ 10 %/); assert.match(h, /▲ 31 %/); assert.match(h, /▼ 6 s/)
|
||||
assert.match(h, /vs\. 2\.200/); assert.match(h, /vs\. 143/); assert.match(h, /vs\. 1:54/)
|
||||
assert.match(h, /aria-label="plus 14 Prozent gegenüber dem Zeitraum davor"/)
|
||||
assert.match(h, /Besucher<span class="an-star">\*<\/span>/)
|
||||
assert.equal(count(h, /<svg class="an-spark"/g), 4)
|
||||
// Verlauf der Zeit: Tage ohne Messung (null) fehlen im Verlauf, sie werden nicht als 0 gezeichnet
|
||||
const noTime = kpisHtml(stats({ series: full.series.map((d, i) => ({ ...d, avgSec: i === 0 ? null : 100 })) }))
|
||||
assert.equal(count(noTime, /<svg class="an-spark"/g), 4)
|
||||
const timeLine = (html) => /data-kpi="time".*?class="an-spark-line" d="([^"]*)"/s.exec(html)[1]
|
||||
assert.match(timeLine(noTime), /^M6\.9 /) // der erste Tag (x = 0) fehlt, die Linie beginnt am zweiten
|
||||
assert.equal(count(timeLine(noTime), /M/g), 1)
|
||||
assert.doesNotMatch(timeLine(noTime), /M0 |L0 /)
|
||||
assert.match(timeLine(kpisHtml(full)), /^M0 /) // vollständige Reihe: Linie ab dem ersten Tag
|
||||
// Zählwerte behalten 0: ein Tag ohne Aufrufe ist ein echter Tiefpunkt
|
||||
const zeroPv = kpisHtml(stats({ series: full.series.map((d, i) => ({ ...d, pv: i === 0 ? 0 : 231 })) }))
|
||||
assert.match(/data-kpi="pv".*?class="an-spark-line" d="([^"]*)"/s.exec(zeroPv)[1], /^M0 36 /)
|
||||
// Reihe ohne avgSec-Feld: kein Verlauf bei der Zeit
|
||||
assert.equal(count(kpisHtml(stats({ series: full.series.map(({ avgSec, ...d }) => d) })), /<svg class="an-spark"/g), 3)
|
||||
// keine Zeitmessung: Strich statt "0:00"
|
||||
const none = kpisHtml(stats({ totals: { ...t, avgSec: null, avgScroll: null }, previous: { ...prev, totals: { ...prev.totals, avgSec: null } } }))
|
||||
assert.match(none, /<b class="an-v">–<\/b>/); assert.doesNotMatch(none, /gescrollt|vs\. –/)
|
||||
})
|
||||
|
||||
test('kpisHtml: neue Website zeigt "Vergleich ab 19.11."', () => {
|
||||
const h = kpisHtml(stats({ firstDay: '2026-09-20', previous: { ...prev, complete: false } }))
|
||||
assert.equal(count(h, /Vergleich ab 19\.11\./g), 4)
|
||||
assert.doesNotMatch(h, /an-delta|vs\./)
|
||||
const k7 = kpisHtml(stats({ range: 7, firstDay: '2026-09-28', previous: { ...prev, complete: false } }))
|
||||
assert.match(k7, /Vergleich ab 12\.10\./)
|
||||
// vollständiger Vorzeitraum, aber unter 20 Aufrufen: weder Chip noch Datum
|
||||
const tiny = kpisHtml(stats({ previous: { ...prev, totals: { ...prev.totals, pv: 5 } } }))
|
||||
assert.doesNotMatch(tiny, /an-delta|vs\.|Vergleich ab/)
|
||||
})
|
||||
|
||||
test('kpisHtml: Richtungen – weniger und gleich', () => {
|
||||
const less = kpisHtml(stats({ totals: { ...t, pv: 5000 } }))
|
||||
assert.match(less, /<span class="an-delta down" role="img" aria-label="minus 18 Prozent gegenüber dem Zeitraum davor">▼ 18 %<\/span>/)
|
||||
const same = kpisHtml(stats({ totals: { ...t, contacts: 143 } }))
|
||||
assert.match(same, /an-delta flat/); assert.match(same, /± 0/)
|
||||
})
|
||||
|
||||
test('sparkHtml: Fläche und Linie, nichts bei weniger als 2 Werten, kein NaN', () => {
|
||||
const h = sparkHtml([1, 5, 3, 8])
|
||||
assert.match(h, /<svg class="an-spark" viewBox="0 0 200 38" preserveAspectRatio="none"/)
|
||||
assert.match(h, /class="an-spark-area"/); assert.match(h, /class="an-spark-line"/)
|
||||
assert.equal(sparkHtml([4]), ''); assert.equal(sparkHtml([]), ''); assert.equal(sparkHtml(undefined), '')
|
||||
assert.doesNotMatch(sparkHtml([0, 0, 0]), /NaN|Infinity/)
|
||||
assert.doesNotMatch(sparkHtml([3, null, undefined, 'x']), /NaN|undefined|null/)
|
||||
})
|
||||
|
||||
test('sparkHtml: Lücken (null) unterbrechen die Linie statt als 0 zu gelten', () => {
|
||||
const line = (h) => /class="an-spark-line" d="([^"]*)"/.exec(h)[1]
|
||||
const area = (h) => /class="an-spark-area" d="([^"]*)"/.exec(h)[1]
|
||||
// Wert 0 liegt auf der Grundlinie (y = 36); eine Lücke darf dort keinen Punkt erzeugen
|
||||
const gap = sparkHtml([4, 6, null, 6, 8])
|
||||
assert.equal(count(line(gap), /M/g), 2) // zwei Abschnitte: Tage 0-1 und 3-4
|
||||
assert.doesNotMatch(line(gap), / 36( |$)/)
|
||||
assert.equal(count(area(gap), /Z/g), 2) // Fläche je Abschnitt
|
||||
assert.doesNotMatch(line(gap), /(^|[ML])100 /) // der Tag mit Lücke (x = 100) hat keinen Punkt
|
||||
assert.match(line(sparkHtml([null, 5, 7, 9])), /^M66\.7 /) // Lücke am Anfang: Linie beginnt später, nicht bei 0
|
||||
assert.equal(sparkHtml([null, null, null]), ''); assert.equal(sparkHtml([null, 4]), '') // unter 2 Messwerten nichts
|
||||
assert.doesNotMatch(sparkHtml([4, null, 6]), /NaN|undefined|null/)
|
||||
// alle Werte vorhanden: ein Abschnitt wie bisher
|
||||
assert.equal(count(line(sparkHtml([1, 5, 3, 8])), /M/g), 1)
|
||||
})
|
||||
|
||||
test('chartHtml: Linie, Fläche, Vorzeitraum nur mit Vergleich, Legende, Punkte mit Daten', () => {
|
||||
const h = chartHtml(full)
|
||||
assert.match(h, /<title id="an-chart-title">Seitenaufrufe pro Tag vom 05\.09\. bis 04\.10\., insgesamt 7\.\d{3}<\/title>/)
|
||||
assert.match(h, /class="an-area"/); assert.match(h, /class="an-line"/); assert.match(h, /class="an-prev"/)
|
||||
assert.match(h, /30 Tage/); assert.match(h, /Zeitraum davor/)
|
||||
assert.equal(count(h, /class="an-dot"/g), 30)
|
||||
assert.match(h, /data-i="14" /); assert.match(h, /data-day="2026-09-19"/); assert.match(h, /data-pv="371"/); assert.match(h, /data-prev="203"/)
|
||||
assert.match(h, /class="an-tip"/)
|
||||
// ohne Vergleich: keine gestrichelte Linie, keine zweite Legende, kein data-prev
|
||||
const nc = chartHtml(stats({ previous: { ...prev, complete: false } }))
|
||||
assert.doesNotMatch(nc, /class="an-prev"|Zeitraum davor|data-prev/)
|
||||
assert.match(nc, /30 Tage/)
|
||||
// ganz ohne Daten
|
||||
assert.match(chartHtml({ series: [] }), /Noch keine Daten\./)
|
||||
assert.doesNotMatch(chartHtml(zero), /NaN|Infinity|undefined|null/)
|
||||
})
|
||||
|
||||
test('chartHtml: Achsenbeschriftung hat Platz – y-Rand wächst mit der Stellenzahl, x-Beschriftungen überlappen nicht', () => {
|
||||
const padOf = (html) => Number(/class="an-grid" x1="([\d.]+)"/.exec(html)[1])
|
||||
const series = (pv, n = 30) => days('2026-09-05', n, pv).map((d) => ({ ...d, visitors: 1, contacts: 0, avgSec: 1 }))
|
||||
const none = { previous: { ...prev, complete: false } }
|
||||
// Skala 500 (3 Zeichen), 5.000 (4), 20.000 (5), 50 (2): Platz für die Ziffern der y-Beschriftung
|
||||
assert.equal(padOf(chartHtml(stats({ series: series(300), ...none }))), 49)
|
||||
assert.equal(padOf(chartHtml(stats({ series: series(2400), ...none }))), 64)
|
||||
assert.equal(padOf(chartHtml(stats({ series: series(12000), ...none }))), 78)
|
||||
assert.equal(padOf(chartHtml(stats({ series: series(30), ...none }))), 40)
|
||||
// y-Beschriftung steht rechtsbündig 6 Einheiten vor dem Raster und ist an der Gitterlinie zentriert
|
||||
const h = chartHtml(stats({ series: series(2400), ...none }))
|
||||
assert.match(h, /<text class="an-axis" x="58" y="[\d.]+" dy="0\.35em" text-anchor="end">5000<\/text>/)
|
||||
// x-Beschriftungen: nie näher als 100 Einheiten (Platz für "29.09." in der größten Schrift), letzter Tag bleibt
|
||||
for (const n of [7, 30, 90]) {
|
||||
const xs = [...chartHtml(stats({ series: series(300, n), ...none })).matchAll(/class="an-axis" x="([\d.]+)" y="[\d.]+" text-anchor="middle"/g)].map((m) => Number(m[1]))
|
||||
assert.ok(xs.length >= 3, `range ${n}`)
|
||||
assert.ok(xs.every((x, i) => !i || x - xs[i - 1] >= 100), `range ${n}: ${xs}`)
|
||||
assert.equal(xs[xs.length - 1], 616) // 640 - rechter Rand 24: der letzte Tag
|
||||
}
|
||||
})
|
||||
|
||||
test('chartTipText: Blase mit und ohne Vorwert', () => {
|
||||
assert.equal(chartTipText('2026-09-19', 371, 210), 'Sa., 19.09.: 371 Aufrufe (davor 210)')
|
||||
assert.equal(chartTipText('2026-09-19', '371', '210'), 'Sa., 19.09.: 371 Aufrufe (davor 210)') // Werte aus data-Attributen sind Strings
|
||||
assert.equal(chartTipText('2026-09-19', 371), 'Sa., 19.09.: 371 Aufrufe')
|
||||
assert.equal(chartTipText('2026-09-19', 371, null), 'Sa., 19.09.: 371 Aufrufe')
|
||||
assert.equal(chartTipText('2026-09-19', 1, 0), 'Sa., 19.09.: 1 Aufruf (davor 0)')
|
||||
assert.equal(chartTipText('2026-09-19', 6930, 6080), 'Sa., 19.09.: 6.930 Aufrufe (davor 6.080)')
|
||||
})
|
||||
|
||||
test('contactsHtml: Arten mit 0 in beiden Zeiträumen entfallen, Leertext ohne Kontakte', () => {
|
||||
const h = contactsHtml(full)
|
||||
assert.match(h, /<b class="an-sum-n">188<\/b>/)
|
||||
assert.equal(count(h, /aria-hidden="true"><\/svg>/g), 0) // jede Zeile hat ihr Symbol
|
||||
assert.equal(count(h, /<svg class="an-ico"/g), 4)
|
||||
for (const label of ['Anrufe', 'E-Mails', 'WhatsApp', 'Links nach außen']) assert.match(h, new RegExp(label))
|
||||
assert.match(h, /data-kind="tel"[^]*?<b>96<\/b>[^]*?▲ 16/) // 96 vs 80: beide unter 100 => absolut statt Prozent
|
||||
assert.match(h, /data-kind="out"[^]*?<b>10<\/b>[^]*?▲ 10/) // 10 vs 0
|
||||
// Art ohne Kontakte, in beiden Zeiträumen 0: Zeile entfällt
|
||||
const noOut = contactsHtml(stats({ contacts: [{ key: 'tel', count: 96 }, { key: 'mail', count: 52 }, { key: 'out', count: 0 }], totals: { ...t, contacts: 148 }, previous: { ...prev, contacts: [{ key: 'tel', count: 80 }, { key: 'mail', count: 40 }] } }))
|
||||
assert.doesNotMatch(noOut, /data-kind="out"|data-kind="wa"|WhatsApp|Links nach außen/)
|
||||
assert.match(noOut, /data-kind="tel"/); assert.match(noOut, /data-kind="mail"/)
|
||||
// Vorzeitraum hatte WhatsApp, jetzt 0: Zeile bleibt mit ▼
|
||||
const lost = contactsHtml(stats({ contacts: [{ key: 'tel', count: 96 }], totals: { ...t, contacts: 96 } }))
|
||||
assert.match(lost, /data-kind="wa"[^]*?<b>0<\/b>[^]*?▼ 23/)
|
||||
// ohne Vergleich: keine Chips, Zeilen nur mit Kontakten
|
||||
const nc = contactsHtml(stats({ previous: { ...prev, complete: false } }))
|
||||
assert.doesNotMatch(nc, /an-delta|davor/); assert.match(nc, /data-kind="tel"/)
|
||||
// Leertext
|
||||
const none = contactsHtml(zero)
|
||||
assert.match(none, /Noch keine Kontakt-Aktionen\. Sie zählen, wenn jemand auf deiner Website auf Telefonnummer, E-Mail-Adresse oder WhatsApp tippt\./)
|
||||
assert.doesNotMatch(none, /data-kind|an-quote/)
|
||||
// 0 Kontakte, aber der Vorzeitraum hatte welche: weiter Leertext (Kopfzahl 0)
|
||||
assert.match(contactsHtml(stats({ totals: { ...t, contacts: 0 }, contacts: [] })), /Noch keine Kontakt-Aktionen\./)
|
||||
})
|
||||
|
||||
test('contactsHtml: Quote pro 100 Besucher, mit und ohne Vorwert, erst ab 30 Besuchern', () => {
|
||||
assert.match(contactsHtml(full), /<p class="an-quote">Auf 100 Besucher kommen 7,8 Kontakt-Aktionen \(davor 6,5\)\.<\/p>/)
|
||||
const nc = contactsHtml(stats({ previous: { ...prev, complete: false } }))
|
||||
assert.match(nc, /Auf 100 Besucher kommen 7,8 Kontakt-Aktionen\./)
|
||||
const fewPrev = contactsHtml(stats({ previous: { ...prev, totals: { ...prev.totals, visitors: 10 } } }))
|
||||
assert.match(fewPrev, /Auf 100 Besucher kommen 7,8 Kontakt-Aktionen\./) // Vorquote unsicher => ohne "davor"
|
||||
assert.doesNotMatch(contactsHtml(stats({ totals: { ...t, visitors: 29, contacts: 3 }, contacts: [{ key: 'tel', count: 3 }] })), /an-quote/)
|
||||
assert.match(contactsHtml(stats({ totals: { ...t, visitors: 400, contacts: 28 } })), /kommen 7,0 Kontakt-Aktionen/) // immer eine Nachkommastelle
|
||||
})
|
||||
|
||||
test('rankCardHtml: Startseite statt /, Anteil in %, 6 Zeilen, expanded bis 20, Herkunft mit refName, Pfad maskiert', () => {
|
||||
const h = rankCardHtml('seen', stats({ pages: [{ key: '/<img src=x>', count: 9 }] }))
|
||||
assert.match(h, /<img src=x>/); assert.doesNotMatch(h, /<img src=x>/)
|
||||
const pages = rankCardHtml('seen', full)
|
||||
assert.match(pages, /Startseite/); assert.doesNotMatch(pages, />\/</)
|
||||
assert.match(pages, /<b>3\.200<\/b><em>46 %<\/em>/) // 3200 von 6930 Aufrufen (die Liste zeigt nur 5410 davon)
|
||||
assert.match(pages, /data-rank="seen" data-rank-active="pages"/)
|
||||
assert.match(pages, /<h3>Was angesehen wird<\/h3>/)
|
||||
assert.match(pages, /data-rank-tab="pages" aria-pressed="true"/); assert.match(pages, /data-rank-tab="refs" aria-pressed="false"/)
|
||||
// Herkunft
|
||||
const refs = rankCardHtml('seen', full, { tab: 'refs' })
|
||||
assert.match(refs, /Google/); assert.match(refs, /Direkt oder unbekannt/); assert.match(refs, /Instagram/); assert.match(refs, /Facebook/)
|
||||
assert.doesNotMatch(refs, /google\.com|l\.facebook/); assert.match(refs, /data-rank-active="refs"/)
|
||||
// 6 Zeilen, "Alle anzeigen" nur bei mehr als 6; expanded bis 20
|
||||
const many = stats({ pages: Array.from({ length: 25 }, (_, i) => ({ key: `/seite-${i}`, count: 100 - i })) })
|
||||
const six = rankCardHtml('seen', many)
|
||||
assert.equal(count(six, /class="an-lr"/g), 6); assert.match(six, /data-rank-more[^>]*>Alle anzeigen</)
|
||||
const open = rankCardHtml('seen', many, { expanded: true })
|
||||
assert.equal(count(open, /class="an-lr"/g), 20); assert.doesNotMatch(open, /Alle anzeigen/)
|
||||
assert.doesNotMatch(rankCardHtml('seen', stats({ pages: Array.from({ length: 6 }, (_, i) => ({ key: `/s${i}`, count: 9 })) })), /Alle anzeigen/)
|
||||
assert.equal(count(rankCardHtml('seen', stats({ pages: Array.from({ length: 6 }, (_, i) => ({ key: `/s${i}`, count: 9 })) })), /class="an-lr"/g), 6)
|
||||
assert.match(rankCardHtml('seen', many), /an-fill" style="width:100%"/) // größter Wert = volle Breite
|
||||
})
|
||||
|
||||
test('rankCardHtml: Geräte, Länder mit Flagge, ungültiger Reiter, leere Liste, Anteil unter 1 %', () => {
|
||||
const dev = rankCardHtml('who', full)
|
||||
assert.match(dev, /<h3>Wer zu Besuch ist<\/h3>/); assert.match(dev, /Handy/); assert.match(dev, /Computer/); assert.match(dev, /Tablet/)
|
||||
assert.match(dev, /<b>4\.590<\/b><em>66 %<\/em>/)
|
||||
assert.match(rankCardHtml('who', stats({ devices: [{ key: 'x', count: 2 }, { key: 'constructor', count: 1 }] })), /Unbekannt/)
|
||||
const land = rankCardHtml('who', full, { tab: 'countries' })
|
||||
assert.match(land, /🇩🇪/); assert.match(land, /Deutschland/); assert.match(land, /Österreich/); assert.match(land, /Unbekannt/)
|
||||
assert.match(rankCardHtml('who', full, { tab: 'pages' }), /data-rank-active="devices"/) // Reiter einer anderen Karte => erster Reiter
|
||||
assert.match(rankCardHtml('seen', stats({ pages: [] })), /Noch keine Daten\./)
|
||||
assert.equal(rankCardHtml('nope', full), '')
|
||||
const tiny = rankCardHtml('seen', stats({ pages: [{ key: '/a', count: 10000 }, { key: '/b', count: 1 }] }))
|
||||
assert.match(tiny, /<em>< 1 %<\/em>/)
|
||||
assert.doesNotMatch(rankCardHtml('seen', stats({ pages: [{ key: '/a', count: 0 }] })), /NaN|Infinity/)
|
||||
// Nenner: Seiten, Länder, Geräte relativ zu max(Summe der Liste, Seitenaufrufe); Herkunft nur zur Summe der Liste
|
||||
const part = stats({ totals: { ...t, pv: 1000 }, pages: [{ key: '/a', count: 300 }, { key: '/b', count: 100 }], countries: [{ key: 'DE', count: 250 }], devices: [{ key: 'm', count: 500 }], refs: [{ key: 'google.com', count: 30 }, { key: '', count: 10 }] })
|
||||
assert.match(rankCardHtml('seen', part), /<b>300<\/b><em>30 %<\/em>/) // 300 von 1000, nicht von 400 (75 %)
|
||||
assert.match(rankCardHtml('who', part, { tab: 'countries' }), /<b>250<\/b><em>25 %<\/em>/)
|
||||
assert.match(rankCardHtml('who', part), /<b>500<\/b><em>50 %<\/em>/)
|
||||
assert.match(rankCardHtml('seen', part, { tab: 'refs' }), /<b>30<\/b><em>75 %<\/em>/) // Herkunft: 30 von 40
|
||||
// Liste größer als die Gesamtzahl (Zählungen laufen auseinander): die Summe, nie mehr als 100 %
|
||||
const over = stats({ totals: { ...t, pv: 100 }, pages: [{ key: '/a', count: 300 }, { key: '/b', count: 100 }] })
|
||||
assert.match(rankCardHtml('seen', over), /<b>300<\/b><em>75 %<\/em>/)
|
||||
// ohne totals (alter Collector): Summe der Liste
|
||||
assert.match(rankCardHtml('seen', { pages: [{ key: '/a', count: 3 }, { key: '/b', count: 1 }] }), /<em>75 %<\/em>/)
|
||||
// Länder-Schlüssel maskiert
|
||||
const bad = rankCardHtml('who', stats({ countries: [{ key: '<b>', count: 3 }] }), { tab: 'countries' })
|
||||
assert.match(bad, /Unbekannt/); assert.doesNotMatch(bad, /<b><|<b>&/); assert.doesNotMatch(bad, /an-flag/)
|
||||
})
|
||||
|
||||
test('basisHtml: Ring, Sätze mit und ohne Entscheidungen', () => {
|
||||
const h = basisHtml(full)
|
||||
assert.match(h, /<text class="an-ring-n"[^>]*>61 %<\/text>/); assert.match(h, /class="an-ring-fg"/)
|
||||
assert.match(h, /Seitenaufrufe zählen wir vollständig; Besucher, Kontakt-Aktionen und Zeit pro Seite \(\*\) nur bei Zustimmung\./)
|
||||
const none = basisHtml(zero)
|
||||
assert.match(none, /Noch hat niemand über das Banner entschieden\./); assert.doesNotMatch(none, /an-ring-fg|haben dem Banner zugestimmt|NaN/)
|
||||
assert.match(none, />–<\/text>/)
|
||||
assert.match(basisHtml(stats({ banner: { shown: 1, accept: 1, reject: 0 }, totals: { ...t, consentRate: 1 } })), /\(1 von 1 Entscheidung\)/)
|
||||
assert.doesNotMatch(basisHtml({}), /NaN|undefined|null/)
|
||||
})
|
||||
|
||||
test('headerHtml: Auswahl nur bei mehreren Websites, Zeitraum nur bei showRange, Dev-Hinweis, Name maskiert', () => {
|
||||
const a = project()
|
||||
const b = { projectId: 'p2', projectName: 'Café "Zum <Bären>"' }
|
||||
const one = headerHtml({ project: a, usable: [a], range: 30, showRange: true, devMode: false, stamp: '19:42', today: { day: '2026-10-05', pv: 1234, visitors: 80, contacts: 3 } })
|
||||
assert.doesNotMatch(one, /an-project|<select/); assert.match(one, /<b class="an-site-name">Boulderhalle Überhang<\/b>/)
|
||||
assert.match(one, /<small class="an-status"><span class="an-st">Analyse aktiv<\/span> · <span class="an-st">Heute bisher: 1\.234 Aufrufe<\/span> · <span class="an-st">Stand: 19:42 Uhr<\/span><\/small>/)
|
||||
assert.match(one, /<button type="button" class="on" data-range="30" aria-pressed="true">30 Tage<\/button>/)
|
||||
assert.equal(count(one, /data-range="/g), 3); assert.match(one, /data-range="7"[^>]*aria-pressed="false"/)
|
||||
const two = headerHtml({ project: b, usable: [a, b], range: 7, showRange: false, devMode: false, stamp: '' })
|
||||
assert.match(two, /<select id="an-project"/); assert.match(two, /<option value="p2" selected>Café "Zum <Bären>"<\/option>/)
|
||||
assert.match(two, /<option value="p1">Boulderhalle Überhang<\/option>/)
|
||||
assert.doesNotMatch(two, /data-range/); assert.doesNotMatch(two, /Zum <Bären>/); assert.doesNotMatch(two, /Stand:/)
|
||||
assert.match(two, /Analyse aktiv/); assert.doesNotMatch(two, /Heute bisher/) // ohne today (alter Collector) entfällt der Teil
|
||||
assert.match(headerHtml({ project: a, usable: [a], range: 365, showRange: true }), /class="on" data-range="30"/) // unbekannter Zeitraum => 30
|
||||
// Dev-Modus
|
||||
const dev = headerHtml({ project: a, usable: [a], range: 30, showRange: true, devMode: true, stamp: '19:42' })
|
||||
assert.match(dev, /Im Dev-Modus wird nicht gemessen\./); assert.doesNotMatch(dev, /Analyse aktiv|Stand:|Heute bisher/); assert.match(dev, /data-state="warn"/)
|
||||
assert.match(one, /data-state="on"/)
|
||||
// Name maskiert
|
||||
const evil = headerHtml({ project: { projectId: 'x', projectName: '<img src=x onerror=alert(1)>' }, usable: [], range: 30, showRange: false })
|
||||
assert.doesNotMatch(evil, /<img/); assert.match(evil, /<img src=x onerror=alert\(1\)>/)
|
||||
const odd = headerHtml({ project: { projectId: 'p"1', projectName: 'A' }, usable: [{ projectId: 'p"1', projectName: 'A' }, { projectId: 'p2', projectName: 'B' }], stamp: '<b>x</b>', today: { pv: '<i>5</i>' } })
|
||||
assert.match(odd, /value="p"1" selected/); assert.match(odd, /Stand: <b>x<\/b> Uhr/); assert.doesNotMatch(odd, /<b>x|<i>/)
|
||||
// Heute bisher: Einzahl, 0 und nur mit Zahl; ohne Uhrzeit nur der Zähler
|
||||
const today = (pv, stamp = '') => headerHtml({ project: a, usable: [a], range: 30, showRange: false, stamp, today: { day: '2026-10-05', pv, visitors: 0, contacts: 0 } })
|
||||
const plain = (h) => /<small class="an-status">(.*?)<\/small>/.exec(h)[1].replace(/<[^>]+>/g, '') // Text ohne die Umbruch-Spans
|
||||
assert.equal(plain(today(1, '08:05')), 'Analyse aktiv · Heute bisher: 1 Aufruf · Stand: 08:05 Uhr')
|
||||
assert.match(today(0, '08:05'), /Heute bisher: 0 Aufrufe/)
|
||||
assert.equal(plain(today(42)), 'Analyse aktiv · Heute bisher: 42 Aufrufe')
|
||||
assert.doesNotMatch(headerHtml({ project: a, usable: [a], today: {} }), /Heute bisher|NaN/) // today ohne pv: nichts behaupten
|
||||
// Zustände ohne Messung zeigen kein "Heute bisher"
|
||||
assert.doesNotMatch(headerHtml({ project: project({ analyse: { state: 'disabled' } }), usable: [], today: { pv: 5 } }), /Heute bisher/)
|
||||
// Zustände ohne Messung sagen nicht "aktiv"
|
||||
const off = headerHtml({ project: project({ analyse: { state: 'off', eligible: true } }), usable: [], range: 30, showRange: false })
|
||||
assert.doesNotMatch(off, /Analyse aktiv/); assert.match(off, /data-state="off"/)
|
||||
assert.match(headerHtml({ project: project({ analyse: { state: 'disabled' } }), usable: [] }), /Analyse ist abgeschaltet/)
|
||||
assert.match(headerHtml({ project: project({ analyse: { state: 'off', eligible: false } }), usable: [] }), /Analyse nicht verfügbar/)
|
||||
assert.doesNotMatch(headerHtml({}), /undefined|null|NaN/)
|
||||
})
|
||||
|
||||
test('tabsHtml: tablist, drei Reiter, aria-selected', () => {
|
||||
const h = tabsHtml('heatmap')
|
||||
assert.match(h, /role="tablist"/); assert.equal(count(h, /role="tab"/g), 3)
|
||||
for (const k of ['uebersicht', 'heatmap', 'einstellungen']) assert.match(h, new RegExp(`data-tab="${k}"`))
|
||||
assert.match(h, /data-tab="heatmap" aria-selected="true"/); assert.match(h, /data-tab="uebersicht" aria-selected="false"/)
|
||||
assert.equal(count(h, /aria-selected="true"/g), 1)
|
||||
assert.match(tabsHtml('quatsch'), /data-tab="uebersicht" aria-selected="true"/)
|
||||
assert.match(h, />Übersicht<\/button>/); assert.match(h, />Heatmap<\/button>/); assert.match(h, />Einstellungen<\/button>/)
|
||||
})
|
||||
|
||||
test('heatTeaserHtml: Knopf wechselt in den Reiter Heatmap', () => {
|
||||
const h = heatTeaserHtml()
|
||||
assert.match(h, /<button type="button" class="an-btn" data-tab="heatmap">Öffnen<\/button>/); assert.match(h, /<h3>Heatmap<\/h3>/)
|
||||
assert.match(h, /an-mini-heat/)
|
||||
})
|
||||
|
||||
test('settingsHtml: aktiv seit TT.MM.JJJJ, Farbfeld, Fassung, Links AVV und Leistungsbeschreibung, #an-off', () => {
|
||||
const h = settingsHtml(project())
|
||||
assert.match(h, /aktiv seit 02\.10\.2026/) // 22:30 UTC = 00:30 Berlin am 02.10.
|
||||
assert.match(h, /class="an-swatch" style="background:#1d4ed8"/); assert.match(h, /#1d4ed8/)
|
||||
assert.match(h, /Fassung 2026-10-02/)
|
||||
assert.match(h, /<a href="\/rechtliches\/avv-website-analyse-2026-10-02\.html" target="_blank" rel="noopener">Auftragsverarbeitungsvertrag Website-Analyse<\/a>/)
|
||||
assert.match(h, /<a href="\/rechtliches\/leistungsbeschreibung-website-analyse-2026-10-02\.html" target="_blank" rel="noopener">Leistungsbeschreibung Website-Analyse<\/a>/)
|
||||
assert.match(h, /<section class="an-card" id="an-off"><\/section>/)
|
||||
// Farbe ungültig => #111111; kein Datum => ohne "seit"
|
||||
const bad = settingsHtml(project({ analyse: { state: 'active', accentColor: 'red;"><x>', avvVersion: '2026-10-02', legal: {}, activatedAt: null } }))
|
||||
assert.match(bad, /background:#111111/); assert.doesNotMatch(bad, /<x>|seit|<a /)
|
||||
assert.match(bad, /id="an-off"/)
|
||||
// zu helle Farbe: das Banner nutzt Schwarz, das Farbfeld zeigt dasselbe (bannerColor)
|
||||
const light = settingsHtml(project({ analyse: { state: 'active', accentColor: '#ffee00', avvVersion: '2026-10-02', legal: {}, activatedAt: null } }))
|
||||
assert.match(light, /class="an-swatch" style="background:#111111"/); assert.doesNotMatch(light, /#ffee00/i)
|
||||
assert.match(settingsHtml(project({ analyse: { state: 'active', accentColor: '#1D4ED8' } })), /background:#1d4ed8/) // groß geschrieben => klein
|
||||
// gefährliche Link-Ziele und Namen
|
||||
const evil = settingsHtml(project({ analyse: { state: 'active', accentColor: '#fff', avvVersion: '<b>', legal: { avv: 'javascript:alert(1)', lb: '/x"onmouseover="y' }, activatedAt: 'kaputt' } }))
|
||||
assert.doesNotMatch(evil, /javascript:|<b>|onmouseover="y/); assert.doesNotMatch(evil, /NaN|undefined|null|Invalid/)
|
||||
assert.doesNotMatch(settingsHtml({ projectId: 'p' }), /NaN|undefined|null|Invalid/)
|
||||
})
|
||||
|
||||
test('errorHtml und skeletonHtml', () => {
|
||||
assert.match(errorHtml('Auswertung gerade nicht erreichbar'), /id="an-retry"/)
|
||||
assert.match(errorHtml('Auswertung gerade nicht erreichbar'), /Auswertung gerade nicht erreichbar/); assert.match(errorHtml('x'), /role="alert"/); assert.match(errorHtml('x'), />Neu laden</)
|
||||
assert.match(errorHtml('<img src=x>'), /<img src=x>/); assert.doesNotMatch(errorHtml('<img src=x>'), /<img/)
|
||||
const sk = skeletonHtml()
|
||||
assert.equal(count(sk, /class="an-card an-kpi an-sk"/g), 4); assert.match(sk, /aria-busy="true"/)
|
||||
assert.doesNotMatch(sk, /Lade…|undefined|NaN/)
|
||||
})
|
||||
|
||||
test('Alle Bausteine: Werte aus Daten werden maskiert (Pfade, Hosts, Tage, Länder)', () => {
|
||||
const evil = '"><script>alert(1)</script>'
|
||||
const s = stats({
|
||||
pages: [{ key: evil, count: 5 }],
|
||||
refs: [{ key: evil, count: 5 }],
|
||||
countries: [{ key: evil, count: 5 }],
|
||||
devices: [{ key: evil, count: 5 }],
|
||||
series: [{ day: evil, pv: 5 }, { day: '2026-09-18', pv: 7 }],
|
||||
previous: { ...prev, series: [{ pv: 3 }, { pv: 4 }] },
|
||||
})
|
||||
const all = overviewHtml(s) + rankCardHtml('seen', s, { tab: 'refs' }) + rankCardHtml('who', s, { tab: 'countries' }) + rankCardHtml('who', s) + chartHtml(s)
|
||||
assert.doesNotMatch(all, /<script>/)
|
||||
assert.match(all, /<script>/)
|
||||
})
|
||||
@@ -0,0 +1,289 @@
|
||||
import { test } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { delta, fmtDuration, fmtNum, dayLabel, periodLabel, compareFrom, contactRate, refName, weekdayStats, summarize, chartModel } from '../public/analyse-view.js'
|
||||
|
||||
// Testdaten: eine vollstaendige Statistik-Antwort mit 30 Tagen (Form wie analytics/src/stats.js)
|
||||
const isoDay = (from, n) => new Date(Date.UTC(+from.slice(0, 4), +from.slice(5, 7) - 1, +from.slice(8, 10) + n)).toISOString().slice(0, 10)
|
||||
const days = (from, n, pv) => Array.from({ length: n }, (_, i) => ({ day: isoDay(from, i), pv: typeof pv === 'function' ? pv(i, isoDay(from, i)) : pv }))
|
||||
const t = { pv: 6930, visitors: 2410, contacts: 188, consentRate: 0.61, engaged: 1800, avgSec: 108, avgScroll: 64 }
|
||||
const prev = {
|
||||
from: '2026-08-06', to: '2026-09-04', complete: true,
|
||||
totals: { pv: 6080, visitors: 2200, contacts: 143, consentRate: 0.6, engaged: 1500, avgSec: 114, avgScroll: 60 },
|
||||
series: days('2026-08-06', 30, 203),
|
||||
contacts: [{ key: 'tel', count: 80 }, { key: 'mail', count: 40 }, { key: 'wa', count: 23 }],
|
||||
}
|
||||
const stats = (over = {}) => ({
|
||||
range: 30, from: '2026-09-05', to: '2026-10-04', firstDay: '2026-07-01',
|
||||
today: { day: '2026-10-05', pv: 42, visitors: 20, contacts: 1 },
|
||||
totals: t,
|
||||
series: days('2026-09-05', 30, 231),
|
||||
pages: [{ key: '/', count: 3200 }, { key: '/preise', count: 1310 }, { key: '/kontakt', count: 900 }],
|
||||
refs: [{ key: 'google.com', count: 880 }, { key: '', count: 700 }, { key: 'instagram.com', count: 400 }, { key: 'l.facebook.com', count: 290 }],
|
||||
countries: [{ key: 'DE', count: 6000 }],
|
||||
devices: [{ key: 'm', count: 4590 }, { key: 'd', count: 2200 }, { key: 't', count: 140 }],
|
||||
contacts: [{ key: 'tel', count: 96 }, { key: 'mail', count: 52 }, { key: 'wa', count: 30 }, { key: 'out', count: 10 }],
|
||||
banner: { shown: 3950, accept: 2410, reject: 1540 },
|
||||
previous: prev,
|
||||
...over,
|
||||
})
|
||||
|
||||
test('delta: Prozent ab 100, sonst absolut, flat, Sekunden, null', () => {
|
||||
assert.deepEqual(delta(6930, 6080), { dir: 'up', text: '▲ 14 %', aria: 'plus 14 Prozent gegenüber dem Zeitraum davor' })
|
||||
assert.equal(delta(188, 143).text, '▲ 31 %') // beide ≥ 100 → Prozent
|
||||
assert.equal(delta(45, 33).text, '▲ 12')
|
||||
assert.equal(delta(30, 33).text, '▼ 3')
|
||||
assert.deepEqual(delta(7, 7), { dir: 'flat', text: '± 0', aria: 'unverändert gegenüber dem Zeitraum davor' })
|
||||
assert.equal(delta(1004, 1000).text, '± 0 %') // |0,4 %| < 1
|
||||
assert.equal(delta(1004, 1000).dir, 'flat')
|
||||
assert.equal(delta(108, 114, { kind: 'sec' }).text, '▼ 6 s')
|
||||
assert.equal(delta(200, 135, { kind: 'sec' }).text, '▲ 1:05')
|
||||
assert.equal(delta(null, 3), null)
|
||||
assert.equal(delta(3, undefined), null)
|
||||
assert.equal(delta('3', 4), null)
|
||||
})
|
||||
|
||||
test('delta: Richtung und aria in Wörtern', () => {
|
||||
assert.deepEqual(delta(5000, 6000), { dir: 'down', text: '▼ 17 %', aria: 'minus 17 Prozent gegenüber dem Zeitraum davor' })
|
||||
assert.equal(delta(45, 33).aria, 'plus 12 gegenüber dem Zeitraum davor')
|
||||
assert.equal(delta(30, 33).aria, 'minus 3 gegenüber dem Zeitraum davor')
|
||||
assert.equal(delta(108, 114, { kind: 'sec' }).aria, 'minus 6 Sekunden gegenüber dem Zeitraum davor')
|
||||
assert.equal(delta(200, 135, { kind: 'sec' }).aria, 'plus 1 Minute 5 Sekunden gegenüber dem Zeitraum davor')
|
||||
assert.equal(delta(240, 120, { kind: 'sec' }).aria, 'plus 2 Minuten gegenüber dem Zeitraum davor')
|
||||
})
|
||||
|
||||
test('fmtDuration, dayLabel, periodLabel, fmtNum', () => {
|
||||
assert.equal(fmtDuration(108), '1:48'); assert.equal(fmtDuration(7), '0:07'); assert.equal(fmtDuration(null), '–')
|
||||
assert.equal(fmtDuration(NaN), '–'); assert.equal(fmtDuration(-3), '–'); assert.equal(fmtDuration(undefined), '–')
|
||||
assert.equal(dayLabel('2026-09-19'), 'Sa., 19.09.')
|
||||
assert.equal(dayLabel('2026-09-20'), 'So., 20.09.')
|
||||
assert.equal(periodLabel('2026-09-05', '2026-10-04'), '5. Sep. – 4. Okt.')
|
||||
assert.equal(periodLabel('2026-03-01', '2026-06-30'), '1. März – 30. Juni')
|
||||
assert.equal(periodLabel('', ''), '')
|
||||
assert.equal(periodLabel('2026-09-05', ''), '')
|
||||
assert.equal(fmtNum(6930), '6.930')
|
||||
assert.equal(fmtNum(0), '0')
|
||||
assert.equal(fmtNum(1234567), '1.234.567')
|
||||
})
|
||||
|
||||
test('compareFrom: ok, Datum bei neuer Website, nichts ohne previous', () => {
|
||||
assert.deepEqual(compareFrom(stats()), { ok: true, from: '' })
|
||||
assert.deepEqual(compareFrom(stats({ firstDay: '2026-09-20', previous: { ...prev, complete: false } })), { ok: false, from: '19.11.' }) // range 30: +60 Tage (2 × range, der erste Tag mit vollem Vorzeitraum)
|
||||
assert.deepEqual(compareFrom(stats({ range: 7, firstDay: '2026-09-28', previous: { ...prev, complete: false } })), { ok: false, from: '12.10.' }) // range 7: +14 Tage
|
||||
assert.deepEqual(compareFrom(stats({ firstDay: '', previous: { ...prev, complete: false } })), { ok: false, from: '' })
|
||||
assert.deepEqual(compareFrom({ totals: { pv: 50 }, series: [] }), { ok: false, from: '' })
|
||||
assert.equal(compareFrom(stats({ previous: { ...prev, totals: { ...prev.totals, pv: 19 } } })).ok, false)
|
||||
assert.equal(compareFrom(stats({ previous: { ...prev, totals: { ...prev.totals, pv: 20 } } })).ok, true)
|
||||
})
|
||||
|
||||
test('contactRate und refName', () => {
|
||||
assert.equal(contactRate(188, 2410), 7.8); assert.equal(contactRate(5, 29), null)
|
||||
assert.equal(contactRate(0, 30), 0); assert.equal(contactRate(null, 100), null)
|
||||
assert.equal(refName('www.google.de'), 'Google'); assert.equal(refName('l.facebook.com'), 'Facebook'); assert.equal(refName(''), 'Direkt oder unbekannt'); assert.equal(refName('blog.example'), 'blog.example')
|
||||
assert.equal(refName('google.com'), 'Google'); assert.equal(refName('google.co.uk'), 'Google')
|
||||
assert.equal(refName('www.bing.com'), 'Bing'); assert.equal(refName('l.instagram.com'), 'Instagram')
|
||||
assert.equal(refName('m.facebook.com'), 'Facebook'); assert.equal(refName('facebook.com'), 'Facebook')
|
||||
assert.equal(refName('duckduckgo.com'), 'DuckDuckGo'); assert.equal(refName('www.ecosia.org'), 'Ecosia')
|
||||
assert.equal(refName('notgoogle.com'), 'notgoogle.com'); assert.equal(refName('google.evil.de'), 'google.evil.de')
|
||||
assert.equal(refName('Google.DE'), 'Google')
|
||||
})
|
||||
|
||||
test('weekdayStats: stärkster Wochentag, Spitzentag, < 7 Tage null', () => {
|
||||
// 05.09.2026 ist ein Samstag: 5 Samstage mit 20, alle anderen 10 → Schnitt 11,67; Samstag 20 ≥ 1,2 × 11,67, aber < 1,8 × 11,67 (kein Spitzentag)
|
||||
const sat = (i, day) => (new Date(day + 'T00:00:00Z').getUTCDay() === 6 ? 20 : 10)
|
||||
const w = weekdayStats(days('2026-09-05', 30, sat), '')
|
||||
assert.equal(w.best.weekday, 6); assert.equal(w.best.name, 'Samstag'); assert.equal(w.best.avg, 20)
|
||||
assert.ok(Math.abs(w.avg - 350 / 30) < 1e-9)
|
||||
assert.equal(w.peak, null)
|
||||
// ein Tag mit dem 3-Fachen des Schnitts → Spitzentag
|
||||
const spike = (i, day) => (day === '2026-09-19' ? 60 : 10)
|
||||
const p = weekdayStats(days('2026-09-05', 30, spike), '')
|
||||
assert.deepEqual(p.peak, { day: '2026-09-19', pv: 60 })
|
||||
assert.equal(p.best.name, 'Samstag')
|
||||
// gleichmäßig: weder stärkster Tag noch Spitzentag
|
||||
assert.deepEqual(weekdayStats(days('2026-09-05', 30, 10), ''), { best: null, avg: 10, peak: null })
|
||||
// weniger als 7 Tage → null; firstDay schneidet Tage davor ab
|
||||
assert.equal(weekdayStats(days('2026-09-05', 6, 10), ''), null)
|
||||
assert.notEqual(weekdayStats(days('2026-09-05', 30, 10), '2026-09-28'), null) // 28.09.–04.10. = genau 7 Tage
|
||||
})
|
||||
|
||||
test('weekdayStats: firstDay zählt nur Tage ab firstDay', () => {
|
||||
assert.equal(weekdayStats(days('2026-09-05', 30, 10), '2026-09-29'), null) // nur 6 Tage (29.09.–04.10.)
|
||||
const w = weekdayStats(days('2026-09-05', 30, (i, day) => (day < '2026-09-20' ? 1000 : 10)), '2026-09-20')
|
||||
assert.equal(w.avg, 10) // die Tage davor (1000) bleiben außen vor
|
||||
assert.equal(weekdayStats(null, ''), null)
|
||||
})
|
||||
|
||||
test('summarize: Wachstum mit Prozent', () => {
|
||||
const s = summarize(stats())
|
||||
assert.equal(s.lead, 'Deine Website wurde in den letzten 30 Tagen <b>6.930-mal</b> aufgerufen – <b>14 % mehr</b> als in den 30 Tagen davor.')
|
||||
assert.equal(s.items[0].icon, 'contact')
|
||||
assert.equal(s.items[0].html, '178-mal hat dich jemand direkt kontaktiert, meist per Telefon (96). Das sind 35 mehr als zuvor.') // Telefon + E-Mail + WhatsApp: 96 + 52 + 30 gegen 80 + 40 + 23
|
||||
assert.ok(s.items.length <= 4)
|
||||
})
|
||||
|
||||
test('summarize: Rückgang, etwa gleich, kleine Zahlen absolut', () => {
|
||||
const lead = (totalsPv, prevPv) => summarize(stats({ totals: { ...t, pv: totalsPv }, previous: { ...prev, totals: { ...prev.totals, pv: prevPv } } })).lead
|
||||
assert.equal(lead(6930, 7615), 'Deine Website wurde in den letzten 30 Tagen <b>6.930-mal</b> aufgerufen – <b>9 % weniger</b> als in den 30 Tagen davor.')
|
||||
assert.equal(lead(6930, 6800), 'Deine Website wurde in den letzten 30 Tagen <b>6.930-mal</b> aufgerufen – etwa so oft wie in den 30 Tagen davor.')
|
||||
assert.equal(lead(80, 68), 'Deine Website wurde in den letzten 30 Tagen <b>80-mal</b> aufgerufen – <b>12 Aufrufe mehr</b> als in den 30 Tagen davor.')
|
||||
assert.equal(lead(60, 75), 'Deine Website wurde in den letzten 30 Tagen <b>60-mal</b> aufgerufen – <b>15 Aufrufe weniger</b> als in den 30 Tagen davor.')
|
||||
assert.equal(lead(84, 83), 'Deine Website wurde in den letzten 30 Tagen <b>84-mal</b> aufgerufen – etwa so oft wie in den 30 Tagen davor.') // unter 5 % gilt auch bei kleinen Zahlen
|
||||
assert.match(lead(32, 31), /aufgerufen – etwa so oft wie in den 30 Tagen davor\.$/)
|
||||
assert.equal(lead(40, 30), 'Deine Website wurde in den letzten 30 Tagen <b>40-mal</b> aufgerufen – <b>10 Aufrufe mehr</b> als in den 30 Tagen davor.')
|
||||
assert.equal(lead(31, 20), 'Deine Website wurde in den letzten 30 Tagen <b>31-mal</b> aufgerufen – <b>11 Aufrufe mehr</b> als in den 30 Tagen davor.')
|
||||
assert.equal(lead(80, 80), 'Deine Website wurde in den letzten 30 Tagen <b>80-mal</b> aufgerufen – etwa so oft wie in den 30 Tagen davor.')
|
||||
assert.equal(lead(7200, 6857), 'Deine Website wurde in den letzten 30 Tagen <b>7.200-mal</b> aufgerufen – <b>5 % mehr</b> als in den 30 Tagen davor.') // genau 5 % gilt noch als Veränderung
|
||||
})
|
||||
|
||||
test('summarize: ohne Vergleich und neu gestartet', () => {
|
||||
// previous fehlt: '…in den letzten 30 Tagen <b>X-mal</b> aufgerufen.'
|
||||
const { previous, ...ohne } = stats()
|
||||
assert.equal(summarize(ohne).lead, 'Deine Website wurde in den letzten 30 Tagen <b>6.930-mal</b> aufgerufen.')
|
||||
// Vorzeitraum unvollständig, firstDay vor dem Zeitraum: kein Vergleich, aber kein „Seit dem Start“
|
||||
assert.equal(summarize(stats({ firstDay: '2026-08-20', previous: { ...prev, complete: false } })).lead, 'Deine Website wurde in den letzten 30 Tagen <b>6.930-mal</b> aufgerufen.')
|
||||
// Vorzeitraum zu klein: kein Vergleich
|
||||
assert.equal(summarize(stats({ previous: { ...prev, totals: { ...prev.totals, pv: 12 } } })).lead, 'Deine Website wurde in den letzten 30 Tagen <b>6.930-mal</b> aufgerufen.')
|
||||
// firstDay im Zeitraum (complete false): 'Seit dem Start der Analyse am 20.09. wurde deine Website <b>X-mal</b> aufgerufen.'
|
||||
const neu = summarize(stats({ firstDay: '2026-09-20', previous: { ...prev, complete: false } }))
|
||||
assert.equal(neu.lead, 'Seit dem Start der Analyse am 20.09. wurde deine Website <b>6.930-mal</b> aufgerufen.')
|
||||
// auch das Startdatum wird maskiert, falls der Collector je Unsinn liefert
|
||||
assert.ok(!summarize(stats({ firstDay: '<i>x</i>', previous: { ...prev, complete: false } })).lead.includes('<i>'))
|
||||
// ohne Vergleich kein „Das sind … mehr als zuvor“
|
||||
assert.equal(neu.items[0].html, '178-mal hat dich jemand direkt kontaktiert, meist per Telefon (96).')
|
||||
// 7 Tage: „7 Tagen“
|
||||
assert.match(summarize(stats({ range: 7 })).lead, /in den letzten 7 Tagen .* als in den 7 Tagen davor\.$/)
|
||||
})
|
||||
|
||||
test('summarize: zu wenig Daten → null; keine Kontakte → Hinweis nur ab 30 Besuchern', () => {
|
||||
assert.equal(summarize(stats({ totals: { ...t, pv: 29 } })), null)
|
||||
assert.equal(summarize(null), null)
|
||||
assert.notEqual(summarize(stats({ totals: { ...t, pv: 30 } })), null)
|
||||
// contacts 0, visitors 40: 'Von den Besuchern mit Zustimmung hat noch niemand über die Website angerufen oder geschrieben.'
|
||||
const keine = summarize(stats({ totals: { ...t, contacts: 0, visitors: 40 }, contacts: [] }))
|
||||
assert.deepEqual(keine.items[0], { icon: 'contact', html: 'Von den Besuchern mit Zustimmung hat noch niemand über die Website angerufen oder geschrieben.' })
|
||||
const wenig = summarize(stats({ totals: { ...t, contacts: 0, visitors: 29 }, contacts: [] }))
|
||||
assert.notEqual(wenig.items[0].icon, 'contact')
|
||||
})
|
||||
|
||||
test('summarize: Kontakte – Vergleichssatz und häufigste Art, Links nach außen zählen nicht mit', () => {
|
||||
const tel = (n) => ({ key: 'tel', count: n })
|
||||
const html = (kinds, before) => summarize(stats({
|
||||
totals: { ...t, contacts: kinds.reduce((a, k) => a + k.count, 0) },
|
||||
contacts: kinds,
|
||||
previous: { ...prev, contacts: before, totals: { ...prev.totals, contacts: before.reduce((a, k) => a + k.count, 0) } },
|
||||
})).items[0].html
|
||||
assert.equal(html([tel(96)], [tel(108)]), '96-mal hat dich jemand direkt kontaktiert, meist per Telefon (96). Das sind 12 weniger als zuvor.')
|
||||
assert.equal(html([{ key: 'mail', count: 100 }], [{ key: 'mail', count: 100 }]), '100-mal hat dich jemand direkt kontaktiert, meist per E-Mail (100). Genauso oft wie zuvor.')
|
||||
assert.equal(html([{ key: 'wa', count: 5 }], []), '5-mal hat dich jemand direkt kontaktiert, meist per WhatsApp (5).') // Vorwert 0: kein Vergleichssatz
|
||||
assert.equal(html([tel(5)], [tel(2)]), '5-mal hat dich jemand direkt kontaktiert, meist per Telefon (5). Das sind 3 mehr als zuvor.')
|
||||
// Links nach außen sind Klicks auf andere Seiten, kein Kontakt: weder in der Zahl noch als häufigste Art, auch nicht im Vorzeitraum
|
||||
assert.equal(html([{ key: 'out', count: 300 }, tel(40)], [{ key: 'out', count: 900 }, tel(40)]), '40-mal hat dich jemand direkt kontaktiert, meist per Telefon (40). Genauso oft wie zuvor.')
|
||||
assert.equal(html([{ key: 'out', count: 300 }, tel(40)], [{ key: 'out', count: 900 }]), '40-mal hat dich jemand direkt kontaktiert, meist per Telefon (40).')
|
||||
// nur Links nach außen (Besucher ≥ 30): wie „keine Kontakte“
|
||||
const nurOut = summarize(stats({ totals: { ...t, contacts: 300, visitors: 400 }, contacts: [{ key: 'out', count: 300 }] }))
|
||||
assert.deepEqual(nurOut.items[0], { icon: 'contact', html: 'Von den Besuchern mit Zustimmung hat noch niemand über die Website angerufen oder geschrieben.' })
|
||||
// Collector ohne Kontaktliste: kein Satz, der etwas Falsches behauptet
|
||||
const { contacts, ...ohneListe } = stats({ totals: { ...t, contacts: 0, visitors: 400 } })
|
||||
assert.notEqual(summarize(ohneListe).items[0].icon, 'contact')
|
||||
})
|
||||
|
||||
test('summarize: Herkunft, Gerät, Seite und Reihenfolge, höchstens 4', () => {
|
||||
// refs google.com 880 von 2270 → 'Die meisten, die über einen Link kamen, kommen von Google (880).'
|
||||
const s = summarize(stats())
|
||||
const byIcon = Object.fromEntries(s.items.map((i) => [i.icon, i.html]))
|
||||
assert.equal(byIcon.source, 'Die meisten, die über einen Link kamen, kommen von Google (880).')
|
||||
// devices m 4590/6930 → '66 % der Aufrufe kommen vom Handy.'
|
||||
assert.equal(byIcon.device, '66 % der Aufrufe kommen vom Handy.')
|
||||
// pages / dann /preise → 'Am meisten angesehen: die Startseite, danach /preise (1.310).'
|
||||
assert.equal(byIcon.page, 'Am meisten angesehen: die Startseite, danach /preise (1.310).')
|
||||
assert.deepEqual(s.items.map((i) => i.icon), ['contact', 'source', 'device', 'page'])
|
||||
// Computer, Seite ohne Startseite
|
||||
const pc = summarize(stats({ devices: [{ key: 'd', count: 600 }, { key: 'm', count: 300 }, { key: 't', count: 100 }], pages: [{ key: '/preise', count: 1310 }, { key: '/', count: 900 }] }))
|
||||
assert.equal(pc.items.find((i) => i.icon === 'device').html, '60 % der Aufrufe kommen vom Computer.')
|
||||
assert.equal(pc.items.find((i) => i.icon === 'page').html, 'Am meisten angesehen: /preise (1.310 Aufrufe).')
|
||||
// nur Startseite
|
||||
assert.equal(summarize(stats({ pages: [{ key: '/', count: 50 }] })).items.find((i) => i.icon === 'page').html, 'Am meisten angesehen: die Startseite (50 Aufrufe).')
|
||||
// Gerät unter 55 %, Herkunft unter 20 %: beide Hinweise entfallen
|
||||
const flach = summarize(stats({ devices: [{ key: 'm', count: 50 }, { key: 'd', count: 50 }], refs: [{ key: 'google.com', count: 10 }, { key: '', count: 90 }] }))
|
||||
assert.ok(!flach.items.some((i) => i.icon === 'device' || i.icon === 'source'))
|
||||
// Direkt (leerer Host) zählt nie als Quelle, auch wenn er vorne steht
|
||||
const direkt = summarize(stats({ refs: [{ key: '', count: 900 }, { key: 'google.com', count: 300 }] }))
|
||||
assert.equal(direkt.items.find((i) => i.icon === 'source').html, 'Die meisten, die über einen Link kamen, kommen von Google (300).')
|
||||
// Samstage 2× → Wochentag-Hinweis; alle 5 Bedingungen wahr → Seite fällt weg
|
||||
const sat = (i, day) => (new Date(day + 'T00:00:00Z').getUTCDay() === 6 ? 20 : 10)
|
||||
const voll = summarize(stats({ series: days('2026-09-05', 30, sat) }))
|
||||
assert.deepEqual(voll.items.map((i) => i.icon), ['contact', 'day', 'source', 'device'])
|
||||
assert.equal(voll.items[1].html, 'Samstag ist im Schnitt dein stärkster Tag.')
|
||||
})
|
||||
|
||||
test('summarize: Wochentag und Spitzentag in einem Hinweis', () => {
|
||||
// Samstage 20, Spitzentag Sa., 19.09. mit 371, sonst 10: beides trifft zu
|
||||
const both = (i, day) => (day === '2026-09-19' ? 371 : new Date(day + 'T00:00:00Z').getUTCDay() === 6 ? 40 : 10)
|
||||
const s = summarize(stats({ series: days('2026-09-05', 30, both) }))
|
||||
assert.equal(s.items.find((i) => i.icon === 'day').html, 'Samstag ist im Schnitt dein stärkster Tag. Spitzentag war Sa., 19.09. mit 371 Aufrufen.')
|
||||
// nur Spitzentag am Mittwoch 23.09.: die anderen Mittwoche (0) gleichen den Wochentagsschnitt aus (alle Wochentage Ø 25)
|
||||
const spike = (i, day) => (day === '2026-09-23' ? 100 : new Date(day + 'T00:00:00Z').getUTCDay() === 3 ? 0 : 25)
|
||||
const p = summarize(stats({ series: days('2026-09-05', 30, spike) }))
|
||||
assert.equal(p.items.find((i) => i.icon === 'day').html, 'Spitzentag war Mi., 23.09. mit 100 Aufrufen.')
|
||||
// weniger als 70 Aufrufe oder weniger als 7 Tage: kein Wochentag-Hinweis
|
||||
assert.ok(!summarize(stats({ totals: { ...t, pv: 69 }, series: days('2026-09-05', 30, spike) })).items.some((i) => i.icon === 'day'))
|
||||
assert.ok(!summarize(stats({ firstDay: '2026-09-30', series: days('2026-09-05', 30, spike) })).items.some((i) => i.icon === 'day'))
|
||||
})
|
||||
|
||||
test('summarize: Wochentag-Hinweis zählt alle Tage der Reihe (alle sind abgeschlossen), auch in der 7-Tage-Ansicht', () => {
|
||||
const isSat = (day) => new Date(day + 'T00:00:00Z').getUTCDay() === 6
|
||||
const dayHtml = (s) => s.items.find((i) => i.icon === 'day')?.html
|
||||
// Reihe 04.09.–03.10.2026 (Ende = gestern, heute steht getrennt in `today`); der letzte Tag, Samstag 03.10., zählt mit
|
||||
const last = '2026-10-03'
|
||||
const base = { from: '2026-09-04', to: last, today: { day: '2026-10-04', pv: 5, visitors: 3, contacts: 0 } }
|
||||
assert.equal(dayHtml(summarize(stats({ ...base, series: days('2026-09-04', 30, (i, day) => (isSat(day) ? 280 : 200)) }))), 'Samstag ist im Schnitt dein stärkster Tag.')
|
||||
// Spitzentag am letzten Tag der Reihe wird erkannt
|
||||
const spike = days('2026-09-04', 30, (i, day) => (day === last ? 400 : 100))
|
||||
assert.equal(dayHtml(summarize(stats({ ...base, series: spike }))), 'Samstag ist im Schnitt dein stärkster Tag. Spitzentag war Sa., 03.10. mit 400 Aufrufen.')
|
||||
// 7-Tage-Ansicht: genau 7 abgeschlossene Tage reichen für den Hinweis (28.09.–04.10., Sa. 03.10.)
|
||||
const week = days('2026-09-28', 7, (i, day) => (isSat(day) ? 500 : 100))
|
||||
assert.equal(dayHtml(summarize(stats({ range: 7, from: '2026-09-28', to: '2026-10-04', series: week }))), 'Samstag ist im Schnitt dein stärkster Tag. Spitzentag war Sa., 03.10. mit 500 Aufrufen.')
|
||||
// weniger als 7 Tage (neue Website): weiter kein Hinweis
|
||||
assert.equal(dayHtml(summarize(stats({ range: 7, from: '2026-09-28', to: '2026-10-04', firstDay: '2026-09-29', series: week }))), undefined)
|
||||
// alter Collector ohne `today`: derselbe Hinweis, kein Absturz
|
||||
const { today, ...alt } = stats({ ...base, series: days('2026-09-04', 30, (i, day) => (isSat(day) ? 280 : 200)) })
|
||||
assert.equal(dayHtml(summarize(alt)), 'Samstag ist im Schnitt dein stärkster Tag.')
|
||||
})
|
||||
|
||||
test('summarize: Pfade und Hosts werden maskiert', () => {
|
||||
const s = summarize(stats({ pages: [{ key: '/<img src=x>', count: 900 }], refs: [{ key: 'a"b.de', count: 900 }] }))
|
||||
assert.ok(!JSON.stringify(s).includes('<img'))
|
||||
assert.ok(JSON.stringify(s).includes('<img'))
|
||||
assert.equal(s.items.find((i) => i.icon === 'source').html, 'Die meisten, die über einen Link kamen, kommen von a"b.de (900).')
|
||||
assert.equal(s.items.find((i) => i.icon === 'page').html, 'Am meisten angesehen: /<img src=x> (900 Aufrufe).')
|
||||
// auch an zweiter Stelle hinter der Startseite
|
||||
const z = summarize(stats({ pages: [{ key: '/', count: 900 }, { key: '/<script>', count: 100 }] }))
|
||||
assert.ok(!JSON.stringify(z).includes('<script>'))
|
||||
})
|
||||
|
||||
test('chartModel mit compare: gemeinsame Skala, prevLine', () => {
|
||||
const cur = days('2026-09-05', 5, 10)
|
||||
const before = days('2026-08-06', 5, (i) => (i === 2 ? 400 : 20))
|
||||
const m = chartModel(cur, { compare: before })
|
||||
assert.equal(m.top, 500) // über beide Reihen (Maximum 400)
|
||||
assert.equal(m.points.length, 5)
|
||||
assert.deepEqual(m.points.map((p) => p.prev), [20, 20, 400, 20, 20])
|
||||
assert.match(m.prevLine, /^M[\d. ]+( L[\d. ]+){4}$/)
|
||||
// nach Tagesindex ausgerichtet: gleiche x-Werte wie die aktuelle Linie, y am Vorwert
|
||||
const first = m.prevLine.split(' L')[0].slice(1).split(' ').map(Number)
|
||||
assert.equal(first[0], m.points[0].x)
|
||||
const mid = m.prevLine.split(' L')[2].split(' ').map(Number)
|
||||
assert.equal(mid[0], m.points[2].x)
|
||||
assert.ok(mid[1] < first[1]) // 400 liegt höher als 20
|
||||
// ohne compare: wie bisher, prevLine leer
|
||||
const o = chartModel(cur)
|
||||
assert.equal(o.top, 10)
|
||||
assert.equal(o.prevLine, '')
|
||||
assert.ok(o.points.every((p) => p.prev === null))
|
||||
assert.equal(o.line, chartModel(cur, { compare: [] }).line)
|
||||
assert.equal(chartModel(cur, { compare: [] }).prevLine, '')
|
||||
// kürzerer Vergleich: nur die vorhandenen Tage, Rest null
|
||||
const k = chartModel(cur, { compare: before.slice(0, 2) })
|
||||
assert.deepEqual(k.points.map((p) => p.prev), [20, 20, null, null, null])
|
||||
assert.match(k.prevLine, /^M[\d. ]+ L[\d. ]+$/)
|
||||
})
|
||||
@@ -112,7 +112,7 @@ test('GET /api/funktionen: analyse-Zustand je Projekt, mit und ohne Schalter', a
|
||||
const body = await get('/api/funktionen', { cookie })
|
||||
const p = (id) => body.projects.find((x) => x.projectId === id)
|
||||
assert.equal(p('p1').features.news.state, 'off')
|
||||
assert.deepEqual(p('p1').analyse, { state: 'off', devMode: false, accentColor: '#111111', eligible: true, reason: null, reasonText: null, avvVersion: config.analyse.avvVersion, legal: legalPaths(config.analyse.avvVersion), controller: { company: 'Kunde Eins', address: '', email: 'k@example.invalid', ok: true, missing: [] } })
|
||||
assert.deepEqual(p('p1').analyse, { state: 'off', devMode: false, accentColor: '#111111', eligible: true, reason: null, reasonText: null, avvVersion: config.analyse.avvVersion, legal: legalPaths(config.analyse.avvVersion), controller: { company: 'Kunde Eins', address: '', email: 'k@example.invalid', ok: true, missing: [] }, activatedAt: null })
|
||||
assert.equal(p('p2').analyse.eligible, false)
|
||||
assert.equal(p('p2').analyse.reason, 'nicht_oeffentlich')
|
||||
assert.equal(p('p2').analyse.reasonText, an.ELIGIBILITY_MESSAGES.nicht_oeffentlich)
|
||||
@@ -133,6 +133,7 @@ test('Aktivieren und Deaktivieren (Kunde)', async () => {
|
||||
const view = (await get('/api/funktionen', { cookie })).projects.find((x) => x.projectId === 'p1').analyse
|
||||
assert.equal(view.state, 'active')
|
||||
assert.equal(view.accentColor, '#112233')
|
||||
assert.match(view.activatedAt, /^\d{4}-\d{2}-\d{2}T/)
|
||||
const off = await post(`${A}/deactivate`, { projectId: 'p1' }, { cookie })
|
||||
assert.deepEqual(off.body, { ok: true, state: 'off' })
|
||||
assert.equal(stops.length, 1)
|
||||
|
||||
@@ -37,6 +37,13 @@ test('Diagramm-Skalierung', () => {
|
||||
assert.ok(m.xLabels.length <= 7 && m.xLabels.length >= 2)
|
||||
assert.equal(chartModel([]).points.length, 0)
|
||||
assert.equal(chartModel([{ day: '2026-10-01', pv: 3 }]).points.length, 1)
|
||||
// labelGap: die vorletzte Beschriftung rückt weg, wenn sie der letzten zu nahe kommt (30 Tage: 29.09. ist 79 Einheiten vor 03.10.)
|
||||
const labels = (opts) => chartModel(series, { width: 640, ...opts }).xLabels.map((l) => l.label)
|
||||
assert.equal(labels({}).length, 7)
|
||||
const wide = chartModel(series, { labelGap: 90 }).xLabels
|
||||
assert.equal(wide.length, 6)
|
||||
assert.ok(wide.every((l, i, a) => !i || l.x - a[i - 1].x >= 90))
|
||||
assert.equal(wide[wide.length - 1].label, '30.09.') // letzter Tag bleibt
|
||||
})
|
||||
|
||||
test('Balkenzeilen', () => {
|
||||
@@ -54,8 +61,11 @@ test('Portal: Analyse-Ansicht ist verdrahtet', () => {
|
||||
assert.match(app, /APP_PARENT = \{ news: 'funktionen', analyse: 'funktionen'/)
|
||||
assert.match(html, /id="view-analyse"/)
|
||||
assert.match(html, /id="analyse-body"/)
|
||||
assert.match(app, /analyse: \(\) => import\('\/analyse\.js'\)/)
|
||||
const an = readFileSync(new URL('../public/analyse.js', import.meta.url), 'utf8')
|
||||
assert.doesNotMatch(an, /\bconfirm\(/)
|
||||
const fn = readFileSync(new URL('../public/funktionen.js', import.meta.url), 'utf8')
|
||||
assert.doesNotMatch(fn.slice(fn.indexOf('Analyse ---')), /\bconfirm\(/)
|
||||
assert.doesNotMatch(fn, /function renderAnalyseStats|function renderAnalyseHeat/)
|
||||
})
|
||||
|
||||
test('Portal-Vorschau: Banner-Text ist der des Clients', () => {
|
||||
|
||||
@@ -4,6 +4,8 @@ import assert from 'node:assert/strict'
|
||||
import { createAnalyticsClient } from '../server/services/analyticsClient.js'
|
||||
import { createAdminServer, createPublicServer } from '../analytics/src/server.js'
|
||||
import { openDb } from '../analytics/src/db.js'
|
||||
import { computeStats } from '../analytics/src/stats.js'
|
||||
import { compareFrom, shortDay } from '../public/analyse-view.js'
|
||||
|
||||
const SITE = 'abcdef0123456789abcd'
|
||||
const DOMAIN = 'kunde.example.com'
|
||||
@@ -39,11 +41,24 @@ test('Vertrag: putSite -> Ereignisse -> getStats -> heatToken -> deleteSite', as
|
||||
await post({ t: 'ct', path: '/', kind: 'tel' })
|
||||
await post({ t: 'bn', a: 'accept' })
|
||||
|
||||
// Frisch gemessen: heute steht nur in `today`, der Zeitraum sind die abgeschlossenen Tage bis gestern
|
||||
const jetzt = await client.getStats(SITE, '7')
|
||||
assert.deepEqual(jetzt.today, { day: jetzt.today.day, pv: 3, visitors: 1, contacts: 1 })
|
||||
assert.equal(jetzt.totals.pv, 0)
|
||||
assert.ok(jetzt.today.day > jetzt.to && jetzt.series.every((d) => d.day <= jetzt.to))
|
||||
// Um 36 Stunden zurückdatieren: liegt immer auf einem abgeschlossenen Tag des 7-Tage-Zeitraums
|
||||
db.prepare('UPDATE events_raw SET ts = ts - 36 * 3600 * 1000 WHERE site = ?').run(SITE)
|
||||
|
||||
const stats = await client.getStats(SITE, '7')
|
||||
assert.equal(stats.totals.pv, 3)
|
||||
assert.equal(stats.totals.contacts, 1)
|
||||
assert.equal(stats.today.pv, 0)
|
||||
assert.equal(stats.series.length, 7)
|
||||
assert.equal(stats.series.reduce((n, d) => n + d.pv, 0), 3)
|
||||
assert.equal(stats.range, 7)
|
||||
assert.equal(stats.previous.series.length, 7)
|
||||
assert.ok('firstDay' in stats && 'avgSec' in stats.totals)
|
||||
assert.ok(stats.series.every((d) => 'visitors' in d && 'contacts' in d && 'avgSec' in d))
|
||||
assert.deepEqual(stats.pages, [{ key: '/', count: 2 }, { key: '/kontakt', count: 1 }])
|
||||
assert.deepEqual(stats.refs, [{ key: '', count: 2 }, { key: 'google.com', count: 1 }])
|
||||
assert.equal(stats.banner.accept, 1)
|
||||
@@ -72,3 +87,22 @@ test('Vertrag: stopSite setzt active=0 und offSince, unbekannt zaehlt als erledi
|
||||
assert.equal(db.prepare('SELECT offSince FROM sites WHERE siteKey = ?').get(KEY2).offSince, row.offSince)
|
||||
assert.deepEqual(await client.stopSite('00000000000000000000'), { ok: true, missing: true })
|
||||
})
|
||||
|
||||
test('Vertrag: "Vergleich ab" des Portals ist der erste Tag, an dem der Collector den Vorzeitraum als vollständig meldet', () => {
|
||||
const firstDay = '2026-09-20'
|
||||
const evDb = openDb(':memory:')
|
||||
evDb.prepare('INSERT INTO sites (siteKey, projectId, domains, active) VALUES (?,?,?,1)').run(SITE, 'p1', '["a.de"]')
|
||||
evDb.prepare("INSERT INTO events_raw (site, ts, type, path, vp, country, device) VALUES (?,?,'pv','/','d','DE','d')").run(SITE, Date.UTC(2026, 8, 20, 10))
|
||||
for (const range of [7, 30]) {
|
||||
const addDays = (day, n) => new Date(Date.UTC(+day.slice(0, 4), +day.slice(5, 7) - 1, +day.slice(8, 10) + n)).toISOString().slice(0, 10)
|
||||
const at = (day) => computeStats(evDb, SITE, range, Date.parse(`${day}T10:00:00Z`))
|
||||
const first = addDays(firstDay, 2 * range) // "Vergleich ab" laut Portal
|
||||
const dayBefore = at(addDays(first, -1))
|
||||
assert.equal(dayBefore.previous.complete, false, `range ${range}: am Tag davor noch nicht vollständig`)
|
||||
assert.deepEqual(compareFrom(dayBefore), { ok: false, from: shortDay(first) })
|
||||
const onDay = at(first)
|
||||
assert.equal(onDay.previous.complete, true, `range ${range}: am Tag selbst vollständig`)
|
||||
assert.equal(onDay.previous.from, firstDay)
|
||||
assert.equal(compareFrom(onDay).from, '') // kein Datum mehr (der Vorzeitraum ist voll; ok bleibt false, denn es gibt nur 1 Aufruf)
|
||||
}
|
||||
})
|
||||
@@ -25,7 +25,7 @@ test('Entwurfsseite ohne Fassung ist nicht mehr als Datei vorhanden', () => {
|
||||
})
|
||||
|
||||
test('Portal: keine alten Formulierungen, AVV-Adresse kommt aus a.legal', () => {
|
||||
const fn = readFileSync(root('public/funktionen.js'), 'utf8')
|
||||
const fn = readFileSync(root('public/analyse.js'), 'utf8')
|
||||
for (const old of ['anonym', 'Cookie-Einstellungen', 'Die bisherigen Daten bleiben noch 60 Tage erhalten', 'Verarbeitung der Analysedaten gemäß Auftragsverarbeitungsvertrag', "AVV_URL = '/rechtliches/avv-website-analyse.html'"]) {
|
||||
assert.ok(!fn.includes(old), old)
|
||||
}
|
||||
|
||||
@@ -109,8 +109,8 @@ test('bestellseite_hinweis: GET /api/funktionen liefert ustHinweis', async () =>
|
||||
const dir = mkdtempSync(join(tmpdir(), 'fn-recht-'))
|
||||
const fileUrl = (name) => pathToFileURL(new URL(`../public/${name}`, import.meta.url).pathname).href
|
||||
const clientQuelle = lesen('public/funktionen.js')
|
||||
.replace("'/fn-util.js'", `'${fileUrl('fn-util.js')}'`)
|
||||
.replace("'/analyse-view.js'", `'${fileUrl('analyse-view.js')}'`)
|
||||
.replace("'/geraete.js'", `'${fileUrl('geraete.js')}'`)
|
||||
.replace("'./vertraege-link.js'", `'${fileUrl('vertraege-link.js')}'`)
|
||||
const clientDatei = join(dir, 'funktionen.mjs')
|
||||
writeFileSync(clientDatei, clientQuelle)
|
||||
|
||||
@@ -5,16 +5,18 @@ import { tmpdir } from 'node:os'
|
||||
import { join } from 'node:path'
|
||||
import { pathToFileURL } from 'node:url'
|
||||
|
||||
// public/funktionen.js wirklich laden (die absoluten Importe /analyse-view.js und /geraete.js und der relative ./vertraege-link.js werden auf die Dateien umgeleitet)
|
||||
// public/funktionen.js wirklich laden (die absoluten Importe /fn-util.js und /analyse-view.js und der relative ./vertraege-link.js werden
|
||||
// auf die Dateien umgeleitet); analyse.js importiert relativ und wird direkt geladen
|
||||
const dir = mkdtempSync(join(tmpdir(), 'fn-tiles-'))
|
||||
const fileUrl = (name) => pathToFileURL(new URL(`../public/${name}`, import.meta.url).pathname).href
|
||||
const src = readFileSync(new URL('../public/funktionen.js', import.meta.url), 'utf8')
|
||||
.replace("'/fn-util.js'", `'${fileUrl('fn-util.js')}'`)
|
||||
.replace("'/analyse-view.js'", `'${fileUrl('analyse-view.js')}'`)
|
||||
.replace("'/geraete.js'", `'${fileUrl('geraete.js')}'`)
|
||||
.replace("'./vertraege-link.js'", `'${fileUrl('vertraege-link.js')}'`)
|
||||
const file = join(dir, 'funktionen.mjs')
|
||||
writeFileSync(file, src)
|
||||
const { initFunktionen, initNews, initAnalyse, renderAnalyseOff } = await import(pathToFileURL(file).href)
|
||||
const { initFunktionen, initNews } = await import(pathToFileURL(file).href)
|
||||
const { initAnalyse, renderAnalyseOff } = await import(fileUrl('analyse.js'))
|
||||
|
||||
const news = { state: 'off' }
|
||||
const project = (id, analyse) => ({ projectId: id, projectName: `P ${id}`, liveUrl: '', features: { news }, analyse })
|
||||
|
||||
@@ -65,7 +65,11 @@ test('importNewRepos legt nur fehlende an', async () => {
|
||||
const neu = aw.all('websiteProjects').find((d) => d.repoFullName === 'JUSN/neu')
|
||||
assert.deepEqual([neu.projectName, neu.status, neu.subdomain || '', neu.previewUrl || ''], ['Döner Nation', 'synced', '', ''])
|
||||
assert.ok(aw.all('websiteProjects').some((d) => d.repoFullName === 'knso/privat'))
|
||||
assert.ok(!aw.all('websiteProjects').some((d) => d.repoFullName === 'JUSN/archiv'))
|
||||
// In Gitea archivierte Repos kommen als archiviertes Projekt an (sichtbar unter "Archiviert"),
|
||||
// aber nicht in createdRepos (keine Zuordnungs-Mail)
|
||||
const archiv = aw.all('websiteProjects').find((d) => d.repoFullName === 'JUSN/archiv')
|
||||
assert.deepEqual([archiv.archived, archiv.status], [true, 'archived'])
|
||||
assert.equal(r.archivedImported, 1)
|
||||
assert.equal(aw.calls.filter((c) => c.method === 'PATCH').length, 0)
|
||||
})
|
||||
test('importNewRepos läuft nie doppelt', async () => {
|
||||
|
||||
@@ -223,6 +223,14 @@ test('Webhook des System-Kontos', async () => {
|
||||
await webhook(pushPayload({ full_name: 'WEBklar/D-ner-Nation', sha: 'cafe0001', pusher: 'webklar-system' }))
|
||||
assert.equal(aw.all('worksheets').length, before)
|
||||
})
|
||||
test('System-Commit an Projekt mit Kunde ohne Ticket legt kein Auto-Ticket an', async () => {
|
||||
gitea.addRepo({ full_name: 'WEBklar/neu-mit-kunde' })
|
||||
aw.insert('websiteProjects', { $id: 'p_sys', repoFullName: 'WEBklar/neu-mit-kunde', projectName: 'Neu', customerId: 'c1', ticketId: '' })
|
||||
const before = aw.all('workorders').length
|
||||
await webhook(pushPayload({ full_name: 'WEBklar/neu-mit-kunde', sha: 'cafe0002', pusher: 'webklar-system' }))
|
||||
assert.equal(aw.all('workorders').length, before)
|
||||
assert.equal(aw.get('websiteProjects', 'p_sys').ticketId, '')
|
||||
})
|
||||
test('Webhook wartet auf laufenden Umzug', async () => {
|
||||
gitea.setTransferDelay(300)
|
||||
const move = post('/api/admin/website-projects/p5/assign', { customerId: 'c1', ticketId: 't1' }, 'jwt-admin') // p5: JUSN/langsam
|
||||
|
||||
@@ -28,6 +28,10 @@ import { randomUUID } from 'node:crypto'
|
||||
export async function startFakeAppwrite(options = {}) {
|
||||
const calls = []
|
||||
const pendingFailures = []
|
||||
// Optionale Unique-Indizes wie in Appwrite/MariaDB: { websiteProjects: ['repoFullName', 'subdomain'] }.
|
||||
// Strings vergleichen ohne Gross-/Kleinschreibung, null/undefined kollidieren nie, '' schon.
|
||||
const uniqueAttrs = options.unique || {}
|
||||
let beforeCreate = null
|
||||
/** @type {Map<string, Map<string, object>>} Sammlungsname -> (Dokument-ID -> Dokument). */
|
||||
const store = new Map()
|
||||
|
||||
@@ -114,11 +118,24 @@ export async function startFakeAppwrite(options = {}) {
|
||||
send(res, 200, { total, documents: result })
|
||||
}
|
||||
|
||||
function handleCreateDocument(match, searchParams, body, headers, res) {
|
||||
function uniqueConflict(col, data, ownId) {
|
||||
for (const attr of uniqueAttrs[col] || []) {
|
||||
const value = data?.[attr]
|
||||
if (value === null || value === undefined) continue
|
||||
const norm = (v) => (typeof v === 'string' ? v.toLowerCase() : v)
|
||||
for (const doc of collectionOf(col).values()) {
|
||||
if (doc.$id !== ownId && doc[attr] !== null && doc[attr] !== undefined && norm(doc[attr]) === norm(value)) return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
async function handleCreateDocument(match, searchParams, body, headers, res) {
|
||||
if (beforeCreate) await beforeCreate(match[2], body?.data || {})
|
||||
const map = collectionOf(match[2])
|
||||
const documentId = body?.documentId || randomUUID()
|
||||
if (map.has(documentId)) {
|
||||
return send(res, 409, { message: 'Document with the requested ID already exists.' })
|
||||
if (map.has(documentId) || uniqueConflict(match[2], body?.data, documentId)) {
|
||||
return send(res, 409, { message: 'Document with the requested ID already exists.', type: 'document_already_exists' })
|
||||
}
|
||||
const now = new Date().toISOString()
|
||||
const doc = { $id: documentId, $createdAt: now, $updatedAt: now, ...(body?.data || {}) }
|
||||
@@ -135,6 +152,9 @@ export async function startFakeAppwrite(options = {}) {
|
||||
function handlePatchDocument(match, searchParams, body, headers, res) {
|
||||
const doc = collectionOf(match[2]).get(match[3])
|
||||
if (!doc) return send(res, 404, { message: 'Document not found' })
|
||||
if (uniqueConflict(match[2], body?.data, doc.$id)) {
|
||||
return send(res, 409, { message: 'Document with the requested ID already exists.', type: 'document_already_exists' })
|
||||
}
|
||||
Object.assign(doc, body?.data || {})
|
||||
doc.$updatedAt = new Date().toISOString()
|
||||
send(res, 200, doc)
|
||||
@@ -212,11 +232,9 @@ export async function startFakeAppwrite(options = {}) {
|
||||
const route = ROUTES.find((r) => r.method === req.method && r.re.test(url.pathname))
|
||||
if (!route) return send(res, 404, { message: 'Not Found' })
|
||||
const match = route.re.exec(url.pathname)
|
||||
try {
|
||||
route.handler(match, url.searchParams, parsedBody, req.headers, res)
|
||||
} catch (err) {
|
||||
send(res, 500, { message: err?.message || 'fakeAppwrite: interner Fehler' })
|
||||
}
|
||||
Promise.resolve()
|
||||
.then(() => route.handler(match, url.searchParams, parsedBody, req.headers, res))
|
||||
.catch((err) => send(res, 500, { message: err?.message || 'fakeAppwrite: interner Fehler' }))
|
||||
})
|
||||
})
|
||||
|
||||
@@ -245,10 +263,24 @@ export async function startFakeAppwrite(options = {}) {
|
||||
pendingFailures.push({ method, pathIncludes, status })
|
||||
}
|
||||
|
||||
/** fn(collection, data) laeuft vor jeder Anlage (z. B. um einen gleichzeitigen Schreiber nachzustellen). */
|
||||
function setBeforeCreate(fn) {
|
||||
beforeCreate = fn || null
|
||||
}
|
||||
|
||||
/** Dokument direkt in den Speicher legen (ohne HTTP), z. B. aus einem setBeforeCreate-Haken. */
|
||||
function insert(col, doc) {
|
||||
const now = new Date().toISOString()
|
||||
const id = doc.$id || randomUUID()
|
||||
const full = { $createdAt: now, $updatedAt: now, ...doc, $id: id }
|
||||
collectionOf(col).set(id, full)
|
||||
return full
|
||||
}
|
||||
|
||||
function close() {
|
||||
for (const socket of sockets) socket.destroy()
|
||||
return new Promise((resolve) => server.close(() => resolve()))
|
||||
}
|
||||
|
||||
return { endpoint, all, get, calls, failNext, close }
|
||||
return { endpoint, all, get, calls, failNext, setBeforeCreate, insert, close }
|
||||
}
|
||||
@@ -63,6 +63,7 @@ export async function startFakeGitea(options = {}) {
|
||||
let transferDelayMs = 0
|
||||
let responseDelayMs = 0
|
||||
let transferNoopNext = false
|
||||
let onGenerate = null
|
||||
const pendingFailures = []
|
||||
|
||||
let nextRepoId = 1
|
||||
@@ -229,6 +230,30 @@ export async function startFakeGitea(options = {}) {
|
||||
send(res, 200, serializeRepo(found.record))
|
||||
}
|
||||
|
||||
/**
|
||||
* Repo aus Vorlage erzeugen wie Gitea (`POST /repos/{tplOwner}/{tpl}/generate`): 409, wenn es das
|
||||
* Ziel schon gibt. `setOnGenerate(fn)` ruft fn(repo) nach dem Anlegen auf, BEVOR geantwortet
|
||||
* wird - so laesst sich der sofort feuernde Webhook `repository/created` nachstellen.
|
||||
*/
|
||||
async function handleGenerate(match, searchParams, body, headers, res) {
|
||||
const owner = body?.owner || ''
|
||||
const name = body?.name || ''
|
||||
if (!owner || !name) return send(res, 422, { message: 'owner und name fehlen' })
|
||||
if (repos.has(keyFrom(owner, name))) {
|
||||
return send(res, 409, { message: 'The repository with the same name already exists.' })
|
||||
}
|
||||
const record = addRepoInternal({ full_name: `${owner}/${name}`, description: body.description || '', private: body.private })
|
||||
if (onGenerate) await onGenerate(serializeRepo(record))
|
||||
send(res, 201, serializeRepo(record))
|
||||
}
|
||||
|
||||
function handleGetBranches(match, searchParams, body, headers, res) {
|
||||
const found = findRepoOrRedirect(match[1], match[2])
|
||||
if (!found) return send(res, 404, { message: 'Not Found' })
|
||||
if (found.redirectTo) return sendRepoRedirect(res, found.redirectTo, '/branches')
|
||||
send(res, 200, [{ name: found.record.default_branch || 'main' }])
|
||||
}
|
||||
|
||||
function handlePatchRepo(match, searchParams, body, headers, res) {
|
||||
const found = findRepoOrRedirect(match[1], match[2])
|
||||
if (!found) return send(res, 404, { message: 'Not Found' })
|
||||
@@ -419,6 +444,8 @@ export async function startFakeGitea(options = {}) {
|
||||
{ method: 'GET', re: /^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/hooks$/, handler: handleGetRepoHooks },
|
||||
{ method: 'DELETE', re: /^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/hooks\/([^/]+)$/, handler: handleDeleteRepoHook },
|
||||
{ method: 'GET', re: /^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/activities\/feeds$/, handler: handleFeeds },
|
||||
{ method: 'POST', re: /^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/generate$/, handler: handleGenerate },
|
||||
{ method: 'GET', re: /^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/branches$/, handler: handleGetBranches },
|
||||
{ method: 'GET', re: /^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/contents\/(.+)$/, handler: handleGetContents },
|
||||
{ method: 'POST', re: /^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/contents\/(.+)$/, handler: handleWriteContents },
|
||||
{ method: 'PUT', re: /^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/contents\/(.+)$/, handler: handleWriteContents },
|
||||
@@ -542,6 +569,10 @@ export async function startFakeGitea(options = {}) {
|
||||
pendingFailures.push({ method, pathIncludes, status })
|
||||
}
|
||||
|
||||
function setOnGenerate(fn) {
|
||||
onGenerate = fn || null
|
||||
}
|
||||
|
||||
function close() {
|
||||
for (const socket of sockets) socket.destroy()
|
||||
return new Promise((resolve) => server.close(() => resolve()))
|
||||
@@ -549,6 +580,7 @@ export async function startFakeGitea(options = {}) {
|
||||
|
||||
return {
|
||||
baseUrl,
|
||||
setOnGenerate,
|
||||
calls,
|
||||
repo,
|
||||
addRepo,
|
||||
|
||||
@@ -67,3 +67,14 @@ test('Route: anderer Kunde bleibt ausgesperrt', async () => {
|
||||
assert.equal(r.allowed, false)
|
||||
assert.equal(r.reason, 'no_project')
|
||||
})
|
||||
test('Route: archiviertes Projekt ist fuer den Kunden gesperrt (Entscheidung 2026-10-04)', async () => {
|
||||
const doc = aw.all('websiteProjects').find((d) => d.$id === 'p1')
|
||||
doc.archived = true
|
||||
try {
|
||||
const r = await access(token.c1)
|
||||
assert.equal(r.allowed, false)
|
||||
assert.equal(r.reason, 'no_project')
|
||||
} finally {
|
||||
doc.archived = false
|
||||
}
|
||||
})
|
||||
@@ -103,6 +103,32 @@ test('Schalter aus: kein Runner-Aufruf, alter Pfad', async () => {
|
||||
assert.equal(rs.calls.length, 0)
|
||||
})
|
||||
|
||||
test('fremde Subdomain (kopierte Config): kein Runner-Auftrag, Projekt unverändert', async () => {
|
||||
const original = await project({ subdomain: 'original-seite' })
|
||||
const kopie = await project()
|
||||
const r = await pd.runDeploy(kopie.repo, 'main', { ...cfg(kopie.repo), subdomain: 'original-seite' }, { project: kopie.doc, sha: SHA })
|
||||
assert.equal(r.blocked, true)
|
||||
assert.equal(r.owner, original.repo)
|
||||
assert.equal(submits().length, 0)
|
||||
assert.equal(aw.get('websiteProjects', kopie.id).previewState, undefined)
|
||||
// danach laeuft ein normaler Auftrag fuer dasselbe Repo wieder an
|
||||
const ok = await pd.runDeploy(kopie.repo, 'main', cfg(kopie.repo), { project: kopie.doc, sha: SHA })
|
||||
assert.equal(ok.queued, true)
|
||||
await pd.waitForRunFollowers()
|
||||
})
|
||||
|
||||
test('gesperrter Aufruf waehrend eines laufenden Baus: der Verfolger bringt den Bau trotzdem online', async () => {
|
||||
await project({ subdomain: 'andere-seite' })
|
||||
const { id, repo, doc } = await project()
|
||||
const r = await pd.runDeploy(repo, 'main', cfg(repo), { project: doc, sha: SHA })
|
||||
assert.equal(r.queued, true)
|
||||
const blocked = await pd.runDeploy(repo, 'main', { ...cfg(repo), subdomain: 'andere-seite' }, { project: doc, sha: SHA })
|
||||
assert.equal(blocked.blocked, true)
|
||||
await pd.waitForRunFollowers()
|
||||
assert.equal(aw.get('websiteProjects', id).previewState, 'online')
|
||||
assert.equal(submits().length, 1)
|
||||
})
|
||||
|
||||
test('an: Auftrag mit entschlüsselten Variablen, sofortige Rückgabe, Ergebnis online', async () => {
|
||||
const { id, repo, doc } = await project({ projectName: 'Mein Projekt', previewEnv: envLib.encryptEnv({ API_URL: 'https://x.test' }, key) })
|
||||
const r = await pd.runDeploy(repo, 'main', cfg(repo), { project: doc, sha: SHA })
|
||||
|
||||
@@ -0,0 +1,253 @@
|
||||
// Ablauf Projekt anlegen / archivieren / Import im Ticketsystem (Fehler aus dem Live-Durchlauf 2026-10-04):
|
||||
// - "Neues Projekt" ohne Subdomain schrieb subdomain '' -> Unique-Index -> "Document with the requested ID already exists"
|
||||
// - Wettlauf mit dem Webhook repository/created beim Anlegen
|
||||
// - Reaktivieren liess status 'archived' stehen
|
||||
// - archivierte Repos kamen nie ins Ticketsystem, Archiv-Stand aus Gitea nie an
|
||||
// - "Gitea-Repos synchronisieren" ueberschrieb Projektnamen
|
||||
import { test, before, after } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { startFakeGitea } from './helpers/fakeGitea.js'
|
||||
import { startFakeAppwrite } from './helpers/fakeAppwrite.js'
|
||||
|
||||
let gitea
|
||||
let aw
|
||||
let config
|
||||
let svc
|
||||
let handleRepositoryCreated
|
||||
let upsertWebsiteProjectByRepo
|
||||
|
||||
const docs = () => aw.all('websiteProjects')
|
||||
const docOf = (name) => docs().find((d) => String(d.repoFullName).toLowerCase() === name.toLowerCase())
|
||||
|
||||
before(async () => {
|
||||
gitea = await startFakeGitea({
|
||||
repos: [
|
||||
{ full_name: 'knso/webklar-preview-template' },
|
||||
{ full_name: 'knso/gradient-component' },
|
||||
{ full_name: 'WEBklar/ohne-site' },
|
||||
{ full_name: 'WEBklar/mit-site' },
|
||||
{ full_name: 'WEBklar/D-ner-Nation', description: 'D-ner-Nation' },
|
||||
],
|
||||
})
|
||||
aw = await startFakeAppwrite({
|
||||
unique: { websiteProjects: ['repoFullName', 'subdomain'] },
|
||||
seed: {
|
||||
websiteProjects: [
|
||||
// wie live: ein altes Projekt traegt subdomain '' (danach scheiterte jedes weitere ohne Website)
|
||||
{ repoFullName: 'knso/gradient-component', projectName: 'gradient component', subdomain: '' },
|
||||
{ $id: 'p_ohne', repoFullName: 'WEBklar/ohne-site', projectName: 'Ohne Site', status: 'created' },
|
||||
{ $id: 'p_mit', repoFullName: 'WEBklar/mit-site', projectName: 'Mit Site', subdomain: 'mit-site', status: 'deployed' },
|
||||
{ $id: 'p_doener', repoFullName: 'WEBklar/D-ner-Nation', projectName: 'Döner Nation', subdomain: 'doener-nation' },
|
||||
],
|
||||
customers: [{ $id: 'c1', name: 'Kunde' }],
|
||||
},
|
||||
})
|
||||
|
||||
Object.assign(process.env, {
|
||||
GITEA_BASE_URL: gitea.baseUrl,
|
||||
GITEA_API_TOKEN: 'test-token',
|
||||
GITEA_DEFAULT_OWNER: 'WEBklar',
|
||||
GITEA_TEMPLATE_OWNER: 'knso',
|
||||
GITEA_TEMPLATE_REPO: 'webklar-preview-template',
|
||||
APPWRITE_ENDPOINT: aw.endpoint,
|
||||
APPWRITE_API_KEY: 'test-key',
|
||||
PREVIEW_DEPLOY_ROOT: '',
|
||||
TRAEFIK_DYNAMIC_DIR: '',
|
||||
})
|
||||
;({ config } = await import('../server/config.js'))
|
||||
svc = await import('../server/services/giteaAdmin.js')
|
||||
;({ handleRepositoryCreated } = await import('../server/services/repoAssignJob.js'))
|
||||
;({ upsertWebsiteProjectByRepo } = await import('../server/services/appwriteAdmin.js'))
|
||||
})
|
||||
|
||||
after(async () => {
|
||||
await gitea.close()
|
||||
await aw.close()
|
||||
})
|
||||
|
||||
test('Neues Projekt ohne Subdomain: kein subdomain-Konflikt mehr, Kunde bleibt dran', async () => {
|
||||
const r = await svc.createProjectFromTemplate({ displayName: 'Zweites ohne Website', customerId: 'c1' })
|
||||
assert.equal(r.repoFullName, 'WEBklar/zweites-ohne-website')
|
||||
assert.equal(r.projectType, 'repo')
|
||||
const d = docOf('WEBklar/zweites-ohne-website')
|
||||
assert.equal(d.subdomain, null)
|
||||
assert.equal(d.customerId, 'c1')
|
||||
assert.equal(d.projectName, 'Zweites ohne Website')
|
||||
// Gitea-Beschreibung = Anzeigename (Abgleich/Webhook lesen den Namen von dort)
|
||||
const gen = gitea.calls.find((c) => c.method === 'POST' && c.path.endsWith('/generate'))
|
||||
assert.equal(gen.body.description, 'Zweites ohne Website')
|
||||
// Kundenquelltext nicht oeffentlich (Entscheidung 2026-10-04)
|
||||
assert.equal(gen.body.private, true)
|
||||
})
|
||||
|
||||
test('Neues Projekt: Webhook repository/created legt das Dokument zuerst an -> eines, mit Kunde und Ticket', async () => {
|
||||
gitea.setOnGenerate(async (repo) => {
|
||||
await handleRepositoryCreated({ action: 'created', repository: repo, sender: { login: 'webklar-system' } }, {
|
||||
sendMail: async () => ({ sent: false }),
|
||||
})
|
||||
})
|
||||
try {
|
||||
const r = await svc.createProjectFromTemplate({ displayName: 'Webhook zuerst', customerId: 'c1', ticketId: 't1' })
|
||||
const all = docs().filter((d) => d.repoFullName === r.repoFullName)
|
||||
assert.equal(all.length, 1)
|
||||
assert.equal(all[0].customerId, 'c1')
|
||||
assert.equal(all[0].ticketId, 't1')
|
||||
assert.equal(all[0].projectType, 'repo')
|
||||
assert.equal(all[0].createdByGitea, 'webklar-system')
|
||||
} finally {
|
||||
gitea.setOnGenerate(null)
|
||||
}
|
||||
})
|
||||
|
||||
test('Wettlauf zwischen Suche und Anlage: 409 wird zum Update statt zur Fehlermeldung', async () => {
|
||||
let raced = false
|
||||
aw.setBeforeCreate((col, data) => {
|
||||
if (col !== 'websiteProjects' || raced || data.repoFullName !== 'WEBklar/wettlauf') return
|
||||
raced = true
|
||||
aw.insert('websiteProjects', { repoFullName: 'WEBklar/wettlauf', projectName: 'wettlauf', status: 'synced' })
|
||||
})
|
||||
try {
|
||||
const d = await upsertWebsiteProjectByRepo('WEBklar/wettlauf', { repoFullName: 'WEBklar/wettlauf', customerId: 'c1', projectName: 'Wettlauf' })
|
||||
assert.ok(raced)
|
||||
assert.equal(d.customerId, 'c1')
|
||||
assert.equal(docs().filter((x) => x.repoFullName === 'WEBklar/wettlauf').length, 1)
|
||||
} finally {
|
||||
aw.setBeforeCreate(null)
|
||||
}
|
||||
})
|
||||
|
||||
test('Neues Projekt mit Art (Ticket): kind gesetzt; unbekannte Art -> 400 ohne Repo', async () => {
|
||||
await svc.createProjectFromTemplate({ displayName: 'Mit Art', customerId: 'c1', ticketId: 't2', kind: 'website', staffName: 'Kenso' })
|
||||
const d = docOf('WEBklar/mit-art')
|
||||
assert.deepEqual([d.kind, d.forCustomer, d.kindSetBy, d.previewMode], ['website', true, 'Kenso', 'auto'])
|
||||
assert.ok(d.kindSetAt)
|
||||
|
||||
const before = gitea.calls.filter((c) => c.path.endsWith('/generate')).length
|
||||
await assert.rejects(svc.createProjectFromTemplate({ displayName: 'Falsch', kind: 'quatsch' }), (err) => err.status === 400)
|
||||
assert.equal(gitea.calls.filter((c) => c.path.endsWith('/generate')).length, before)
|
||||
})
|
||||
|
||||
test('Typ "Internes Projekt" schreibt null statt leerer Subdomain', async () => {
|
||||
const r = await svc.updateWebsiteProject('p_mit', { projectType: 'project' })
|
||||
assert.equal(r.subdomain, '')
|
||||
assert.equal(aw.get('websiteProjects', 'p_mit').subdomain, null)
|
||||
// fuer die folgenden Tests wieder als Website
|
||||
await svc.updateWebsiteProject('p_mit', { projectType: 'preview', subdomain: 'mit-site' })
|
||||
assert.equal(aw.get('websiteProjects', 'p_mit').subdomain, 'mit-site')
|
||||
})
|
||||
|
||||
test('Archivieren und Reaktivieren ohne Website: status geht zurueck auf synced', async () => {
|
||||
await svc.archiveRepo('p_ohne', true)
|
||||
assert.deepEqual([aw.get('websiteProjects', 'p_ohne').archived, aw.get('websiteProjects', 'p_ohne').status], [true, 'archived'])
|
||||
assert.equal(gitea.repo('WEBklar/ohne-site').archived, true)
|
||||
|
||||
await svc.archiveRepo('p_ohne', false)
|
||||
assert.deepEqual([aw.get('websiteProjects', 'p_ohne').archived, aw.get('websiteProjects', 'p_ohne').status], [false, 'synced'])
|
||||
assert.equal(gitea.repo('WEBklar/ohne-site').archived, false)
|
||||
})
|
||||
|
||||
test('Reaktivieren mit Website: status nicht mehr archived (pending bis der Deploy meldet)', async () => {
|
||||
await svc.archiveRepo('p_mit', true)
|
||||
assert.equal(aw.get('websiteProjects', 'p_mit').status, 'archived')
|
||||
await svc.archiveRepo('p_mit', false)
|
||||
const d = aw.get('websiteProjects', 'p_mit')
|
||||
assert.equal(d.archived, false)
|
||||
// hier ohne PREVIEW_DEPLOY_ROOT: kein Deploy -> 'pending' und als fehlgeschlagen markiert
|
||||
assert.deepEqual([d.status, d.provisioningStatus], ['pending', 'deploy_failed'])
|
||||
// der Status wird vor dem Redeploy geschrieben, danach nicht mehr (der Runner setzt 'deployed')
|
||||
const patches = aw.calls.filter((c) => c.method === 'PATCH' && c.path.endsWith('/p_mit'))
|
||||
assert.equal(patches.at(-1).body.data.status, undefined)
|
||||
})
|
||||
|
||||
test('Neues Projekt: alter verknuepfter Eintrag mit demselben Namen blockiert mit klarer Meldung, bevor ein Repo entsteht', async () => {
|
||||
aw.insert('websiteProjects', { repoFullName: 'WEBklar/alt-belegt', projectName: 'Alt', archived: true, status: 'archived', kind: 'website', customerId: 'cAlt' })
|
||||
const before = gitea.calls.filter((c) => c.path.endsWith('/generate')).length
|
||||
await assert.rejects(svc.createProjectFromTemplate({ displayName: 'alt belegt', repoName: 'alt-belegt' }), (err) =>
|
||||
err.status === 409 && /alten Projekt/.test(err.message) && /archiviert/.test(err.message))
|
||||
assert.equal(gitea.calls.filter((c) => c.path.endsWith('/generate')).length, before)
|
||||
})
|
||||
|
||||
test('Neues Projekt: alter Platzhalter ohne Bezug wird entfernt, das neue Projekt startet sauber', async () => {
|
||||
aw.insert('websiteProjects', { $id: 'platzhalter', repoFullName: 'WEBklar/frei-machen', projectName: 'alt', archived: true, status: 'archived' })
|
||||
const r = await svc.createProjectFromTemplate({ displayName: 'Frei machen', customerId: 'c1' })
|
||||
assert.equal(aw.get('websiteProjects', 'platzhalter'), undefined)
|
||||
const d = docOf(r.repoFullName)
|
||||
assert.equal(d.archived, false)
|
||||
assert.equal(d.customerId, 'c1')
|
||||
})
|
||||
|
||||
test('Abgleich ueberschreibt den Projektnamen nicht mehr', async () => {
|
||||
await svc.syncReposToAppwrite()
|
||||
assert.equal(aw.get('websiteProjects', 'p_doener').projectName, 'Döner Nation')
|
||||
})
|
||||
|
||||
test('Import: archivierte Repos kommen als archiviert an (ohne Mail-Liste), Gitea-Archivstand wird gespiegelt, ein Fehler bricht nicht ab', async () => {
|
||||
const g = await startFakeGitea({
|
||||
repos: [
|
||||
{ full_name: 'knso/neu-archiviert', archived: true, description: 'Alt' },
|
||||
{ full_name: 'knso/kaputt' },
|
||||
{ full_name: 'knso/neu-aktiv' },
|
||||
{ full_name: 'knso/in-gitea-archiviert', archived: true },
|
||||
{ full_name: 'knso/in-gitea-reaktiviert' },
|
||||
],
|
||||
})
|
||||
const a = await startFakeAppwrite({
|
||||
seed: {
|
||||
websiteProjects: [
|
||||
{ $id: 'x1', repoFullName: 'knso/in-gitea-archiviert', projectName: 'A', status: 'synced', archived: false },
|
||||
{ $id: 'x2', repoFullName: 'knso/in-gitea-reaktiviert', projectName: 'B', status: 'archived', archived: true },
|
||||
],
|
||||
},
|
||||
})
|
||||
const original = { gitea: config.gitea.baseUrl, appwrite: config.appwrite.endpoint }
|
||||
config.gitea.baseUrl = g.baseUrl
|
||||
config.appwrite.endpoint = a.endpoint
|
||||
const originalError = console.error
|
||||
console.error = () => {}
|
||||
try {
|
||||
// erste Anlage (knso/kaputt kommt nach dem archivierten) schlaegt fehl
|
||||
a.failNext({ method: 'POST', pathIncludes: '/collections/websiteProjects/documents', status: 400 })
|
||||
const r = await svc.importNewRepos()
|
||||
const byName = (n) => a.all('websiteProjects').find((d) => d.repoFullName === n)
|
||||
// der erzwungene Fehler trifft die erste Anlage: das archivierte neue Repo
|
||||
assert.deepEqual(r.failed, ['knso/neu-archiviert'])
|
||||
assert.ok(byName('knso/kaputt'))
|
||||
assert.ok(byName('knso/neu-aktiv'))
|
||||
assert.deepEqual(r.createdRepos.map((x) => x.repo.full_name).sort(), ['knso/kaputt', 'knso/neu-aktiv'])
|
||||
assert.equal(r.archiveSynced, 2)
|
||||
assert.deepEqual([a.get('websiteProjects', 'x1').archived, a.get('websiteProjects', 'x1').status], [true, 'archived'])
|
||||
assert.deepEqual([a.get('websiteProjects', 'x2').archived, a.get('websiteProjects', 'x2').status], [false, 'synced'])
|
||||
|
||||
// naechster Lauf holt das archivierte Repo nach - als archiviert, ohne Mail-Liste
|
||||
const r2 = await svc.importNewRepos()
|
||||
assert.equal(r2.archivedImported, 1)
|
||||
assert.deepEqual(r2.createdRepos, [])
|
||||
const arch = byName('knso/neu-archiviert')
|
||||
assert.deepEqual([arch.archived, arch.status, arch.projectName], [true, 'archived', 'Alt'])
|
||||
// dritter Lauf: nichts mehr zu tun
|
||||
const r3 = await svc.importNewRepos()
|
||||
assert.deepEqual([r3.created, r3.archivedImported, r3.archiveSynced, r3.failed.length], [0, 0, 0, 0])
|
||||
} finally {
|
||||
config.gitea.baseUrl = original.gitea
|
||||
config.appwrite.endpoint = original.appwrite
|
||||
console.error = originalError
|
||||
await g.close()
|
||||
await a.close()
|
||||
}
|
||||
})
|
||||
|
||||
test('Vorlage fuer "Neues Projekt" zieht beim Zuweisen nie um', async () => {
|
||||
const { isInternalRepo } = await import('../server/services/repoMove.js')
|
||||
assert.equal(await isInternalRepo('knso/webklar-preview-template'), true)
|
||||
})
|
||||
|
||||
test('CORS erlaubt PUT (Preview-Variablen speichern)', async () => {
|
||||
const { corsMiddleware } = await import('../server/middleware/cors.js')
|
||||
const headers = {}
|
||||
let status = 0
|
||||
const req = { method: 'OPTIONS', get: (h) => (h === 'Origin' ? 'https://ticket.webklar.com' : undefined) }
|
||||
const res = { setHeader: (k, v) => { headers[k] = v }, sendStatus: (s) => { status = s } }
|
||||
corsMiddleware(['https://ticket.webklar.com'])(req, res, () => {})
|
||||
assert.equal(status, 204)
|
||||
assert.match(headers['Access-Control-Allow-Methods'], /\bPUT\b/)
|
||||
})
|
||||
@@ -0,0 +1,87 @@
|
||||
// Entscheidungen vom 04.10.2026: Projekt-Aktionen fuer alle Mitarbeiter, archivierte Projekte im
|
||||
// Kundenportal ausgeblendet. (Private Repos: siehe projektAblauf.test.js, generate-Aufruf.)
|
||||
import { test, after } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { startAppwriteMock } from './support/appwriteMock.js'
|
||||
import { startFakeStripe } from './support/fakeStripe.js'
|
||||
import { useTestEnv } from './support/testEnv.js'
|
||||
|
||||
const aw = await startAppwriteMock()
|
||||
const st = await startFakeStripe()
|
||||
useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })
|
||||
const { startTestApp, rawGet, get, send, sessionCookie } = await import('./support/testApp.js')
|
||||
const { default: projectsRouter } = await import('../server/routes/projects.js')
|
||||
const { default: servicesRouter } = await import('../server/routes/admin/services.js')
|
||||
const { default: customersRouter } = await import('../server/routes/admin/customers.js')
|
||||
const { default: websiteProjectsRouter } = await import('../server/routes/admin/websiteProjects.js')
|
||||
const { default: giteaRouter } = await import('../server/routes/admin/gitea.js')
|
||||
const { default: funktionenRouter } = await import('../server/routes/funktionen.js')
|
||||
const app = await startTestApp({
|
||||
'/api/projects': projectsRouter,
|
||||
'/api/admin/services': servicesRouter,
|
||||
'/api/admin/customers': customersRouter,
|
||||
'/api/admin/website-projects': websiteProjectsRouter,
|
||||
'/api/admin/gitea': giteaRouter,
|
||||
'/api/funktionen': funktionenRouter,
|
||||
})
|
||||
after(() => Promise.all([aw.close(), st.close(), app.close()]))
|
||||
|
||||
aw.seed('websiteProjects', { $id: 'p_aktiv', customerId: 'c1', projectName: 'Aktiv', subdomain: 'aktiv', status: 'deployed' })
|
||||
aw.seed('websiteProjects', { $id: 'p_archiv', customerId: 'c1', projectName: 'Alt', subdomain: 'alt', status: 'archived', archived: true })
|
||||
const kunde = { cookie: sessionCookie({ customerId: 'c1', appwriteUserId: 'u1' }) }
|
||||
const bearer = (jwt) => ({ headers: { Authorization: `Bearer ${jwt}` } })
|
||||
|
||||
test('Kundenportal: archivierte Projekte stehen nicht in der Liste', async () => {
|
||||
const { projects } = await get('/api/projects', kunde)
|
||||
assert.deepEqual(projects.map((p) => p.id), ['p_aktiv'])
|
||||
})
|
||||
|
||||
test('Kundenportal: archiviertes Projekt auch per Direktaufruf nicht erreichbar', async () => {
|
||||
assert.equal((await rawGet('/api/projects/p_archiv/work', kunde)).status, 404)
|
||||
assert.equal((await rawGet('/api/projects/p_aktiv/work', kunde)).status, 200)
|
||||
})
|
||||
|
||||
test('Projekt-Routen: Mitarbeiter ohne Admin-Label kommen rein, Kunden-Konto nicht', async () => {
|
||||
assert.equal((await rawGet('/api/admin/services', bearer('jwt-staff'))).status, 200)
|
||||
assert.equal((await rawGet('/api/admin/services', bearer('jwt-admin'))).status, 200)
|
||||
const kundeKonto = await rawGet('/api/admin/services', bearer('jwt-kunde'))
|
||||
assert.equal(kundeKonto.status, 403)
|
||||
assert.equal(kundeKonto.body.error, 'Nur für Mitarbeiter')
|
||||
assert.equal((await rawGet('/api/admin/services')).status, 401)
|
||||
})
|
||||
|
||||
test('Kunden-Verwaltung bleibt nur fuer Admins', async () => {
|
||||
const r = await rawGet('/api/admin/customers', bearer('jwt-staff'))
|
||||
assert.equal(r.status, 403)
|
||||
assert.equal(r.body.error, 'Admin-Berechtigung erforderlich')
|
||||
})
|
||||
|
||||
test('Funktionen: Kunde sieht archivierte Projekte nicht, die Mitarbeiter-Ansicht schon', async () => {
|
||||
const { listCustomerFeatures } = await import('../server/services/siteFeatures.js')
|
||||
assert.deepEqual((await listCustomerFeatures('c1', { docs: [] })).map((p) => p.projectId), ['p_aktiv'])
|
||||
assert.deepEqual(
|
||||
(await listCustomerFeatures('c1', { docs: [], includeArchived: true })).map((p) => p.projectId).sort(),
|
||||
['p_aktiv', 'p_archiv']
|
||||
)
|
||||
})
|
||||
|
||||
test('Funktionen: archiviertes Projekt mit laufender Funktion bleibt fuer den Kunden sichtbar (Buchungen verwalten)', async () => {
|
||||
const { listCustomerFeatures } = await import('../server/services/siteFeatures.js')
|
||||
const docs = [{ customerId: 'c1', projectId: 'p_archiv', featureKey: 'termine', state: 'active' }]
|
||||
assert.deepEqual((await listCustomerFeatures('c1', { docs })).map((p) => p.projectId).sort(), ['p_aktiv', 'p_archiv'])
|
||||
const aus = [{ customerId: 'c1', projectId: 'p_archiv', featureKey: 'termine', state: 'off' }]
|
||||
assert.deepEqual((await listCustomerFeatures('c1', { docs: aus })).map((p) => p.projectId), ['p_aktiv'])
|
||||
})
|
||||
|
||||
test('Neu bestellen auf archiviertem Projekt geht nicht', async () => {
|
||||
const r = await send('POST', '/api/funktionen/news/checkout', { ...kunde, body: { projectId: 'p_archiv', consent: true } })
|
||||
assert.equal(r.status, 409)
|
||||
assert.match(r.body.error, /archiviert/)
|
||||
})
|
||||
|
||||
test('Vorlage bleibt Admin-Sache; README nur fuer bekannte Projekte', async () => {
|
||||
const t = await send('PATCH', '/api/admin/website-projects/p_aktiv', { ...bearer('jwt-staff'), body: { projectType: 'template' } })
|
||||
assert.equal(t.status, 403)
|
||||
const fremd = await rawGet('/api/admin/gitea/repo-readme?repoFullName=JUSN/tickte-system', bearer('jwt-staff'))
|
||||
assert.equal(fremd.status, 404)
|
||||
})
|
||||
@@ -126,6 +126,17 @@ test('Job: Mail ohne vorherigen Versuch wird nachgeholt (createdByGitea, 0 Versu
|
||||
assert.equal(sink.sent.length, 1)
|
||||
})
|
||||
|
||||
test('Job: vom System-Konto angelegtes Projekt ohne Art wird nicht abgefragt und nicht gemailt', async () => {
|
||||
freshSink()
|
||||
gitea.addRepo({ full_name: 'WEBklar/aus-womS', created_at: ago(1) })
|
||||
aw.insert('websiteProjects', { repoFullName: 'WEBklar/aus-womS', projectName: 'aus WOMS', createdByGitea: 'webklar-system', assignMailAttempts: 0 })
|
||||
const before = gitea.calls.filter((c) => c.path === '/api/v1/repos/WEBklar/aus-womS').length
|
||||
const c = await runRepoAssignJob({ now: NOW })
|
||||
assert.equal(c.retries, 0)
|
||||
assert.equal(sink.sent.length, 0)
|
||||
assert.equal(gitea.calls.filter((x) => x.path === '/api/v1/repos/WEBklar/aus-womS').length, before)
|
||||
})
|
||||
|
||||
test('Job: neues Nutzer-Repo → Mail, Org-Repo → keine Mail', async () => {
|
||||
freshSink()
|
||||
gitea.addRepo({ full_name: 'knso/jobneu', created_at: ago(1) })
|
||||
|
||||
@@ -0,0 +1,249 @@
|
||||
import { test, before, after } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { createHmac } from 'node:crypto'
|
||||
import fs from 'node:fs/promises'
|
||||
import os from 'node:os'
|
||||
import path from 'node:path'
|
||||
import express from 'express'
|
||||
import { startFakeGitea } from './helpers/fakeGitea.js'
|
||||
import { startFakeAppwrite } from './helpers/fakeAppwrite.js'
|
||||
|
||||
// Sperre gegen fremde Subdomains: Ein kopiertes Repo (git clone + push, Vorlage) bringt die
|
||||
// .webklar-preview.json des Originals mit. Ohne Sperre ueberschrieb sein erster Push die
|
||||
// Preview des Originals (Olzinger -> HSK-Vorlage, 04.10.2026).
|
||||
|
||||
const WEBHOOK_TOKEN = 's3cret'
|
||||
const ORIGINAL = 'WEBklar/Olzinger'
|
||||
const KOPIE = 'WEBklar/HSK-Kopie'
|
||||
|
||||
const previewJson = (subdomain) =>
|
||||
JSON.stringify({ enabled: true, type: 'static', branch: 'main', displayName: 'Olzinger', subdomain })
|
||||
|
||||
let gitea
|
||||
let aw
|
||||
let tmp
|
||||
let originalCwd
|
||||
let server
|
||||
let baseUrl
|
||||
let foreignSubdomainOwner
|
||||
let runDeploy
|
||||
let foreignSubdomainBlock
|
||||
|
||||
function pushPayload(repo, { sha, branch = 'main', pusher = 'knso' }) {
|
||||
return {
|
||||
ref: `refs/heads/${branch}`,
|
||||
repository: { full_name: repo, name: repo.split('/')[1], html_url: `${gitea.baseUrl}/${repo}` },
|
||||
commits: [{ id: sha, message: `Commit ${sha}`, author: { name: pusher } }],
|
||||
pusher: { username: pusher },
|
||||
after: sha,
|
||||
}
|
||||
}
|
||||
|
||||
async function webhook(payload) {
|
||||
const bodyText = JSON.stringify(payload)
|
||||
const signature = createHmac('sha256', WEBHOOK_TOKEN).update(bodyText).digest('hex')
|
||||
const res = await fetch(`${baseUrl}/webhook/gitea`, {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json', 'X-Gitea-Signature': signature },
|
||||
body: bodyText,
|
||||
})
|
||||
return { status: res.status, body: await res.json().catch(() => null) }
|
||||
}
|
||||
|
||||
const docOf = (repo) => aw.all('websiteProjects').find((d) => d.repoFullName === repo)
|
||||
|
||||
before(async () => {
|
||||
gitea = await startFakeGitea({
|
||||
repos: [
|
||||
{ full_name: ORIGINAL },
|
||||
{ full_name: KOPIE },
|
||||
{ full_name: 'WEBklar/neu-name' },
|
||||
{ full_name: 'WEBklar/relaunch-kopie' },
|
||||
{ full_name: 'WEBklar/eigene-seite' },
|
||||
],
|
||||
redirects: { 'knso/alt-name': 'WEBklar/neu-name' },
|
||||
contents: {
|
||||
[`${ORIGINAL}:.webklar-preview.json`]: previewJson('olzinger'),
|
||||
[`${KOPIE}:.webklar-preview.json`]: previewJson('olzinger'),
|
||||
'WEBklar/relaunch-kopie:.webklar-preview.json': previewJson('relaunch'),
|
||||
// hat schon eine eigene Preview, Config von Hand auf eine fremde Subdomain gestellt
|
||||
'WEBklar/eigene-seite:.webklar-preview.json': previewJson('olzinger'),
|
||||
},
|
||||
})
|
||||
aw = await startFakeAppwrite({
|
||||
unique: { websiteProjects: ['repoFullName', 'subdomain'] },
|
||||
seed: {
|
||||
websiteProjects: [
|
||||
{ $id: 'olz', repoFullName: ORIGINAL, projectName: 'Olzinger', subdomain: 'olzinger', customerId: 'c1', ticketId: 't1', status: 'deployed' },
|
||||
// per Gitea umgezogen (alter Name leitet weiter), Dokument noch unter dem alten Namen
|
||||
{ $id: 'umzug', repoFullName: 'knso/alt-name', projectName: 'Umzug', subdomain: 'umzug-seite' },
|
||||
// Repo in Gitea geloescht, Dokument haelt die Subdomain noch
|
||||
{ $id: 'weg', repoFullName: 'knso/geloescht', projectName: 'Weg', subdomain: 'weg-seite' },
|
||||
// gehostet ohne Repo (wie die Relaunch-Vorschau)
|
||||
{ $id: 'rel', repoFullName: '', projectName: 'WEBklar Relaunch', subdomain: 'relaunch' },
|
||||
{ $id: 'eigen', repoFullName: 'WEBklar/eigene-seite', projectName: 'Eigene Seite', subdomain: 'eigene-seite', status: 'deployed', provisioningStatus: 'ready' },
|
||||
],
|
||||
workorders: [{ $id: 't1', woid: '100130', customerName: 'Olzinger', topic: 'Website', status: 'Open' }],
|
||||
customers: [{ $id: 'c1', name: 'Olzinger GmbH' }],
|
||||
employees: [{ $id: 'k', displayName: 'Kenso Grimm', shortcode: 'KNSO', email: 'kenso@webklar.com' }],
|
||||
},
|
||||
})
|
||||
|
||||
originalCwd = process.cwd()
|
||||
tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'subdomain-sperre-'))
|
||||
process.chdir(tmp)
|
||||
|
||||
Object.assign(process.env, {
|
||||
GITEA_BASE_URL: gitea.baseUrl,
|
||||
GITEA_API_TOKEN: 'test-token',
|
||||
GITEA_WEBHOOK_TOKEN: WEBHOOK_TOKEN,
|
||||
APPWRITE_ENDPOINT: aw.endpoint,
|
||||
APPWRITE_API_KEY: 'test-key',
|
||||
PREVIEW_DEPLOY_ROOT: '',
|
||||
TRAEFIK_DYNAMIC_DIR: '',
|
||||
PUSH_TIME_SECRET: 'w'.repeat(40),
|
||||
})
|
||||
|
||||
const [{ default: giteaWebhookRoutes }, previewDeploy, mailer] = await Promise.all([
|
||||
import('../server/routes/webhook/gitea.js'),
|
||||
import('../server/services/previewDeploy.js'),
|
||||
import('../server/services/mailer.js'),
|
||||
])
|
||||
foreignSubdomainOwner = previewDeploy.foreignSubdomainOwner
|
||||
runDeploy = previewDeploy.runDeploy
|
||||
foreignSubdomainBlock = previewDeploy.foreignSubdomainBlock
|
||||
mailer.setMailTransportForTests({ sendMail: async () => ({}) })
|
||||
|
||||
const app = express()
|
||||
app.use(express.json({ limit: '2mb', verify: (req, _res, buf) => { req.rawBody = buf } }))
|
||||
app.use('/webhook', giteaWebhookRoutes)
|
||||
server = await new Promise((resolve) => {
|
||||
const s = app.listen(0, '127.0.0.1', () => resolve(s))
|
||||
})
|
||||
baseUrl = `http://127.0.0.1:${server.address().port}`
|
||||
})
|
||||
|
||||
after(async () => {
|
||||
if (server) await new Promise((resolve) => server.close(resolve))
|
||||
if (originalCwd) process.chdir(originalCwd)
|
||||
await gitea?.close()
|
||||
await aw?.close()
|
||||
if (tmp) await fs.rm(tmp, { recursive: true, force: true })
|
||||
})
|
||||
|
||||
test('foreignSubdomainOwner: freie Subdomain und eigenes Repo sind nicht fremd', async () => {
|
||||
assert.equal(await foreignSubdomainOwner(KOPIE, 'noch-frei'), '')
|
||||
assert.equal(await foreignSubdomainOwner(ORIGINAL, 'olzinger'), '')
|
||||
assert.equal(await foreignSubdomainOwner('webklar/OLZINGER', 'olzinger'), '', 'Schreibweise egal')
|
||||
assert.equal(await foreignSubdomainOwner(KOPIE, ''), '')
|
||||
})
|
||||
|
||||
test('foreignSubdomainOwner: Subdomain eines anderen Repos ist fremd', async () => {
|
||||
assert.equal(await foreignSubdomainOwner(KOPIE, 'olzinger'), ORIGINAL)
|
||||
})
|
||||
|
||||
test('foreignSubdomainOwner: in Gitea umgezogenes Repo ist nicht fremd, geloeschtes schon', async () => {
|
||||
assert.equal(await foreignSubdomainOwner('WEBklar/neu-name', 'umzug-seite'), '')
|
||||
assert.equal(await foreignSubdomainOwner(KOPIE, 'weg-seite'), 'knso/geloescht')
|
||||
})
|
||||
|
||||
test('foreignSubdomainOwner: Projekt ohne Repo haelt seine Subdomain, sperrt sich aber nicht selbst', async () => {
|
||||
assert.equal(await foreignSubdomainOwner(KOPIE, 'relaunch'), 'Projekt „WEBklar Relaunch“ (ohne Repo)')
|
||||
assert.equal(await foreignSubdomainOwner('', 'relaunch'), '')
|
||||
})
|
||||
|
||||
test('runDeploy verweigert eine fremde Subdomain, bevor irgendetwas geklont wird', async () => {
|
||||
const before = gitea.calls.length
|
||||
const r = await runDeploy(KOPIE, 'main', { enabled: true, type: 'static', subdomain: 'olzinger' })
|
||||
assert.equal(r.deployed, false)
|
||||
assert.equal(r.blocked, true)
|
||||
assert.equal(r.reason, 'subdomain_foreign')
|
||||
assert.equal(r.subdomain, 'olzinger')
|
||||
assert.equal(r.owner, ORIGINAL)
|
||||
// nur die Besitzer-Pruefung fragt Gitea (nach dem Original), fuer die Kopie wird nichts geholt
|
||||
assert.deepEqual(gitea.calls.slice(before).map((c) => `${c.method} ${c.path}`), [`GET /api/v1/repos/${ORIGINAL}`])
|
||||
})
|
||||
|
||||
test('runDeploy: Pruefung nicht moeglich (Appwrite-Fehler) → Deploy laeuft trotzdem', async () => {
|
||||
aw.failNext({ method: 'GET', pathIncludes: 'websiteProjects', status: 500 })
|
||||
const r = await runDeploy(KOPIE, 'main', { enabled: true, type: 'static', subdomain: 'olzinger' })
|
||||
assert.equal(r.blocked, undefined)
|
||||
assert.equal(r.reason, 'PREVIEW_DEPLOY_ROOT nicht gesetzt')
|
||||
})
|
||||
|
||||
test('foreignSubdomainBlock ohne failOpen (Webhook): Appwrite-Fehler wird weitergereicht', async () => {
|
||||
aw.failNext({ method: 'GET', pathIncludes: 'websiteProjects', status: 500 })
|
||||
await assert.rejects(foreignSubdomainBlock(KOPIE, 'olzinger'))
|
||||
assert.equal((await foreignSubdomainBlock(KOPIE, 'olzinger')).owner, ORIGINAL)
|
||||
})
|
||||
|
||||
test('runDeploy: eigene Subdomain des uebergebenen Projekts und subdomainChecked brauchen keine Abfrage', async () => {
|
||||
const calls = aw.calls.length
|
||||
const own = await runDeploy(ORIGINAL, 'main', { subdomain: 'olzinger' }, { project: aw.get('websiteProjects', 'olz') })
|
||||
assert.equal(own.reason, 'PREVIEW_DEPLOY_ROOT nicht gesetzt')
|
||||
const checked = await runDeploy(KOPIE, 'main', { subdomain: 'olzinger' }, { subdomainChecked: true })
|
||||
assert.equal(checked.blocked, undefined, 'der Aufrufer hat schon geprueft')
|
||||
assert.equal(aw.calls.length, calls)
|
||||
})
|
||||
|
||||
test('runDeploy: eigene Subdomain laeuft weiter wie bisher', async () => {
|
||||
const r = await runDeploy(ORIGINAL, 'main', { enabled: true, type: 'static', subdomain: 'olzinger' })
|
||||
assert.equal(r.blocked, undefined)
|
||||
assert.equal(r.reason, 'PREVIEW_DEPLOY_ROOT nicht gesetzt')
|
||||
})
|
||||
|
||||
test('Webhook: Push einer Kopie mit fremder Subdomain → kein Deploy, Projekt ohne Preview', async () => {
|
||||
const r = await webhook(pushPayload(KOPIE, { sha: 'aaaa1111' }))
|
||||
assert.equal(r.status, 200)
|
||||
assert.equal(r.body.subdomain, '')
|
||||
assert.equal(r.body.previewUrl, '')
|
||||
assert.equal(r.body.deploy.blocked, true)
|
||||
assert.equal(r.body.deploy.owner, ORIGINAL)
|
||||
|
||||
const kopie = docOf(KOPIE)
|
||||
assert.ok(kopie, 'Dokument der Kopie angelegt')
|
||||
assert.ok(!kopie.subdomain, 'Kopie bekommt die fremde Subdomain nicht')
|
||||
assert.equal(kopie.status, 'synced')
|
||||
assert.equal(kopie.projectName, 'HSK-Kopie', 'nicht der Anzeigename aus der fremden Config')
|
||||
|
||||
const original = aw.get('websiteProjects', 'olz')
|
||||
assert.equal(original.subdomain, 'olzinger')
|
||||
assert.equal(original.status, 'deployed')
|
||||
})
|
||||
|
||||
test('Webhook: Kopie auf anderem Branch bekommt die fremde Subdomain auch nicht', async () => {
|
||||
const r = await webhook(pushPayload(KOPIE, { sha: 'bbbb2222', branch: 'entwurf' }))
|
||||
assert.equal(r.status, 200)
|
||||
assert.equal(r.body.subdomain, '')
|
||||
assert.ok(!docOf(KOPIE).subdomain)
|
||||
})
|
||||
|
||||
test('Webhook: Kopie mit der Subdomain eines Projekts ohne Repo wird gesperrt', async () => {
|
||||
const r = await webhook(pushPayload('WEBklar/relaunch-kopie', { sha: 'cccc3333' }))
|
||||
assert.equal(r.status, 200)
|
||||
assert.equal(r.body.deploy.blocked, true)
|
||||
assert.equal(aw.get('websiteProjects', 'rel').subdomain, 'relaunch')
|
||||
})
|
||||
|
||||
test('Webhook: Push des Originals deployt wie bisher', async () => {
|
||||
const r = await webhook(pushPayload(ORIGINAL, { sha: 'dddd4444' }))
|
||||
assert.equal(r.status, 200)
|
||||
assert.equal(r.body.subdomain, 'olzinger')
|
||||
assert.equal(r.body.deploy.blocked, undefined)
|
||||
assert.equal(r.body.deploy.reason, 'PREVIEW_DEPLOY_ROOT nicht gesetzt')
|
||||
assert.equal(docOf(ORIGINAL).subdomain, 'olzinger')
|
||||
})
|
||||
|
||||
test('Webhook: Projekt mit eigener Preview und fremder Subdomain in der Config bleibt, wie es ist', async () => {
|
||||
const r = await webhook(pushPayload('WEBklar/eigene-seite', { sha: 'ffff6666' }))
|
||||
assert.equal(r.status, 200)
|
||||
assert.equal(r.body.deploy.blocked, true)
|
||||
const doc = aw.get('websiteProjects', 'eigen')
|
||||
assert.equal(doc.subdomain, 'eigene-seite')
|
||||
assert.equal(doc.status, 'deployed')
|
||||
assert.equal(doc.provisioningStatus, 'ready')
|
||||
assert.equal(doc.projectName, 'Eigene Seite')
|
||||
assert.equal(doc.previewState, 'failed', 'WOMS zeigt den Fehlertext nur bei failed')
|
||||
assert.match(doc.previewError, /„olzinger“, die gehört WEBklar\/Olzinger/)
|
||||
assert.equal(aw.get('websiteProjects', 'olz').subdomain, 'olzinger')
|
||||
})
|
||||
@@ -1030,7 +1030,7 @@ test('funktion-bestellen.js statisch: kein termine*.js, relative Importe, von ke
|
||||
assert.doesNotMatch(readFileSync(new URL(`../public/${datei}`, import.meta.url), 'utf8'), /from '\/funktion-bestellen\.js'|import\('\/funktion-bestellen\.js'\)/, `${datei}: kein absoluter Import`)
|
||||
}
|
||||
const fn = readFileSync(new URL('../public/funktionen.js', import.meta.url), 'utf8')
|
||||
assert.deepEqual(fn.match(/from '\/[^']+'/g), ["from '/analyse-view.js'", "from '/geraete.js'"], 'funktionen.js behält genau diese beiden absoluten Importe')
|
||||
assert.deepEqual(fn.match(/from '\/[^']+'/g), ["from '/fn-util.js'", "from '/analyse-view.js'"], 'funktionen.js behält genau diese beiden absoluten Importe')
|
||||
assert.doesNotMatch(fn, /funktion-bestellen/)
|
||||
})
|
||||
|
||||
|
||||
@@ -311,9 +311,9 @@ test('Portal: Ansicht #termine ist verdrahtet, funktionen.js lädt keine Terminp
|
||||
assert.match(html, /<section class="kb-view" id="view-termine">[\s\S]*<h1>Terminplaner<\/h1>[\s\S]*<div id="termine-body">/)
|
||||
assert.match(html, /<link rel="stylesheet" href="\/termine\.css">/)
|
||||
// R4: funktionen.js lädt keine Terminplaner-Module (die Kachel steht inline); seine absoluten Importe biegt
|
||||
// test/funktionenTiles.test.js um – genau diese beiden (/geraete.js kam mit der Heatmap im Gerätrahmen auf main)
|
||||
// test/funktionenTiles.test.js um – genau diese beiden (die Analyse-Oberfläche liegt in analyse.js, mit relativen Importen)
|
||||
const fn = lies('public/funktionen.js')
|
||||
assert.deepEqual(fn.match(/from '\/[^']+'/g), ["from '/analyse-view.js'", "from '/geraete.js'"])
|
||||
assert.deepEqual(fn.match(/from '\/[^']+'/g), ["from '/fn-util.js'", "from '/analyse-view.js'"])
|
||||
assert.doesNotMatch(fn, /from '\/termine/)
|
||||
// dazu genau ein relativer Import: die gemeinsame Quelle des Links „Zu Verträge“ (Reiner Datenmodul, kein Terminplaner-Modul; C10b)
|
||||
assert.deepEqual(fn.match(/from '\.[^']+'/g), ["from './vertraege-link.js'"])
|
||||
|
||||
+317
-42
@@ -1,4 +1,5 @@
|
||||
// Playwright-Check Analyse-Panel (Einschalten-Dialog + aktives Panel): statischer Server fuer public/ + gemockte API.
|
||||
// Playwright-Check Analyse (Cockpit): statischer Server fuer public/ + gemockte API.
|
||||
// Zustaende: Einschalten, aktiv (volle Daten, neu, wenig Daten, Dev-Modus, alter Collector, langer Pfad, 503), Reiter, Zeitraum.
|
||||
// Nicht Teil von npm test. Aufruf: node test/ui/analyse.ui.mjs [Ausgabeordner]
|
||||
import http from 'node:http'
|
||||
import { readFile, mkdir } from 'node:fs/promises'
|
||||
@@ -7,7 +8,7 @@ import { fileURLToPath } from 'node:url'
|
||||
import { chromium } from '/root/.npm/_npx/db89d7302a373f10/node_modules/playwright-core/index.mjs'
|
||||
|
||||
const pub = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../public')
|
||||
const SHOTS = process.argv[2] || '/root/reports/website-analyse-2026-10-01'
|
||||
const SHOTS = process.argv[2] || '/root/reports/analyse-ueberarbeitung-2026-10-04/screens'
|
||||
await mkdir(SHOTS, { recursive: true })
|
||||
const TYPES = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.svg': 'image/svg+xml', '.png': 'image/png', '.ico': 'image/x-icon', '.webmanifest': 'application/json' }
|
||||
const server = http.createServer(async (req, res) => {
|
||||
@@ -22,83 +23,357 @@ const server = http.createServer(async (req, res) => {
|
||||
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
|
||||
const base = `http://127.0.0.1:${server.address().port}`
|
||||
|
||||
/* --- Testdaten: Form wie analytics/src/stats.js, Werte wie die Fixture "Boulderhalle Überhang" --- */
|
||||
const legal = { avv: '/rechtliches/avv-website-analyse-2026-10-02.html', lb: '/rechtliches/leistungsbeschreibung-website-analyse-2026-10-02.html' }
|
||||
const controller = { ok: true, company: 'Bäckerei Berg GmbH', address: 'Hauptstraße 1, 12345 Musterstadt', email: 'info@baeckerei-berg.example' }
|
||||
const base1 = { projectId: 'p1', projectName: 'Bäckerei Berg', liveUrl: 'https://baeckerei.example', features: { news: { state: 'off' } } }
|
||||
const baseProject = { projectId: 'p1', projectName: 'Boulderhalle Überhang', liveUrl: 'https://baeckerei.example', features: { news: { state: 'off' } } }
|
||||
const analyse = (over) => ({ state: 'active', eligible: true, devMode: false, accentColor: '#1d4ed8', avvVersion: '2026-10-02', activatedAt: '2026-08-12T09:00:00.000Z', legal, controller, ...over })
|
||||
const project = (over = {}) => ({ ...baseProject, analyse: analyse(over) })
|
||||
|
||||
const TODAY = '2026-10-04'
|
||||
const addDays = (day, n) => new Date(Date.UTC(+day.slice(0, 4), +day.slice(5, 7) - 1, +day.slice(8, 10) + n)).toISOString().slice(0, 10)
|
||||
const daysOf = (from, n, base, spike = -1) => Array.from({ length: n }, (_, i) => ({
|
||||
day: addDays(from, i), pv: i === spike ? 371 : Math.round(base * (1 + 0.25 * Math.sin(i / 2.3))), visitors: 80 + (i % 7) * 4, contacts: 4 + (i % 5), avgSec: 100 + (i % 9) * 3,
|
||||
}))
|
||||
const TOTALS = {
|
||||
7: { pv: 1640, visitors: 560, contacts: 41, consentRate: 0.61, engaged: 400, avgSec: 101, avgScroll: 62 },
|
||||
30: { pv: 6930, visitors: 2410, contacts: 188, consentRate: 0.61, engaged: 1800, avgSec: 108, avgScroll: 64 },
|
||||
90: { pv: 19800, visitors: 6700, contacts: 530, consentRate: 0.6, engaged: 5000, avgSec: 111, avgScroll: 63 },
|
||||
}
|
||||
const BEFORE = {
|
||||
7: { pv: 1500, visitors: 520, contacts: 35, consentRate: 0.6, engaged: 380, avgSec: 99, avgScroll: 60 },
|
||||
30: { pv: 6080, visitors: 2210, contacts: 143, consentRate: 0.6, engaged: 1500, avgSec: 114, avgScroll: 60 },
|
||||
90: { pv: 17900, visitors: 6200, contacts: 470, consentRate: 0.6, engaged: 4500, avgSec: 112, avgScroll: 61 },
|
||||
}
|
||||
const SCALE = { 7: 0.25, 30: 1, 90: 3 } // Anteil der 30-Tage-Zahlen je Zeitraum
|
||||
const PAGES = [['/', 2480], ['/preise', 1310], ['/kurse', 1150], ['/routen', 960], ['/oeffnungszeiten', 640], ['/team', 410], ['/kontakt', 300], ['/impressum', 120], ['/datenschutz', 90]]
|
||||
// Der Zeitraum endet gestern (abgeschlossene Tage); heute steht getrennt in `today`
|
||||
function makeStats(range, over = {}) {
|
||||
const from = addDays(TODAY, -range)
|
||||
const pfrom = addDays(from, -range)
|
||||
return {
|
||||
range, from, to: addDays(TODAY, -1), firstDay: addDays(pfrom, -40), totals: TOTALS[range], series: daysOf(from, range, 231, Math.min(14, range - 1)),
|
||||
today: { day: TODAY, pv: 42, visitors: 17, contacts: 2 },
|
||||
pages: PAGES.map(([key, count]) => ({ key, count: Math.round(count * SCALE[range]) })),
|
||||
refs: [{ key: 'google.com', count: 880 }, { key: '', count: 700 }, { key: 'instagram.com', count: 400 }, { key: 'l.facebook.com', count: 290 }].map((r) => ({ ...r, count: Math.round(r.count * SCALE[range]) })),
|
||||
countries: [{ key: 'DE', count: 6000 }, { key: 'AT', count: 600 }, { key: 'CH', count: 330 }],
|
||||
devices: [{ key: 'm', count: 4590 }, { key: 'd', count: 2030 }, { key: 't', count: 310 }],
|
||||
contacts: [{ key: 'tel', count: 96 }, { key: 'mail', count: 41 }, { key: 'wa', count: 38 }, { key: 'out', count: 13 }],
|
||||
banner: { shown: 3950, accept: 2410, reject: 1540 },
|
||||
previous: {
|
||||
from: pfrom, to: addDays(from, -1), complete: true, totals: BEFORE[range], series: daysOf(pfrom, range, 200),
|
||||
contacts: [{ key: 'tel', count: 75 }, { key: 'mail', count: 32 }, { key: 'wa', count: 21 }, { key: 'out', count: 13 }],
|
||||
},
|
||||
...over,
|
||||
}
|
||||
}
|
||||
const longPath = `/${'a'.repeat(120)}`
|
||||
const OLD = (range) => ({
|
||||
totals: { pv: 612, visitors: 214, contacts: 18, consentRate: 0.62 }, series: daysOf(addDays(TODAY, -13), 14, 40).map(({ day, pv }) => ({ day, pv })),
|
||||
pages: [{ key: '/', count: 300 }], refs: [], countries: [], devices: [], contacts: [], banner: { shown: 10, accept: 6, reject: 4 }, range,
|
||||
})
|
||||
// je Zustand: die Website und die Statistik (nach range)
|
||||
const SCENARIOS = {
|
||||
off: { ...base1, analyse: { state: 'off', eligible: true, accentColor: '#1d4ed8', avvVersion: '2026-10-02', legal, controller } },
|
||||
missing: { ...base1, analyse: { state: 'off', eligible: true, accentColor: '#1d4ed8', avvVersion: '2026-10-02', legal, controller: { ok: false, company: '', address: '', email: '', missing: ['firma'] } } },
|
||||
active: { ...base1, analyse: { state: 'active', eligible: true, accentColor: '#1d4ed8', avvVersion: '2026-10-02', legal, controller } },
|
||||
}
|
||||
const days = Array.from({ length: 14 }, (_, i) => ({ day: `2026-09-${String(17 + i).padStart(2, '0')}`, pv: 20 + ((i * 7) % 13) * 4 }))
|
||||
const stats = {
|
||||
totals: { pv: 612, visitors: 214, contacts: 18, consentRate: 0.62 }, series: days,
|
||||
pages: [{ key: '/', count: 300 }, { key: '/kontakt', count: 120 }], refs: [{ key: '', count: 200 }, { key: 'google.com', count: 90 }],
|
||||
countries: [{ key: 'DE', count: 500 }], devices: [{ key: 'm', count: 380 }, { key: 'd', count: 230 }], contacts: [{ key: 'tel', count: 12 }],
|
||||
banner: { shown: 300, accept: 186, reject: 114 },
|
||||
off: { project: project({ state: 'off' }) },
|
||||
missing: { project: project({ state: 'off', controller: { ok: false, company: '', address: '', email: '', missing: ['firma'] } }) },
|
||||
full: { project: project(), stats: (r) => makeStats(r) },
|
||||
neu: { project: project(), stats: (r) => makeStats(r, { firstDay: addDays(TODAY, -12), previous: { ...makeStats(r).previous, complete: false } }) },
|
||||
wenig: { project: project(), stats: (r) => makeStats(r, { totals: { ...TOTALS[r], pv: 12 } }) },
|
||||
dev: { project: project({ devMode: true }), stats: (r) => makeStats(r) },
|
||||
alt: { project: project(), stats: (r) => OLD(r) },
|
||||
stark: { project: project(), stats: (r) => makeStats(r, { series: daysOf(addDays(TODAY, -r), r, 2400, Math.min(14, r - 1)) }) },
|
||||
sehrStark: { project: project(), stats: (r) => makeStats(r, { series: daysOf(addDays(TODAY, -r), r, 12000, Math.min(14, r - 1)) }) },
|
||||
langerPfad: { project: project(), stats: (r) => makeStats(r, { pages: [{ key: longPath, count: 900 }, { key: '/kurz', count: 500 }], refs: [{ key: `${'h'.repeat(90)}.example.com`, count: 300 }] }) },
|
||||
fehler: { project: project(), stats: null },
|
||||
zwei: { projects: [project(), { ...baseProject, projectId: 'p2', projectName: 'Zweite Website mit einem wirklich sehr langen Namen, der nicht in eine Zeile passt', analyse: analyse({}) }], stats: (r) => makeStats(r) },
|
||||
}
|
||||
|
||||
let scenario = 'off'
|
||||
const browser = await chromium.launch()
|
||||
let statsRequests = []
|
||||
let delayFirst30 = 0
|
||||
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
|
||||
const launch = () => chromium.launch().catch(() => chromium.launch({ executablePath: '/root/.cache/ms-playwright/chromium-1234/chrome-linux64/chrome' }))
|
||||
const browser = await launch()
|
||||
let failed = 0
|
||||
const check = (name, ok) => { console.log(`${ok ? 'OK ' : 'FAIL'} ${name}`); if (!ok) failed += 1 }
|
||||
const TIMEOUT = Number(process.env.UI_TIMEOUT) || 120000
|
||||
try {
|
||||
for (const [label, viewport] of [['desktop', { width: 1280, height: 900 }], ['phone', { width: 390, height: 844 }]]) {
|
||||
const ctx = await browser.newContext({ viewport })
|
||||
for (const [label, viewport, touch] of [['desktop', { width: 1440, height: 1000 }, false], ['phone', { width: 402, height: 874 }, true]]) {
|
||||
const ctx = await browser.newContext({ viewport, hasTouch: touch })
|
||||
ctx.setDefaultTimeout(TIMEOUT)
|
||||
const page = await ctx.newPage()
|
||||
const errors = []
|
||||
page.on('pageerror', (e) => errors.push(e.message))
|
||||
await page.route('**/api/**', async (route) => {
|
||||
const p = new URL(route.request().url()).pathname
|
||||
const json = (b) => route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(b) })
|
||||
const url = new URL(route.request().url())
|
||||
const p = url.pathname
|
||||
const json = (b, status = 200) => route.fulfill({ status, contentType: 'application/json', body: JSON.stringify(b) }).catch(() => {})
|
||||
const sc = SCENARIOS[scenario]
|
||||
if (p === '/api/auth/me') return json({ authenticated: true, role: 'customer', customer: { id: 'c1', code: '1001', name: 'Berta Berg', email: 'b@example.test' } })
|
||||
if (p === '/api/projects') return json({ projects: [{ id: 'p1', name: 'Bäckerei Berg', status: 'live' }] })
|
||||
if (p === '/api/projects') return json({ projects: [{ id: 'p1', name: 'Boulderhalle Überhang', status: 'live' }] })
|
||||
if (p === '/api/features') return json({ features: [] })
|
||||
if (p === '/api/activity') return json({ tickets: [] })
|
||||
if (p === '/api/funktionen') return json({ projects: [SCENARIOS[scenario]] })
|
||||
if (p === '/api/funktionen/analyse/stats') return json(stats)
|
||||
if (p === '/api/funktionen') return json({ projects: sc.projects || [sc.project] })
|
||||
if (p === '/api/funktionen/analyse/stats') {
|
||||
const range = Number(url.searchParams.get('range'))
|
||||
statsRequests.push(range)
|
||||
if (range === 30 && delayFirst30 > 0) {
|
||||
delayFirst30 -= 1
|
||||
await sleep(1500)
|
||||
}
|
||||
if (!sc.stats) return json({ error: 'Auswertung nicht erreichbar' }, 503)
|
||||
return json(sc.stats(range))
|
||||
}
|
||||
if (p === '/api/funktionen/analyse/heatmap-link') return json({ url: `${base}/offline.html` })
|
||||
if (p === '/api/funktionen/analyse/deactivate') return json({ ok: true })
|
||||
return json({})
|
||||
})
|
||||
const open = async (sc) => {
|
||||
// waitFor: Selektor, der den fertigen Zustand anzeigt
|
||||
const open = async (sc, waitFor = '.an-ov:not(.an-skeleton)') => {
|
||||
scenario = sc
|
||||
statsRequests = []
|
||||
await page.goto('about:blank')
|
||||
await page.goto(`${base}/dashboard.html#analyse`)
|
||||
await page.waitForSelector('#analyse-body .kb-panel')
|
||||
await page.waitForTimeout(900)
|
||||
await page.waitForSelector('#analyse-body .an')
|
||||
await page.waitForSelector(waitFor)
|
||||
await page.waitForTimeout(300)
|
||||
}
|
||||
const shot = async (name) => {
|
||||
const height = await page.evaluate(() => Math.min(document.documentElement.scrollHeight, 3200))
|
||||
const height = await page.evaluate(() => Math.min(document.documentElement.scrollHeight, 4200))
|
||||
await page.setViewportSize({ width: viewport.width, height: Math.max(viewport.height, height) })
|
||||
await page.waitForTimeout(150)
|
||||
await page.screenshot({ path: `${SHOTS}/task-7-${label}-${name}.png` })
|
||||
await page.waitForTimeout(250)
|
||||
await page.screenshot({ path: `${SHOTS}/${label}-${name}.png` })
|
||||
await page.setViewportSize(viewport)
|
||||
}
|
||||
const noScroll = async (n) => check(`${label} kein_horizontaler_scroll ${n}`, await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth))
|
||||
const noScroll = () => page.evaluate(() => document.scrollingElement.scrollWidth <= window.innerWidth)
|
||||
const text = (sel) => page.evaluate((s) => document.querySelector(s)?.textContent ?? '', sel)
|
||||
const count = (sel) => page.evaluate((s) => document.querySelectorAll(s).length, sel)
|
||||
const L = (name) => `${label} ${name}`
|
||||
|
||||
await open('off')
|
||||
const text = await page.textContent('#analyse-body')
|
||||
check(`${label} verantwortlicher`, text.includes('Bäckerei Berg GmbH') && text.includes('info@baeckerei-berg.example'))
|
||||
check(`${label} links`, (await page.$$eval('#analyse-body a[href^="/rechtliches/"]', (a) => a.map((x) => x.getAttribute('href')))).join() === `${legal.avv},${legal.lb}`)
|
||||
check(`${label} knopf_gesperrt_ohne_haken`, await page.isDisabled('#an-on'))
|
||||
/* --- Einschalten (wie bisher) --- */
|
||||
await open('off', '#an-on')
|
||||
const body = await text('#analyse-body')
|
||||
const linkOk = (await page.$$eval('#analyse-body a[href^="/rechtliches/"]', (a) => a.map((x) => x.getAttribute('href')))).join() === `${legal.avv},${legal.lb}`
|
||||
const disabledFirst = await page.isDisabled('#an-on')
|
||||
const preview = (await text('#an-preview')).includes('Annehmen') && (await text('#an-preview')).includes('Ablehnen')
|
||||
await page.check('#an-avv')
|
||||
check(`${label} knopf_frei_mit_haken`, !(await page.isDisabled('#an-on')))
|
||||
await noScroll('einschalten')
|
||||
const enabled = !(await page.isDisabled('#an-on'))
|
||||
check(L('Einschalten: Banner-Vorschau, Häkchen schaltet Knopf frei (wie bisher)'), body.includes('Bäckerei Berg GmbH') && body.includes('info@baeckerei-berg.example') && linkOk && preview && disabledFirst && enabled)
|
||||
check(L('Einschalten: Kopfleiste ohne Zeitraum und Reiter, Status "Analyse ist noch ausgeschaltet"'), (await count('.an-top')) === 1 && (await count('.an-seg')) === 0 && (await count('.an-tabs')) === 0 && (await text('.an-status')).includes('Analyse ist noch ausgeschaltet'))
|
||||
check(L('kein_horizontaler_scroll einschalten'), await noScroll())
|
||||
await shot('einschalten')
|
||||
|
||||
await open('missing')
|
||||
await open('missing', '#an-missing')
|
||||
await page.check('#an-avv')
|
||||
check(`${label} gesperrt_ohne_angaben`, (await page.isDisabled('#an-on')) && Boolean(await page.$('#an-missing')))
|
||||
check(L('gesperrt_ohne_angaben'), (await page.isDisabled('#an-on')) && Boolean(await page.$('#an-missing')))
|
||||
await shot('fehlende-angaben')
|
||||
|
||||
await open('active')
|
||||
await page.waitForSelector('.an-kpis')
|
||||
await noScroll('aktiv')
|
||||
/* --- aktiv, volle Daten --- */
|
||||
await open('full')
|
||||
check(L('aktiv: Block "Das Wichtigste" mit "14 % mehr"'), (await text('.an-sum')).includes('Das Wichtigste') && (await text('.an-sum')).includes('14 % mehr'))
|
||||
check(L('aktiv: 4 Kacheln, 3 Chips ▲, 1 Chip ▼'), (await count('.an-kpis .an-kpi')) === 4 && (await count('.an-kpis .an-delta.up')) === 3 && (await count('.an-kpis .an-delta.down')) === 1 && (await text('.an-kpis')).includes('▲') && (await text('.an-kpis')).includes('▼'))
|
||||
check(L('aktiv: Kopfleiste mit "Heute bisher: 42 Aufrufe" und Stand-Uhrzeit, Zeitraum 30 Tage gewählt, Reiter Übersicht gewählt'), /^Analyse aktiv · Heute bisher: 42 Aufrufe · Stand: \d\d:\d\d Uhr$/.test(await text('.an-status')) && (await page.getAttribute('.an-seg .on', 'data-range')) === '30' && (await page.getAttribute('.an-tabbtn[aria-selected="true"]', 'data-tab')) === 'uebersicht')
|
||||
check(L('kein_horizontaler_scroll aktiv'), await noScroll())
|
||||
// Raster: Desktop 4 Kacheln nebeneinander, Handy 2 x 2; Diagramm und Kontaktkarte gleich hoch (Desktop)
|
||||
const tiles = await page.$$eval('.an-kpis .an-kpi', (els) => els.map((e) => { const r = e.getBoundingClientRect(); return { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width) } }))
|
||||
check(L(touch ? 'Kacheln 2 × 2' : 'Kacheln 4 nebeneinander'), touch
|
||||
? tiles[0].y === tiles[1].y && tiles[2].y === tiles[3].y && tiles[2].y > tiles[0].y && tiles[0].x === tiles[2].x && tiles[1].x > tiles[0].x
|
||||
: tiles.every((t) => t.y === tiles[0].y))
|
||||
await page.evaluate(() => document.querySelector('.an-chart').scrollIntoView({ block: 'center' }))
|
||||
await page.waitForTimeout(200)
|
||||
const boxes = await page.evaluate(() => {
|
||||
const r = (s) => { const b = document.querySelector(s).getBoundingClientRect(); return { top: Math.round(b.top), height: Math.round(b.height), left: b.left, right: b.right } }
|
||||
return { chart: r('.an-chartbox'), contacts: r('.an-contacts'), svg: r('.an-chart') }
|
||||
})
|
||||
if (!touch) {
|
||||
check(L(`Diagramm und Kontaktkarte gleich hoch (${boxes.chart.height} / ${boxes.contacts.height} px)`), boxes.chart.top === boxes.contacts.top && Math.abs(boxes.chart.height - boxes.contacts.height) <= 1)
|
||||
check(L(`Diagramm füllt seine Karte (${boxes.svg.height} von ${boxes.chart.height} px)`), boxes.svg.height >= boxes.chart.height * 0.6)
|
||||
} else {
|
||||
check(L('Handy: Diagramm und Kontaktkarte untereinander'), boxes.contacts.top > boxes.chart.top && boxes.chart.left === boxes.contacts.left)
|
||||
}
|
||||
// Blase am Diagramm: nächster Tag, zeigt "…: N Aufrufe (davor M)"; Maus verlässt / Tippen daneben blendet aus
|
||||
const svg = boxes.svg
|
||||
const px = svg.left + (svg.right - svg.left) * 0.62
|
||||
const py = svg.top + svg.height / 2
|
||||
if (touch) {
|
||||
await page.touchscreen.tap(px, py)
|
||||
} else {
|
||||
await page.mouse.move(px, py)
|
||||
}
|
||||
await page.waitForSelector('.an-tip:not([hidden])')
|
||||
const tip = await text('.an-tip')
|
||||
check(L(`Diagramm-Blase: "${tip}"`), /^\S+, \d\d\.\d\d\.: [\d.]+ Aufrufe \(davor [\d.]+\)$/.test(tip) && (await count('.an-dot.on')) === 1)
|
||||
if (touch) {
|
||||
// neben das Diagramm tippen (nicht in die App-Leiste oben, die führt zurück)
|
||||
const h = await page.locator('.an-chartbox h3').boundingBox()
|
||||
await page.touchscreen.tap(h.x + 10, h.y + h.height / 2)
|
||||
} else {
|
||||
await page.mouse.move(2, 2)
|
||||
}
|
||||
await page.waitForFunction(() => document.querySelector('.an-tip')?.hidden === true)
|
||||
check(L('Diagramm-Blase: verschwindet wieder, kein Punkt bleibt markiert'), (await count('.an-dot.on')) === 0)
|
||||
// Achsenbeschriftung: gerendert ca. 11-12 px (viewBox 640 skaliert mit der Breite), nichts ragt aus der Karte, x-Beschriftungen überlappen nicht
|
||||
const axis = () => page.evaluate(() => {
|
||||
const svg = document.querySelector('.an-chart')
|
||||
const scale = svg.getBoundingClientRect().width / 640
|
||||
const box = document.querySelector('.an-chartbox').getBoundingClientRect()
|
||||
const texts = [...svg.querySelectorAll('.an-axis')].map((t) => ({ r: t.getBoundingClientRect(), px: parseFloat(getComputedStyle(t).fontSize) * scale, anchor: t.getAttribute('text-anchor'), s: t.textContent }))
|
||||
const xs = texts.filter((t) => t.anchor === 'middle').sort((a, b) => a.r.left - b.r.left)
|
||||
return {
|
||||
px: Math.min(...texts.map((t) => t.px)), pxMax: Math.max(...texts.map((t) => t.px)),
|
||||
inside: texts.every((t) => t.r.left >= box.left + 1 && t.r.right <= box.right - 1),
|
||||
gap: xs.every((t, i) => !i || t.r.left >= xs[i - 1].r.right + 4),
|
||||
y: texts.filter((t) => t.anchor === 'end').map((t) => t.s).join(','),
|
||||
}
|
||||
})
|
||||
const ax = await axis()
|
||||
check(L(`Achsenbeschriftung ca. 11-12 px (${ax.px.toFixed(1)} px), liegt in der Karte, x-Werte überlappen nicht`), ax.px >= 10.5 && ax.pxMax <= 13 && ax.inside && ax.gap)
|
||||
const faint = await page.evaluate(() => getComputedStyle(document.querySelector('.an-credit')).color)
|
||||
check(L(`Hilfstext "--an-faint" kontrastreich (${faint})`), Number(/rgba?\([^)]*?,\s*([\d.]+)\)$/.exec(faint)?.[1] ?? 1) >= 0.55)
|
||||
if (touch) {
|
||||
const heights = await page.evaluate(() => Object.fromEntries(['.an-tabbtn', '.an-seg button', '.an-ltab', '.an-more', '.an-teaser .an-btn'].map((sel) => [sel, Math.min(...[...document.querySelectorAll(sel)].map((e) => e.getBoundingClientRect().height))])))
|
||||
check(L(`Tippflächen mindestens 40 px: ${Object.entries(heights).map(([k, v]) => `${k} ${v.toFixed(0)}`).join(', ')}`), Object.values(heights).every((h) => h >= 39.5))
|
||||
}
|
||||
// Ranglisten: Umschalter und "Alle anzeigen" ändern nur ihre Karte
|
||||
check(L('Rangliste: 6 Zeilen und "Alle anzeigen"'), (await count('[data-rank="seen"] .an-lr')) === 6 && (await count('[data-rank="seen"] [data-rank-more]')) === 1)
|
||||
await page.click('[data-rank="seen"] [data-rank-more]')
|
||||
check(L('Rangliste: "Alle anzeigen" zeigt alle 9 Seiten'), (await count('[data-rank="seen"] .an-lr')) === 9 && (await count('[data-rank="seen"] [data-rank-more]')) === 0)
|
||||
await page.click('[data-rank="seen"] [data-rank-tab="refs"]')
|
||||
check(L('Rangliste: Umschalter Herkunft, Seiten-Reiter der anderen Karte unverändert'), (await page.getAttribute('[data-rank="seen"]', 'data-rank-active')) === 'refs' && (await page.getAttribute('[data-rank="who"]', 'data-rank-active')) === 'devices' && (await text('[data-rank="seen"]')).includes('Google'))
|
||||
await shot('aktiv')
|
||||
|
||||
// Reiter per Pfeiltaste (Reihenfolge Übersicht, Heatmap, Einstellungen)
|
||||
await page.focus('.an-tabbtn[data-tab="uebersicht"]')
|
||||
await page.keyboard.press('ArrowRight')
|
||||
await page.waitForSelector('.an-tabbtn[data-tab="heatmap"][aria-selected="true"]')
|
||||
await page.keyboard.press('ArrowLeft')
|
||||
await page.waitForSelector('.an-tabbtn[data-tab="uebersicht"][aria-selected="true"]')
|
||||
check(L('Reiter: Pfeiltasten wechseln die Reiter'), (await count('.an-ov:not(.an-skeleton) .an-kpis')) === 1)
|
||||
|
||||
// Zeitraum 7: neue Anfrage, nur die Übersicht lädt neu, Reiter bleibt
|
||||
const before = statsRequests.length
|
||||
await page.click('.an-seg [data-range="7"]')
|
||||
await page.waitForFunction(() => document.querySelector('.an-lead')?.textContent.includes('7 Tagen'))
|
||||
check(L('Zeitraum 7 → Anfrage range=7, Reiter bleibt Übersicht'), statsRequests.length > before && statsRequests.at(-1) === 7 && (await page.getAttribute('.an-seg .on', 'data-range')) === '7' && (await page.getAttribute('.an-tabbtn[aria-selected="true"]', 'data-tab')) === 'uebersicht')
|
||||
|
||||
// Heatmap: iframes erst nach dem Reiterwechsel (Teaser-Knopf und Reiterknopf wechseln beide)
|
||||
await open('full')
|
||||
const iframesBefore = await count('iframe')
|
||||
await page.click('.an-teaser [data-tab="heatmap"]')
|
||||
await page.waitForFunction(() => document.querySelectorAll('.hs-dev iframe').length === 2)
|
||||
check(L('Teaser "Öffnen" wechselt in den Reiter Heatmap'), (await page.getAttribute('.an-tabbtn[aria-selected="true"]', 'data-tab')) === 'heatmap' && (await count('.an-top .an-seg')) === 0)
|
||||
await open('full')
|
||||
await page.click('.an-tabbtn[data-tab="heatmap"]')
|
||||
await page.waitForFunction(() => document.querySelectorAll('.hs-dev iframe').length === 2)
|
||||
check(L('Reiter Heatmap: vorher 0 iframes, nach Klick 2 iframes'), iframesBefore === 0 && (await count('.hs-dev iframe')) === 2 && (await count('#an-heat-page')) === 1)
|
||||
check(L('Heatmap: Seitenauswahl und Computer/Tablet-Schalter in einer Leiste'), await page.evaluate(() => { const bar = document.querySelector('.an-heat-bar'); return Boolean(bar?.querySelector('#an-heat-page') && bar.querySelector('.hs-switch button')) }))
|
||||
check(L('kein_horizontaler_scroll heatmap'), await noScroll())
|
||||
await page.waitForTimeout(600)
|
||||
await shot('heatmap')
|
||||
// zurück in die Übersicht: die iframes verschwinden, die Zahlen stehen sofort wieder da
|
||||
await page.click('.an-tabbtn[data-tab="uebersicht"]')
|
||||
await page.waitForSelector('.an-ov:not(.an-skeleton) .an-kpis')
|
||||
check(L('Reiterwechsel zurück: Übersicht ohne iframes'), (await count('iframe')) === 0)
|
||||
|
||||
// Einstellungen
|
||||
await page.click('.an-tabbtn[data-tab="einstellungen"]')
|
||||
await page.waitForSelector('#an-off-ask')
|
||||
const settings = await text('#analyse-body')
|
||||
check(L('Reiter Einstellungen: "Analyse ausschalten" sichtbar, "aktiv seit"'), (await page.isVisible('#an-off-ask')) && settings.includes('Analyse ausschalten') && /aktiv seit 12\.08\.2026/.test(settings) && settings.includes('Fassung 2026-10-02') && (await count('.an-docs a')) === 2 && (await count('.an-swatch')) === 1 && (await count('.an-top .an-seg')) === 0)
|
||||
check(L('kein_horizontaler_scroll einstellungen'), await noScroll())
|
||||
const errColor = await page.evaluate(() => {
|
||||
const p = document.createElement('p')
|
||||
p.className = 'error'
|
||||
p.textContent = 'x'
|
||||
document.querySelector('#an-off').appendChild(p)
|
||||
const c = getComputedStyle(p).color
|
||||
p.remove()
|
||||
return c
|
||||
})
|
||||
check(L(`Fehlertext beim Ausschalten rot (${errColor})`), errColor === 'rgb(252, 165, 165)')
|
||||
await shot('einstellungen')
|
||||
await page.click('#an-off-ask')
|
||||
await page.click('#an-off-yes')
|
||||
await page.waitForSelector('#an-off-done')
|
||||
check(`${label} ausschalten_bestaetigung`, (await page.textContent('#an-off-done')).includes('Ab jetzt werden keine Daten mehr gespeichert'))
|
||||
check(L('ausschalten_bestaetigung'), (await text('#an-off-done')).includes('Ab jetzt werden keine Daten mehr gespeichert'))
|
||||
await shot('ausgeschaltet')
|
||||
check(`${label} keine_js_fehler`, errors.length === 0)
|
||||
|
||||
// verzögerte erste Antwort überschreibt die spätere nicht
|
||||
delayFirst30 = 1
|
||||
await open('full', '.an-seg')
|
||||
await page.click('.an-seg [data-range="7"]')
|
||||
await page.waitForFunction(() => document.querySelector('.an-lead')?.textContent.includes('7 Tagen'))
|
||||
await page.waitForTimeout(1900)
|
||||
const lateOk = (await text('.an-lead')).includes('7 Tagen') && !(await text('.an-lead')).includes('30 Tagen') && statsRequests.join() === '30,7' && (await page.getAttribute('.an-seg .on', 'data-range')) === '7'
|
||||
// auch der Zustand dahinter bleibt der 7-Tage-Stand: "Alle anzeigen" und der Umschalter malen mit 7-Tage-Zahlen (Startseite 620, Google 220)
|
||||
const firstRow = (card) => text(`[data-rank="${card}"] .an-lr`)
|
||||
const before7 = await firstRow('seen')
|
||||
await page.click('[data-rank="seen"] [data-rank-more]')
|
||||
const more = await firstRow('seen')
|
||||
await page.click('[data-rank="seen"] [data-rank-tab="refs"]')
|
||||
const refs = await firstRow('seen')
|
||||
check(L('verzögerte erste Antwort (range=30, 1,5 s) überschreibt die spätere (range=7) nicht'), lateOk && before7.includes('620') && more.includes('620') && !more.includes('2.480') && refs.includes('220') && !refs.includes('880') && (await count('[data-rank="seen"] .an-lr')) === 4)
|
||||
delayFirst30 = 0
|
||||
|
||||
// Heatmap-Reiter während der ersten Übersicht-Anfrage: nutzt sie mit, statt dieselbe Anfrage noch einmal zu stellen
|
||||
delayFirst30 = 1
|
||||
await open('full', '.an-seg')
|
||||
await page.click('.an-tabbtn[data-tab="heatmap"]')
|
||||
await page.waitForFunction(() => document.querySelectorAll('.hs-dev iframe').length === 2)
|
||||
check(L('Heatmap-Reiter nutzt die laufende 30-Tage-Anfrage mit'), statsRequests.join() === '30')
|
||||
delayFirst30 = 0
|
||||
|
||||
// Website wechseln: Reiter bleibt
|
||||
await open('zwei')
|
||||
await page.click('.an-tabbtn[data-tab="einstellungen"]')
|
||||
await page.waitForSelector('#an-off-ask')
|
||||
check(L('mehrere Websites: Auswahlfeld in der Kopfleiste, langer Name bricht nichts'), (await count('#an-project option')) === 2 && (await noScroll()))
|
||||
await page.selectOption('#an-project', 'p2')
|
||||
await page.waitForSelector('#an-off-ask')
|
||||
check(L('Websitewechsel: Reiter Einstellungen bleibt'), (await page.getAttribute('.an-tabbtn[aria-selected="true"]', 'data-tab')) === 'einstellungen' && (await page.inputValue('#an-project')) === 'p2')
|
||||
await shot('zwei-websites')
|
||||
|
||||
/* --- weitere Zustände --- */
|
||||
await open('neu')
|
||||
check(L('neu: "Vergleich ab" statt Chips, Satz "Seit dem Start der Analyse"'), (await count('.an-kpis .an-delta')) === 0 && (await text('.an-kpis')).includes('Vergleich ab') && (await text('.an-sum')).includes('Seit dem Start der Analyse') && (await count('.an-prev')) === 0)
|
||||
await shot('neu')
|
||||
|
||||
await open('wenig')
|
||||
check(L('wenig: Leerzustand'), (await count('.an-sum-empty')) === 1 && (await text('.an-sum')).includes('Sobald ein paar mehr Besuche da sind'))
|
||||
await shot('wenig')
|
||||
|
||||
await open('dev')
|
||||
check(L('dev: "Im Dev-Modus wird nicht gemessen."'), (await text('.an-status')).includes('Im Dev-Modus wird nicht gemessen.') && (await page.getAttribute('.an-site', 'data-state')) === 'warn')
|
||||
await shot('dev')
|
||||
|
||||
await open('alt')
|
||||
check(L('alt: kein "Heute bisher" (alter Collector), Stand bleibt'), /^Analyse aktiv · Stand: \d\d:\d\d Uhr$/.test(await text('.an-status')))
|
||||
check(L('alt: keine Chips, keine pageerror'), (await count('.an-delta')) === 0 && (await count('.an-prev')) === 0 && errors.length === 0 && (await text('.an-kpis')).includes('612'))
|
||||
await shot('alt')
|
||||
|
||||
await open('fehler', '.an-error')
|
||||
const requestsBefore = statsRequests.length
|
||||
check(L('fehler: "Auswertung gerade nicht erreichbar" + Neu laden'), (await text('.an-error')).includes('Auswertung gerade nicht erreichbar') && (await text('#an-retry')) === 'Neu laden' && (await count('.an-tabs')) === 1)
|
||||
await page.click('#an-retry')
|
||||
for (let i = 0; i < 50 && statsRequests.length === requestsBefore; i += 1) await sleep(100)
|
||||
await page.waitForSelector('.an-error')
|
||||
check(L('fehler: "Neu laden" fragt erneut an'), statsRequests.length === requestsBefore + 1)
|
||||
await shot('fehler')
|
||||
|
||||
for (const [sc, label5] of [['stark', 'vierstellige'], ['sehrStark', 'fünfstellige']]) {
|
||||
await open(sc)
|
||||
const big = await axis()
|
||||
check(L(`${label5} y-Werte (${big.y}) nicht abgeschnitten, x-Werte überlappen nicht, Schrift ${big.px.toFixed(1)} px`), big.inside && big.gap && big.px >= 10.5 && big.pxMax <= 13)
|
||||
await shot(sc === 'stark' ? 'skala-4-stellig' : 'skala-5-stellig')
|
||||
}
|
||||
|
||||
await open('langerPfad')
|
||||
const name = await page.evaluate(() => { const n = document.querySelector('[data-rank="seen"] .an-name'); return { sw: n.scrollWidth, cw: n.clientWidth, title: n.title } })
|
||||
check(L(`langer Pfad${touch ? ', 402 px' : ''}: document.scrollingElement.scrollWidth <= innerWidth`), (await noScroll()) && name.sw > name.cw && name.title.length > 100)
|
||||
await shot('langer-pfad')
|
||||
|
||||
check(L('keine pageerror in allen Zuständen'), errors.length === 0)
|
||||
if (errors.length) console.log(errors.join('\n'))
|
||||
await ctx.close()
|
||||
}
|
||||
} finally {
|
||||
|
||||
Reference in new issue
Block a user