DogFatherGitandClaude Opus 5
9134b30d06
Wunsch vom 02.09.2026: "ich will die Rollen, welcher Scout welchem
Manager oder DogFather gehoert, wie es bei den Creator ist, drunter."
Die Auswahl stand bisher nur dann unter einem Scout, wenn es ueberhaupt
einen Manager gab -- und es gibt zurzeit keinen. In der Personenliste war
davon also nichts zu sehen. Jetzt steht sie immer da, mit Managern UND
DogFather zur Wahl, genau wie "Betreut von" bei den Creatorn.
DIE BEIDEN FAELLE BEWIRKEN VERSCHIEDENES, und das ist Absicht:
MANAGER Der Eintrag entscheidet ueber SICHTBARKEIT -- er sieht
danach die Leads dieses Scouts und dessen Creator.
DOGFATHER Der Eintrag haelt nur die ZUSTAENDIGKEIT fest. An den
Rechten aendert er nichts; DogFather sieht ohnehin alles.
Genau diese Unterscheidung gilt bei den Creatorn seit dem 31.08. auch.
Vorher hatte ich einen Scout unter DogFather abgewiesen mit der
Begruendung, der Eintrag bewirke nichts. Das war zu eng gedacht: Er
beantwortet die Frage "wen frage ich?", und das ist der Zweck dieser
ganzen Liste.
Ein Scout unter einem Scout bleibt ausgeschlossen -- eine Ordnung, die
es nicht gibt.
ZWEI DINGE MITGEZOGEN, damit die Liste nicht zwei Sprachen spricht:
* Der Leerwert heisst wieder "— niemand —" wie bei den Creatorn.
"— direkt bei DogFather —" sah aus wie eine Zuordnung und war
keine -- derselbe Fehler war bei den Creatorn schon einmal behoben
worden, weil dieselben Leute dadurch gleichzeitig als "ohne
zustaendige Person" gezaehlt wurden.
* Die Rolle steht nur dann in Klammern, wenn sie etwas hinzufuegt.
"Dogfather (DogFather)" waere zweimal dasselbe Wort.
Die Pruefung haelt jetzt BEIDES fest: dass die Zuteilung an DogFather
geht -- und dass sie niemandem mehr Sicht gibt. Verschwimmt dieser
Unterschied je, faellt es dort auf.
Co-Authored-By: Claude Opus 5 <[email protected]>
372 lines
18 KiB
JavaScript
372 lines
18 KiB
JavaScript
/* Prueft die Zuteilung Manager -> Scouts.
|
||
|
||
Wunsch vom 01.09.2026: "er soll nur die Scouts sehen, die ihm
|
||
zugeteilt sind." Dazu entschieden: Ein Manager sieht dann AUCH die
|
||
Creator dieser Scouts ("ja, alles seiner Scouts"), und zuteilen darf
|
||
NUR DogFather.
|
||
|
||
WARUM DAS DIE HEIKELSTE AENDERUNG DES TAGES IST.
|
||
|
||
Diese Zuteilung ERWEITERT Sichtbarkeit. Alles andere heute hat sie
|
||
eingeschraenkt -- ein Fehler dort zeigt jemandem zu wenig, und das
|
||
faellt auf. Ein Fehler HIER zeigt jemandem zu viel, und das faellt
|
||
niemandem auf. Deshalb steht der Missbrauch am Anfang:
|
||
|
||
Darf ein Manager sich selbst Scouts zuteilen? -> muss 404 sein
|
||
Darf ein Scout das? -> muss 404 sein
|
||
Kann man einen Scout an einen Scout haengen? -> muss 400 sein
|
||
Kann man einen Creator zuteilen? -> muss 404 sein
|
||
|
||
Und danach die Kette in beide Richtungen: Was der Manager sehen SOLL,
|
||
sieht er -- und was er nicht sehen soll, sieht er nicht. */
|
||
|
||
import { mkdtempSync, rmSync } from "node:fs";
|
||
import { tmpdir } from "node:os";
|
||
import { join } from "node:path";
|
||
|
||
const ordner = mkdtempSync(join(tmpdir(), "ws-zut-"));
|
||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||
process.env.PORT = "4217";
|
||
process.env.SITE_ACCESS_SECRET = "lokaler-test";
|
||
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
|
||
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
|
||
|
||
const express = (await import("express")).default;
|
||
const ec = express.response.cookie;
|
||
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
|
||
await import("./index.js");
|
||
await new Promise((r) => setTimeout(r, 700));
|
||
const BASIS = "http://127.0.0.1:4217";
|
||
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
|
||
|
||
/* ORTSZEIT, nicht UTC. Die Anwendung rechnet "heute" nach der Uhr des
|
||
Benutzers; toISOString() liefert dagegen UTC und damit zwischen
|
||
Mitternacht und 2 Uhr den VORTAG. In diesem Fenster schlug diese
|
||
Pruefung fehl, ohne dass etwas kaputt war. */
|
||
const tagText = (d = new Date()) =>
|
||
`${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`
|
||
+ `-${String(d.getDate()).padStart(2, "0")}`;
|
||
|
||
let fehler = 0;
|
||
const ok = (b, t) => { console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||
|
||
await fetch(BASIS + "/workspace/api/anmelden", {
|
||
method: "POST", headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
|
||
|
||
const { DatabaseSync } = await import("node:sqlite");
|
||
const { scryptSync, randomBytes } = await import("node:crypto");
|
||
for (let i = 0; i < 60; i++) {
|
||
try {
|
||
const p = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
|
||
} catch { await new Promise((r) => setTimeout(r, 250)); }
|
||
}
|
||
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const jetzt = new Date().toISOString();
|
||
const heute = tagText();
|
||
function anlegen(name, rolle, code) {
|
||
const salt = randomBytes(16).toString("hex");
|
||
const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||
d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
|
||
.run(name, rolle, hash, salt, 32768, jetzt);
|
||
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
}
|
||
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
|
||
const idMara = anlegen("Mara", "manager", "CODE-MANA-0001");
|
||
const idNina = anlegen("Nina", "manager", "CODE-MANB-0001");
|
||
const idPat = anlegen("Patrick", "scout", "CODE-SCOU-0001");
|
||
const idBen = anlegen("Ben", "scout", "CODE-SCOB-0001");
|
||
const idTili = anlegen("Tili", "creator", "CODE-ANNA-0001");
|
||
const idLuna = anlegen("Luna", "creator", "CODE-LUNA-0001");
|
||
|
||
/* Patrick betreut Tili, Ben betreut Luna. Noch KEINE Scout-Zuteilung --
|
||
die wird gleich ueber die Schnittstelle gesetzt, damit auch der Weg
|
||
dorthin geprueft ist und nicht nur die Datenbank. */
|
||
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idPat, jetzt);
|
||
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idBen, jetzt);
|
||
|
||
const lead = (name, scout) =>
|
||
d.prepare(`INSERT INTO leads (name, plattform, handle, status, prioritaet, scout_id, erstellt)
|
||
VALUES (?,?,?,?,?,?,?)`)
|
||
.run(name, "tiktok", "@" + name.toLowerCase(), "neu", "mittel", scout, jetzt);
|
||
lead("PATRICK-LEAD", idPat);
|
||
lead("BEN-LEAD", idBen);
|
||
|
||
const aufgabe = (titel, creator, verant) =>
|
||
d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet,
|
||
creator_id, verantwortlich_id, erstellt, erstellt_von) VALUES (?,?,?,?,?,?,?,?)`)
|
||
.run(titel, "", "offen", "mittel", creator, verant, jetzt, idDogi);
|
||
aufgabe("TILI-AUFGABE", idTili, idPat);
|
||
aufgabe("LUNA-AUFGABE", idLuna, idBen);
|
||
d.close();
|
||
|
||
async function anmelden(rolle, code) {
|
||
const a = await fetch(BASIS + "/workspace/api/anmelden", {
|
||
method: "POST", headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ rolle, code }),
|
||
});
|
||
return (a.headers.getSetCookie?.() || []).map((x) => x.split(";")[0]).join("; ");
|
||
}
|
||
const setzen = (scoutId, managerId, keks) =>
|
||
fetch(`${BASIS}/workspace/api/verwaltung/scout-zuteilung/${scoutId}`, {
|
||
method: "PUT",
|
||
headers: { cookie: keks, "Content-Type": "application/json", origin: BASIS },
|
||
body: JSON.stringify({ manager_id: managerId }),
|
||
});
|
||
const holen = async (pfad, keks) => {
|
||
const a = await fetch(BASIS + pfad, { headers: { cookie: keks } });
|
||
return { status: a.status, daten: a.ok ? await a.json() : null };
|
||
};
|
||
|
||
const kDogi = await anmelden("admin", "CODE-DOGI-0001");
|
||
const kMara = await anmelden("manager", "CODE-MANA-0001");
|
||
const kNina = await anmelden("manager", "CODE-MANB-0001");
|
||
const kPat = await anmelden("scout", "CODE-SCOU-0001");
|
||
|
||
/* ================================================================
|
||
1. ZUERST DER MISSBRAUCH
|
||
================================================================ */
|
||
console.log("\n=== Nur DogFather darf zuteilen");
|
||
|
||
{
|
||
const a = await setzen(idPat, idMara, kMara);
|
||
ok(a.status === 404,
|
||
`ein Manager kann sich NICHT selbst einen Scout zuteilen (${a.status}, 404 erwartet)`);
|
||
/* 404 und nicht 403: Wer es nicht darf, soll nicht einmal erfahren,
|
||
dass es diesen Weg gibt. */
|
||
const b = await setzen(idPat, idMara, kPat);
|
||
ok(b.status === 404, `ein Scout auch nicht (${b.status})`);
|
||
|
||
/* Und wirklich nichts passiert? Eine abgewiesene Anfrage, die trotzdem
|
||
schreibt, waere der schlimmste Fall -- deshalb wird nachgesehen. */
|
||
const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const n = d2.prepare("SELECT COUNT(*) AS n FROM scout_zuteilung").get().n;
|
||
d2.close();
|
||
ok(n === 0, `und es wurde auch nichts geschrieben (${n} Zuteilungen)`);
|
||
}
|
||
|
||
console.log("\n=== Unsinnige Zuteilungen");
|
||
{
|
||
const a = await setzen(idPat, idBen, kDogi);
|
||
ok(a.status === 400, `Scout an Scout geht nicht (${a.status})`);
|
||
/* SEIT 02.09.2026 ERLAUBT: "ich will die Rollen, welcher Scout welchem
|
||
Manager ODER DOGFATHER gehoert, wie es bei den Creator ist."
|
||
|
||
Vorher wurde das abgewiesen mit der Begruendung, DogFather sehe
|
||
ohnehin alles -- der Eintrag bewirke also nichts. Das war zu eng
|
||
gedacht: Er haelt die ZUSTAENDIGKEIT fest, und das ist genau die
|
||
Frage "wen frage ich?". Bei den Creatorn steht DogFather aus
|
||
demselben Grund seit dem 31.08. in der Auswahl.
|
||
|
||
Geprueft wird deshalb beides: dass es geht -- und dass es an den
|
||
RECHTEN nichts aendert. */
|
||
const b = await setzen(idPat, idDogi, kDogi);
|
||
ok(b.status === 200, `Scout an DogFather geht jetzt (${b.status})`);
|
||
const c = await setzen(idTili, idMara, kDogi);
|
||
ok(c.status === 404, `einen Creator kann man nicht zuteilen (${c.status})`);
|
||
const e = await setzen(999999, idMara, kDogi);
|
||
ok(e.status === 404, `eine erfundene Nummer ebenfalls nicht (${e.status})`);
|
||
}
|
||
|
||
/* Eine Zuteilung an DogFather darf NIEMANDEM mehr zeigen. Das ist der
|
||
Unterschied zwischen "haelt die Zustaendigkeit fest" und "vergibt
|
||
Sichtbarkeit" -- und wenn er je verschwimmt, faellt es hier auf. */
|
||
console.log("\n=== Eine Zuteilung an DogFather vergibt keine Sicht");
|
||
{
|
||
const l = await holen("/workspace/api/leads", kMara);
|
||
const a = await holen("/workspace/api/aufgaben", kMara);
|
||
ok((l.daten?.leads || []).length === 0 && (a.daten?.aufgaben || []).length === 0,
|
||
`Mara sieht dadurch nichts (${(l.daten?.leads || []).length} Leads, `
|
||
+ `${(a.daten?.aufgaben || []).length} Aufgaben)`);
|
||
const lN = await holen("/workspace/api/leads", kNina);
|
||
ok((lN.daten?.leads || []).length === 0, "und Nina auch nicht");
|
||
/* Zuruecksetzen, damit die Kette darunter von vorn beginnt. */
|
||
await setzen(idPat, null, kDogi);
|
||
}
|
||
|
||
/* ================================================================
|
||
2. DIE KETTE: Manager -> Scout -> dessen Creator
|
||
================================================================ */
|
||
console.log("\n=== Vorher: Mara sieht nichts von Patrick");
|
||
{
|
||
const l = await holen("/workspace/api/leads", kMara);
|
||
ok((l.daten?.leads || []).length === 0,
|
||
`ohne Zuteilung keine fremden Leads (${(l.daten?.leads || []).length})`);
|
||
const a = await holen("/workspace/api/aufgaben", kMara);
|
||
ok((a.daten?.aufgaben || []).length === 0,
|
||
`und keine fremden Aufgaben (${(a.daten?.aufgaben || []).length})`);
|
||
}
|
||
|
||
console.log("\n=== DogFather teilt Patrick an Mara zu");
|
||
{
|
||
const a = await setzen(idPat, idMara, kDogi);
|
||
ok(a.status === 200, `die Zuteilung geht durch (${a.status})`);
|
||
|
||
const l = await holen("/workspace/api/leads", kMara);
|
||
const namen = (l.daten?.leads || []).map((x) => x.name).sort();
|
||
ok(namen.length === 1 && namen[0] === "PATRICK-LEAD",
|
||
`Mara sieht jetzt Patricks Lead (${namen.join(", ")})`);
|
||
ok(!namen.includes("BEN-LEAD"),
|
||
" und NICHT den des anderen Scouts");
|
||
|
||
/* DIE KETTE -- der eigentliche Punkt der Entscheidung: Sie sieht auch
|
||
den Creator, den Patrick betreut, obwohl er ihr nie direkt zugeteilt
|
||
wurde. */
|
||
const auf = await holen("/workspace/api/aufgaben", kMara);
|
||
const titel = (auf.daten?.aufgaben || []).map((x) => x.titel).sort();
|
||
ok(titel.length === 1 && titel[0] === "TILI-AUFGABE",
|
||
`und die Aufgaben von Patricks Creator (${titel.join(", ")})`);
|
||
ok(!titel.includes("LUNA-AUFGABE"),
|
||
" aber nicht die des Creators vom anderen Scout");
|
||
}
|
||
|
||
console.log("\n=== Die zweite Managerin sieht davon nichts");
|
||
{
|
||
const l = await holen("/workspace/api/leads", kNina);
|
||
const a = await holen("/workspace/api/aufgaben", kNina);
|
||
ok((l.daten?.leads || []).length === 0 && (a.daten?.aufgaben || []).length === 0,
|
||
`Nina sieht weiterhin nichts (${(l.daten?.leads || []).length} Leads, `
|
||
+ `${(a.daten?.aufgaben || []).length} Aufgaben) – eine Zuteilung gilt nur fuer den, `
|
||
+ "dem zugeteilt wurde");
|
||
}
|
||
|
||
console.log("\n=== Auch Suche und Hinweise ziehen mit");
|
||
{
|
||
/* Ein Hinweis oder Suchtreffer, der mehr verraet als die Seite
|
||
dahinter, waere ein Leck -- deshalb dieselbe Regel, aus derselben
|
||
Quelle. */
|
||
const s = await holen("/workspace/api/suche?q=LEAD", kMara);
|
||
const treffer = (s.daten?.gruppen || []).flatMap((g) => g.treffer.map((t) => t.titel || t.name));
|
||
ok(!treffer.some((t) => String(t).includes("BEN")),
|
||
`die Suche zeigt Mara keinen fremden Lead (${treffer.join(", ") || "nichts"})`);
|
||
|
||
const sN = await holen("/workspace/api/suche?q=LEAD", kNina);
|
||
const trefferN = (sN.daten?.gruppen || []).flatMap((g) => g.treffer.map((t) => t.titel || t.name));
|
||
ok(trefferN.length === 0,
|
||
`und Nina gar keinen (${trefferN.join(", ") || "nichts"})`);
|
||
}
|
||
|
||
/* ================================================================
|
||
3. ZURUECKNEHMEN -- und die Sicht geht wirklich wieder weg
|
||
================================================================ */
|
||
console.log("\n=== Zuruecknehmen");
|
||
{
|
||
const a = await setzen(idPat, null, kDogi);
|
||
ok(a.status === 200, `die Zuteilung laesst sich loesen (${a.status})`);
|
||
const l = await holen("/workspace/api/leads", kMara);
|
||
const auf = await holen("/workspace/api/aufgaben", kMara);
|
||
ok((l.daten?.leads || []).length === 0 && (auf.daten?.aufgaben || []).length === 0,
|
||
`und Mara sieht danach wieder nichts (${(l.daten?.leads || []).length} Leads, `
|
||
+ `${(auf.daten?.aufgaben || []).length} Aufgaben)`);
|
||
}
|
||
|
||
/* Ein Scout gehoert zu HOECHSTENS einem Manager -- eine zweite Zuteilung
|
||
ersetzt die erste, sie kommt nicht dazu. Sonst waere "wer ist
|
||
zustaendig?" eine Frage ohne Antwort. */
|
||
console.log("\n=== Ein Scout gehoert zu genau einem Manager");
|
||
{
|
||
await setzen(idPat, idMara, kDogi);
|
||
await setzen(idPat, idNina, kDogi);
|
||
const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const z = d2.prepare("SELECT COUNT(*) AS n FROM scout_zuteilung WHERE scout_id = ?").get(idPat);
|
||
const wer = d2.prepare("SELECT manager_id FROM scout_zuteilung WHERE scout_id = ?").get(idPat);
|
||
d2.close();
|
||
ok(z.n === 1, `nach zwei Zuteilungen genau ein Eintrag (${z.n})`);
|
||
ok(wer.manager_id === idNina, " und zwar der zuletzt gesetzte");
|
||
|
||
const lMara = await holen("/workspace/api/leads", kMara);
|
||
ok((lMara.daten?.leads || []).length === 0,
|
||
`die erste Managerin sieht Patricks Lead nicht mehr (${(lMara.daten?.leads || []).length})`);
|
||
}
|
||
|
||
/* ================================================================
|
||
4. IM BROWSER: die Auswahl steht da -- und nur bei DogFather
|
||
================================================================ */
|
||
console.log("\n=== Die Auswahl in der Personenliste");
|
||
const { chromium } = await import(
|
||
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
||
const browser = await chromium.launch();
|
||
|
||
async function seiteAls(rolle, code) {
|
||
const kontext = await browser.newContext({ viewport: { width: 1280, height: 1100 } });
|
||
const konsole = [];
|
||
const seite = await kontext.newPage();
|
||
seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
|
||
seite.on("pageerror", (e) => konsole.push("pageerror: " + e.message));
|
||
await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
|
||
await seite.click(`.rolle[data-rolle="${rolle}"]`);
|
||
await seite.fill("#code", code);
|
||
await seite.click("button[type=submit]");
|
||
await seite.waitForURL("**/start.html", { timeout: 15000 });
|
||
await seite.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
|
||
await seite.waitForTimeout(1200);
|
||
/* DIE LISTE IST NACH ROLLEN ZUGEKLAPPT -- offen ist nur die eigene
|
||
Gruppe. Der erste Anlauf dieser Pruefung mass deshalb genau eine
|
||
Zeile ("Filipe (du)") und meldete, die Auswahl fehle. Sie fehlte
|
||
nicht, sie war nur zugeklappt.
|
||
|
||
Ein lehrreicher Fehlschlag: Er sah aus wie ein Produktfehler und war
|
||
einer der Pruefung. Wer ihn ungeprueft geglaubt haette, haette am
|
||
falschen Ende repariert. */
|
||
await seite.click("#rest-schalter").catch(() => {});
|
||
await seite.waitForTimeout(600);
|
||
return { kontext, seite, konsole };
|
||
}
|
||
|
||
const bDogi = await seiteAls("admin", "CODE-DOGI-0001");
|
||
const r = await bDogi.seite.evaluate(() => ({
|
||
personen: document.querySelectorAll(".person").length,
|
||
/* Die Auswahl "Gehört zu" -- eine je Scout. */
|
||
wahlen: [...document.querySelectorAll('select[id^="manager-"]')].map((s) => ({
|
||
id: s.id,
|
||
wert: s.value,
|
||
erste: s.querySelector("option")?.textContent,
|
||
anzahl: s.querySelectorAll("option").length,
|
||
})),
|
||
/* Die Zeilen sollen es auch in Worten sagen. */
|
||
texte: [...document.querySelectorAll(".person__zeile")].map((z) => z.textContent),
|
||
ueber: document.documentElement.scrollWidth - document.documentElement.clientWidth,
|
||
}));
|
||
ok(r.personen === 7,
|
||
`aufgeklappt stehen alle sieben Personen da (${r.personen}) – `
|
||
+ "sonst misst die Pruefung eine zugeklappte Liste");
|
||
ok(r.wahlen.length === 2, `zwei Scouts, zwei Auswahlfelder (${r.wahlen.length})`);
|
||
ok(/niemand/.test(r.wahlen[0]?.erste || ""),
|
||
`der Leer-Wert heisst wie bei den Creatorn ("${r.wahlen[0]?.erste}")`);
|
||
/* DogFather MUSS in der Auswahl stehen -- das war der Wunsch. Und zwar
|
||
ohne die doppelte Klammer "Dogfather (DogFather)". */
|
||
ok(r.wahlen[0]?.anzahl >= 4,
|
||
`Manager UND DogFather stehen zur Wahl (${r.wahlen[0]?.anzahl} Eintraege)`);
|
||
ok(r.wahlen.some((w) => w.wert === String(idNina)),
|
||
"die bestehende Zuteilung ist vorausgewaehlt");
|
||
ok(r.texte.some((t) => /gehört zu Nina/.test(t)),
|
||
"und steht auch in Worten in der Zeile");
|
||
ok(r.texte.some((t) => /1 Scout zugeteilt/.test(t)),
|
||
"beim Manager steht die Zahl seiner Scouts");
|
||
ok(r.ueber <= 0, `nichts steht ueber (${r.ueber}px)`);
|
||
ok(bDogi.konsole.length === 0,
|
||
`keine Fehler in der Konsole${bDogi.konsole.length ? " -> " + bDogi.konsole.join(" | ") : ""}`);
|
||
await bDogi.seite.screenshot({ path: "pruef-scout-zuteilung.png", fullPage: false });
|
||
await bDogi.kontext.close();
|
||
|
||
/* GEGENPROBE: Ein Manager darf die Personenliste sehen -- aber diese
|
||
Auswahl nicht. */
|
||
const bMara = await seiteAls("manager", "CODE-MANA-0001");
|
||
const rM = await bMara.seite.evaluate(() => ({
|
||
wahlen: document.querySelectorAll('select[id^="manager-"]').length,
|
||
personen: document.querySelectorAll(".person").length,
|
||
}));
|
||
ok(rM.personen >= 7,
|
||
`ein Manager sieht die ganze Personenliste (${rM.personen} Zeilen) – `
|
||
+ "die Personenverwaltung ist ihm nicht genommen worden");
|
||
ok(rM.wahlen === 0,
|
||
`Gegenprobe: aber KEINE Zuteilungs-Auswahl (${rM.wahlen}) – er koennte sich sonst `
|
||
+ "seine eigene Sichtbarkeit vergeben");
|
||
await bMara.kontext.close();
|
||
|
||
await browser.close();
|
||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||
console.log(fehler ? `\n${fehler} Prüfung(en) fehlgeschlagen.` : "\nAlles in Ordnung.");
|
||
process.exit(fehler ? 1 : 0);
|