DogFatherGitandClaude Opus 5
e54c6829f1
Gemessen vor dem Bau: talentNaechste kettet aufgefallen -> beobachtet -> angesprochen -> probe -> imteam, und danach kommt nichts. Eine Suche nach "beenden|abgesagt|verworfen|archiv" in workspace-entwicklung.js fand nichts. Der Trichter hatte genau einen Ausgang -- obwohl der Text der Probe-Stufe woertlich verspricht: "Nach 30 Tagen: uebernehmen -- der Zugang entsteht dabei -- oder sauber beenden." Wer nicht passte, blieb also auf seiner Stufe stehen, mit wachsender Standzeit und rotem "liegt"-Zeichen. Nach einem Jahr hat die Liste mehr Karteileichen als Kandidaten, und dann schaut niemand mehr hin. DREI SPALTEN, KEINE NEUE STUFE. Eine neue Stufe haette einen CHECK-Umbau auf laufenden Daten verlangt -- und eine Auskunft zerstoert: Die Stufe haelt fest, WO es geendet hat. "Beendet in der Probe" und "beendet nach dem ersten Hinsehen" sind zwei verschiedene Saetze, und genau der Unterschied ist die Frage, wenn dieselbe Person in einem halben Jahr wieder auffaellt. DER SATZ IST PFLICHT (10 Zeichen, wie beim Ablehnen einer Anfrage) -- aus zwei Richtungen: Nach vorn, weil beim zweiten Anlauf niemand mehr weiss, was damals war. Nach innen, weil wer schreiben muss, anders entscheidet als wer klickt. "Passt nicht" hat neun Zeichen. WIEDER AUFNEHMEN setzt auf "aufgefallen" zurueck -- Menschen aendern sich, ein Urteil von damals gilt nicht weiter -- und rettet den alten Satz in die Notiz, statt ihn zu loeschen. AM BILDSCHIRMFOTO GEFUNDEN, nicht an einer Zahl: Auf einer Karte auf "Im Team" stand "Nichts mehr zu tun -- der Zugang steht" und direkt darunter "Passt doch nicht?". Ein Beenden dort haette die Karte stillgelegt und den ZUGANG offengelassen -- eine halbe Handlung, die sich wie eine ganze anfuehlt. Jetzt steht dort der Weg zu "Personen & Zugaenge", und der Server weist es mit 409 ab. pruef-nachwuchs 152 -> 200, davon 21 im echten Browser (der erste Browserblick auf diese Seite ueberhaupt -- mit einer Messung, ob Name und Datum bei 390 px uebereinanderliegen, statt einer Zahl im CSS). Sechs Gegenproben, jede genau auf ihr Ziel: Grenze auf 0 -> 3 rot Beendete bleiben drin -> 2 rot beendete: [] -> 5 rot alter Grund verworfen -> 1 rot Serverriegel imteam -> 5 rot Browserzweig imteam -> 3 rot Dazu gruen: css-klassen, struktur, entwicklung, uebergang. Nebenbefund behoben: absage() im Browser warf einen erklaerenden Satz des Servers lautlos weg und zeigte "Ging nicht." -- die Auskunft war da. Co-Authored-By: Claude Opus 5 <[email protected]>
1245 lines
63 KiB
JavaScript
1245 lines
63 KiB
JavaScript
/* =====================================================================
|
||
Entwicklung & Nachwuchs — die Riegel (11.09.2026)
|
||
|
||
Der Bereich hat vier Regeln, und jede einzelne wäre ohne Prüfung
|
||
eine Zusage statt einer Eigenschaft:
|
||
|
||
1. Block 5 gehört der Person. DogFather sieht ihn nicht — lesend
|
||
UND schreibend. Mit Gegenprobe: die Person selbst sieht ihn.
|
||
2. Der Stand des anderen kommt erst nach dem eigenen Klick. Mit
|
||
Gegenprobe: danach kommt er auch wirklich.
|
||
3. „Da hakt es" ohne Anlass wird abgelehnt. Mit Gegenprobe: mit
|
||
Anlass geht es durch.
|
||
4. Talente gehört DogFather und der rechten Hand. Ein Modi bekommt
|
||
404 — und zwar auf Seite UND Schnittstelle.
|
||
|
||
Dazu der Katalog selbst (Schlüssel, Stufen, keine Dopplungen) und
|
||
das Verblassen nach 90 Tagen — von beiden Seiten der Grenze, sonst
|
||
beweist es nichts.
|
||
|
||
Aufrufen mit: node server/pruef-nachwuchs.mjs
|
||
===================================================================== */
|
||
|
||
import { mkdtempSync, rmSync, readFileSync } from "node:fs";
|
||
import { tmpdir } from "node:os";
|
||
import { join } from "node:path";
|
||
import { request as httpAnfrage } from "node:http";
|
||
import { portMussFreiSein } from "./helfer-port.mjs";
|
||
import { tagLokal } from "./helfer-tag.mjs";
|
||
|
||
const PORT = await portMussFreiSein(4404, "pruef-nachwuchs");
|
||
|
||
const ordner = mkdtempSync(join(tmpdir(), "ws-nachwuchs-"));
|
||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||
process.env.PORT = String(PORT);
|
||
process.env.SITE_ACCESS_SECRET = "lokaler-test";
|
||
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 }); };
|
||
import { notbremse } from "./helfer-notbremse.mjs";
|
||
await import("./index.js");
|
||
notbremse(240_000, "pruef-nachwuchs");
|
||
await new Promise((r) => setTimeout(r, 700));
|
||
|
||
process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
|
||
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });
|
||
|
||
let fehler = 0, geprueft = 0;
|
||
const melde = (t) => console.log(t);
|
||
const ok = (b, t) => { geprueft++; console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||
/* DER DRITTE AUSGANG: nicht in Ordnung ist etwas anderes als "konnte
|
||
nicht nachsehen". Ohne ihn wuerde ein fehlendes Playwright entweder
|
||
als Fehler gemeldet (falscher Alarm) oder stillschweigend
|
||
uebersprungen (schlimmer -- die Zahl saenke, und niemand wuesste
|
||
warum). */
|
||
let offen = 0;
|
||
const unklar = (t) => { offen++; console.log(" -- " + t); };
|
||
|
||
const CREW = "crew.dogfather-universe.com";
|
||
const HAUS = "workspace.dogfather-universe.com";
|
||
|
||
const { DatabaseSync } = await import("node:sqlite");
|
||
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
|
||
const kat = await import("./workspace-entwicklungs-punkte.js");
|
||
const tal = await import("./workspace-talent-punkte.js");
|
||
const rechte = await import("./rechte.js");
|
||
|
||
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const jetzt = new Date().toISOString();
|
||
const schluessel = randomBytes(32).toString("hex");
|
||
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
|
||
+ " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
|
||
.run("code_kennung_schluessel", schluessel, jetzt);
|
||
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, code_kennung, aktiv, erstellt)"
|
||
+ " VALUES (?,?,?,?,?,?,1,?)")
|
||
.run(name, rolle, hash, salt, 32768, createHmac("sha256", schluessel).update(code).digest("hex"), jetzt);
|
||
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
}
|
||
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
|
||
const idHand = anlegen("Rieke", "hand", "CODE-HAND-0001");
|
||
const idModi = anlegen("Frida", "modi", "CODE-MODI-0001");
|
||
anlegen("Nina", "modi", "CODE-MODI-0002");
|
||
anlegen("Mara", "manager", "CODE-MANA-0001");
|
||
|
||
/* Ein Kandidat im Talente-Brett -- ohne ihn waere jede Zeile ueber den
|
||
Trichter ein gruener Haken ueber der Null. */
|
||
d.prepare("INSERT INTO eintraege (bereich, art, titel, text, datum, erstellt, erstellt_von, einsatz)"
|
||
+ " VALUES ('talente','ruhig','Kessi aus dem Chat','Faellt seit Wochen auf.',?,?,?,?)")
|
||
.run(jetzt.slice(0, 10), jetzt, idDogi, "Im Stream am Dienstag");
|
||
const idTalent = d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
||
d.close();
|
||
|
||
function roh(pfad, host, kopf = {}, koerper = null, methode = null) {
|
||
if (methode === "DELETE") koerper = null;
|
||
return new Promise((fertig, schief) => {
|
||
const a = httpAnfrage({
|
||
host: "127.0.0.1", port: PORT, path: pfad,
|
||
method: methode || (koerper ? "POST" : "GET"),
|
||
headers: { Host: host, ...(koerper ? { "Content-Type": "application/json" } : {}), ...kopf },
|
||
}, (antwort) => {
|
||
let text = "";
|
||
antwort.on("data", (s) => { text += s; });
|
||
antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
|
||
});
|
||
a.on("error", schief);
|
||
if (koerper) a.write(JSON.stringify(koerper));
|
||
a.end();
|
||
});
|
||
}
|
||
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
|
||
async function anmelden(rolle, code, host) {
|
||
const r = await roh("/workspace/api/anmelden", host, {}, { rolle, code });
|
||
return [].concat(r.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
|
||
}
|
||
const kDogi = await anmelden("admin", "CODE-DOGI-0001", HAUS);
|
||
const kHand = await anmelden("hand", "CODE-HAND-0001", CREW);
|
||
const kModi = await anmelden("modi", "CODE-MODI-0001", CREW);
|
||
ok(!!kDogi && !!kHand && !!kModi, "DogFather, rechte Hand und ein Modi sind angemeldet");
|
||
|
||
/* =======================================================================
|
||
1. DER KATALOG SELBST
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 1. Die zwei Kataloge ===");
|
||
{
|
||
const alle = kat.ENTWICKLUNG_ALLE;
|
||
ok(alle.length > 20, `${alle.length} Beobachtungen im Katalog`);
|
||
ok(new Set(alle.map((p) => p.schluessel)).size === alle.length,
|
||
"kein Schlüssel doppelt");
|
||
ok(alle.every((p) => p.schluessel.startsWith("e-")),
|
||
"jeder Schlüssel beginnt mit e- (keine Kollision mit der Checkliste)");
|
||
ok(alle.every((p) => p.titel && p.text && p.stufe),
|
||
"jede Beobachtung hat Titel, Erklärung und Erwartungsstufe");
|
||
const stufen = new Set(alle.map((p) => p.stufe));
|
||
ok(kat.ENTWICKLUNG_ERWARTUNG.every((e) => stufen.has(e.schluessel)),
|
||
`alle drei Erwartungsstufen kommen vor (${[...stufen].join(", ")})`);
|
||
|
||
/* DER RIEGEL IST EINE EIGENSCHAFT DES KATALOGS, nicht nur des
|
||
Servers: Genau ein Block ist `nurSelbst`, und die abgeleiteten
|
||
Listen passen dazu. Verrutscht das hier, greift der Server
|
||
weiterhin -- aber die Oberflaeche zeigte etwas anderes an. */
|
||
const selbstBloecke = kat.ENTWICKLUNG_BLOECKE.filter((b) => b.nurSelbst);
|
||
ok(selbstBloecke.length === 1, `genau ein Block gehört der Person selbst (${selbstBloecke.length})`);
|
||
ok(kat.ENTWICKLUNG_FREMD.length + kat.ENTWICKLUNG_SELBST.length === alle.length,
|
||
`${kat.ENTWICKLUNG_FREMD.length} fremd + ${kat.ENTWICKLUNG_SELBST.length} selbst = ${alle.length}`);
|
||
ok(kat.ENTWICKLUNG_SELBST.length > 0 && kat.ENTWICKLUNG_FREMD.length > 0,
|
||
"beide Listen haben Inhalt — sonst prüft die Zeile darüber nichts");
|
||
|
||
const merk = tal.TALENT_ALLE;
|
||
ok(merk.length > 15, `${merk.length} Merkmale im Talente-Katalog`);
|
||
ok(tal.TALENT_WARNZEICHEN.length > 0, `${tal.TALENT_WARNZEICHEN.length} Warnzeichen, getrennt geführt`);
|
||
ok(tal.TALENT_NACH_SCHLUESSEL.size === merk.length + tal.TALENT_WARNZEICHEN.length,
|
||
"kein Schlüssel doppelt zwischen Merkmalen und Warnzeichen");
|
||
ok([...merk, ...tal.TALENT_WARNZEICHEN].every((m) => m.schluessel.startsWith("t-")),
|
||
"jeder Schlüssel beginnt mit t-");
|
||
|
||
const raenge = tal.TALENT_STUFEN.map((s) => s.rang);
|
||
ok(JSON.stringify(raenge) === JSON.stringify([...raenge].sort((a, b) => a - b)),
|
||
`die fünf Stufen stehen in der richtigen Reihenfolge (${tal.TALENT_STUFEN.map((s) => s.name).join(" → ")})`);
|
||
ok(tal.TALENT_STUFEN.slice(0, -1).every((s) => s.knopf && s.schritt),
|
||
"jede Stufe außer der letzten hat GENAU EINEN nächsten Schritt mit Knopf");
|
||
ok(tal.talentNaechste("imteam") === null, "und hinter der letzten kommt nichts mehr");
|
||
ok(tal.talentStufe("gibt-es-nicht") === null,
|
||
"eine erfundene Stufe ergibt null statt der ersten — sie soll auffallen");
|
||
}
|
||
|
||
/* =======================================================================
|
||
2. BLOCK 5 GEHÖRT DER PERSON
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 2. Block 5 ===");
|
||
{
|
||
const selbst = kat.ENTWICKLUNG_SELBST[0].schluessel;
|
||
|
||
const karte = await roh(`/workspace/api/entwicklung/person/${idModi}`, HAUS, { cookie: kDogi });
|
||
const bloecke = json(karte).bloecke || [];
|
||
const alleSchluessel = bloecke.flatMap((b) => (b.punkte || []).map((p) => p.schluessel));
|
||
ok(karte.code === 200 && alleSchluessel.length > 0,
|
||
`DogFather bekommt die Karte des Modis (${alleSchluessel.length} Punkte)`);
|
||
const durch = kat.ENTWICKLUNG_SELBST.filter((p) => alleSchluessel.includes(p.schluessel));
|
||
ok(durch.length === 0,
|
||
`und KEINEN Punkt aus Block 5${durch.length ? " -- DURCH: " + durch.map((p) => p.schluessel).join(", ") : ""}`);
|
||
ok(!/Wie geht es dir/.test(karte.text), "auch der Blockname steht nicht in der Antwort");
|
||
|
||
/* Und schreiben geht auch nicht -- mit derselben Antwort wie ein
|
||
erfundener Schluessel, damit man an der Antwort nichts ablesen kann. */
|
||
const schreib = await roh(`/workspace/api/entwicklung/person/${idModi}/${selbst}`, HAUS,
|
||
{ cookie: kDogi }, { stufe: "laeuft" }, "PUT");
|
||
const erfunden = await roh(`/workspace/api/entwicklung/person/${idModi}/e-gibt-es-nicht`, HAUS,
|
||
{ cookie: kDogi }, { stufe: "laeuft" }, "PUT");
|
||
ok(schreib.code === 404, `DogFather kann dort auch nichts setzen (${schreib.code})`);
|
||
ok(schreib.code === erfunden.code,
|
||
`dieselbe Antwort wie bei einem erfundenen Punkt (${schreib.code}/${erfunden.code})`);
|
||
|
||
/* GEGENPROBE: Die Person selbst sieht ihn sehr wohl. Ohne diese
|
||
Zeile waeren die drei darueber auch dann gruen, wenn Block 5 fuer
|
||
NIEMANDEN existierte. */
|
||
const meins = await roh("/workspace/api/entwicklung/mich", CREW, { cookie: kModi });
|
||
const meine = (json(meins).punkte || []).map((p) => p.schluessel);
|
||
ok(meins.code === 200 && meine.length === kat.ENTWICKLUNG_SELBST.length,
|
||
`der Modi selbst sieht alle ${meine.length} Fragen`);
|
||
|
||
const setzen = await roh(`/workspace/api/entwicklung/mich/${selbst}`, CREW,
|
||
{ cookie: kModi }, { stufe: "hakt" }, "PUT");
|
||
ok(setzen.code === 200, `und kann sie beantworten (${setzen.code})`);
|
||
|
||
/* Und danach steht sie immer noch nicht in DogFathers Karte. */
|
||
const nachher = await roh(`/workspace/api/entwicklung/person/${idModi}`, HAUS, { cookie: kDogi });
|
||
ok(!nachher.text.includes(selbst),
|
||
"auch nach der Antwort steht sie nicht in DogFathers Karte");
|
||
|
||
/* Und in die andere Richtung: ueber jemand ANDEREN kann man dort
|
||
nichts eintragen -- es gibt gar keine Nummer in der Adresse. */
|
||
const fremdPunkt = await roh(`/workspace/api/entwicklung/mich/${kat.ENTWICKLUNG_FREMD[0].schluessel}`,
|
||
CREW, { cookie: kModi }, { stufe: "laeuft" }, "PUT");
|
||
ok(fremdPunkt.code === 404,
|
||
`über „mich" lässt sich kein fremder Punkt setzen (${fremdPunkt.code})`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
3. DIE AMPEL VERRÄT KEINEN NAMEN
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 3. Die Ampel ===");
|
||
{
|
||
/* BEIDE SEITEN DER GRENZE, sonst beweist es nichts.
|
||
|
||
Die Ampel schweigt, solange das Team so klein ist, dass „jemandem
|
||
geht es gerade zu viel" dasselbe waere wie ein Name. Eine Pruefung,
|
||
die nur eine Seite ansieht, waere auch dann gruen, wenn die Ampel
|
||
IMMER schwiege -- oder immer redete. Beides waere ein Fehler, und
|
||
keiner davon faellt von allein auf.
|
||
|
||
Die Schwelle wird nicht abgeschrieben, sondern aus dem Verhalten
|
||
abgeleitet: Erst mit vollem Team messen, dann eine Person
|
||
abschalten und noch einmal. Was dazwischen kippt, IST die Grenze. */
|
||
const voll = json(await roh("/workspace/api/entwicklung/ampel", HAUS, { cookie: kDogi }));
|
||
ok(voll.team >= 3 && voll.sagbar === true,
|
||
`bei ${voll.team} Personen sagt die Ampel etwas (${voll.lage})`);
|
||
ok(typeof voll.geantwortet === "number" && voll.geantwortet >= 1,
|
||
`und zaehlt, wie viele geantwortet haben (${voll.geantwortet} von ${voll.team})`);
|
||
/* Ein Modi hat in Abschnitt 2 „hakt" gesetzt -- die Ampel muss das
|
||
sehen, ohne zu sagen, wer es war. */
|
||
ok(voll.lage === "jemand",
|
||
`sie meldet die Lage aus Abschnitt 2 (${voll.lage})`);
|
||
ok(!/Frida|Nina|Rieke|Filipe/.test(JSON.stringify(voll)),
|
||
"und in der ganzen Antwort steht kein einziger Name");
|
||
|
||
/* Jetzt eine Person abschalten -- das Team faellt unter die Schwelle. */
|
||
const dd = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
dd.prepare("UPDATE personen SET aktiv = 0 WHERE name = 'Nina'").run();
|
||
dd.close();
|
||
|
||
const klein = json(await roh("/workspace/api/entwicklung/ampel", HAUS, { cookie: kDogi }));
|
||
ok(klein.team === voll.team - 1 && klein.sagbar === false,
|
||
`bei ${klein.team} Personen schweigt sie`);
|
||
ok(/Name/.test(klein.grund || ""),
|
||
"und sagt, warum – ein stilles Nichts sieht aus wie ein Fehler");
|
||
ok(!/Frida|Nina|Rieke|Filipe/.test(JSON.stringify(klein)),
|
||
"auch im schweigenden Fall steht kein Name da");
|
||
|
||
const dd2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
dd2.prepare("UPDATE personen SET aktiv = 1 WHERE name = 'Nina'").run();
|
||
dd2.close();
|
||
|
||
const modi = await roh("/workspace/api/entwicklung/ampel", CREW, { cookie: kModi });
|
||
ok(modi.code === 404, `ein Modi bekommt sie gar nicht (${modi.code})`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
4. DER STAND DES ANDEREN KOMMT ERST NACH DEM EIGENEN
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 4. Zwei Augenpaare ===");
|
||
{
|
||
const punkt = kat.ENTWICKLUNG_FREMD[0].schluessel;
|
||
|
||
const gesetzt = await roh(`/workspace/api/entwicklung/person/${idModi}/${punkt}`, CREW,
|
||
{ cookie: kHand }, { stufe: "laeuft", anlass: "Gestern im Chat gesehen." }, "PUT");
|
||
ok(gesetzt.code === 200, `die rechte Hand setzt einen Punkt (${gesetzt.code})`);
|
||
|
||
const vorher = await roh(`/workspace/api/entwicklung/person/${idModi}`, HAUS, { cookie: kDogi });
|
||
const p1 = (json(vorher).bloecke || []).flatMap((b) => b.punkte || [])
|
||
.find((p) => p.schluessel === punkt);
|
||
ok(p1 && p1.andere === null,
|
||
"DogFather sieht ihren Stand NICHT, bevor er selbst gesetzt hat");
|
||
ok(p1 && p1.andere_offen === 1,
|
||
`aber er sieht, DASS es einen gibt (${p1?.andere_offen}) – sonst wäre „noch niemand" dasselbe Bild`);
|
||
ok(!vorher.text.includes("Gestern im Chat gesehen"),
|
||
"und ihr Anlasstext wird gar nicht erst ausgeliefert");
|
||
|
||
const eigen = await roh(`/workspace/api/entwicklung/person/${idModi}/${punkt}`, HAUS,
|
||
{ cookie: kDogi }, { stufe: "waechst" }, "PUT");
|
||
ok(eigen.code === 200, `DogFather setzt selbst (${eigen.code})`);
|
||
|
||
/* GEGENPROBE: jetzt kommt er. */
|
||
const nachher = await roh(`/workspace/api/entwicklung/person/${idModi}`, HAUS, { cookie: kDogi });
|
||
const p2 = (json(nachher).bloecke || []).flatMap((b) => b.punkte || [])
|
||
.find((p) => p.schluessel === punkt);
|
||
ok(p2 && p2.andere?.length === 1 && p2.andere[0].stufe === "laeuft",
|
||
`danach sieht er ihn (${p2?.andere?.[0]?.stufe})`);
|
||
|
||
/* UND DIE ABWEICHUNG IST DAS ERGEBNIS. */
|
||
const ab = json(nachher).abweichungen || [];
|
||
ok(ab.length === 1 && ab[0].schluessel === punkt,
|
||
`die Abweichung steht oben in der Karte (${ab.length})`);
|
||
ok(ab[0].meins === "waechst" && ab[0].andere === "laeuft",
|
||
`mit beiden Ständen nebeneinander (${ab[0]?.meins} / ${ab[0]?.andere})`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
5. „DA HAKT ES" BRAUCHT EINEN ANLASS
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 5. Kein Klick ohne Anlass ===");
|
||
{
|
||
const punkt = kat.ENTWICKLUNG_FREMD[1].schluessel;
|
||
const ohne = await roh(`/workspace/api/entwicklung/person/${idModi}/${punkt}`, HAUS,
|
||
{ cookie: kDogi }, { stufe: "hakt", anlass: "" }, "PUT");
|
||
ok(ohne.code === 400, `„Da hakt es" ohne Anlass wird abgelehnt (${ohne.code})`);
|
||
ok(/gemerkt|Satz/.test(json(ohne).fehler || ""),
|
||
"und die Absage sagt, was fehlt, statt nur nein");
|
||
|
||
const mit = await roh(`/workspace/api/entwicklung/person/${idModi}/${punkt}`, HAUS,
|
||
{ cookie: kDogi }, { stufe: "hakt", anlass: "Am Samstag zweimal nicht reagiert." }, "PUT");
|
||
ok(mit.code === 200, `mit Anlass geht es durch (${mit.code})`);
|
||
|
||
/* GEGENPROBE: „Läuft" braucht keinen — sonst wären es 28 Pflichtfelder
|
||
je Person, und „so einfach wie möglich" war die halbe Aufgabe. */
|
||
const laeuft = await roh(`/workspace/api/entwicklung/person/${idModi}/${kat.ENTWICKLUNG_FREMD[2].schluessel}`,
|
||
HAUS, { cookie: kDogi }, { stufe: "laeuft" }, "PUT");
|
||
ok(laeuft.code === 200, `„Läuft" geht ohne Anlass (${laeuft.code})`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
6. NACH 90 TAGEN VERBLASST EINE EINSCHÄTZUNG
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 6. Verblassen ===");
|
||
{
|
||
const modul = await import("./workspace-entwicklung.js");
|
||
const alt = kat.ENTWICKLUNG_FREMD[3].schluessel;
|
||
const dd = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
dd.prepare(`INSERT INTO entwicklung_stand (person_id, schluessel, von_id, stufe, anlass, am)
|
||
VALUES (?,?,?,'laeuft',NULL,?)`)
|
||
.run(idModi, alt, idDogi,
|
||
new Date(Date.now() - (modul.VERBLASST_NACH_TAGEN + 10) * 86400000).toISOString());
|
||
dd.close();
|
||
|
||
const r = await roh(`/workspace/api/entwicklung/person/${idModi}`, HAUS, { cookie: kDogi });
|
||
const punkte = (json(r).bloecke || []).flatMap((b) => b.punkte || []);
|
||
const alterPunkt = punkte.find((p) => p.schluessel === alt);
|
||
ok(alterPunkt?.meins?.verblasst === true,
|
||
`ein Stand von vor ${modul.VERBLASST_NACH_TAGEN + 10} Tagen gilt als verblasst`);
|
||
|
||
/* GEGENPROBE, und ohne sie beweist die Zeile darüber nichts: Einer
|
||
von heute gilt NICHT als verblasst. */
|
||
const frisch = punkte.find((p) => p.schluessel === kat.ENTWICKLUNG_FREMD[0].schluessel);
|
||
ok(frisch?.meins?.verblasst === false,
|
||
"einer von heute nicht");
|
||
|
||
const lage = json(await roh("/workspace/api/entwicklung/lage", HAUS, { cookie: kDogi }));
|
||
const zeile = (lage.personen || []).find((p) => p.id === idModi);
|
||
ok(zeile?.veraltet === 1, `und die Übersicht zählt ihn (${zeile?.veraltet})`);
|
||
ok(zeile?.abweichungen === 1, `samt der Abweichung (${zeile?.abweichungen})`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
7. TALENTE GEHÖRT DOGFATHER UND DER RECHTEN HAND
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 7. Talente ===");
|
||
{
|
||
const lage = await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi });
|
||
const r = json(lage);
|
||
ok(lage.code === 200 && (r.kandidaten || []).length === 1,
|
||
`DogFather sieht den Trichter (${(r.kandidaten || []).length} Kandidat)`);
|
||
ok((r.trichter || []).length === tal.TALENT_STUFEN.length,
|
||
`alle ${r.trichter?.length} Stufen kommen mit`);
|
||
const k = r.kandidaten[0];
|
||
ok(k.stufe === "aufgefallen",
|
||
`ein neuer Kandidat startet auf „${k.stufe_name}" (${k.stufe})`);
|
||
ok(!!k.schritt && !!k.knopf, `und hat genau einen nächsten Schritt: „${k.knopf}"`);
|
||
|
||
/* DER RIEGEL. Auf Seite UND Schnittstelle -- eine Kachel, die es
|
||
nicht gibt, ist keine Sicherung. */
|
||
const modiApi = await roh("/workspace/api/talente/lage", CREW, { cookie: kModi });
|
||
ok(modiApi.code === 404, `ein Modi bekommt die Schnittstelle nicht (${modiApi.code})`);
|
||
const modiSeite = await roh("/workspace/talente.html", CREW, { cookie: kModi });
|
||
ok(modiSeite.code !== 200, `und die Seite auch nicht (${modiSeite.code})`);
|
||
const wer = rechte.SEITEN["/workspace/talente.html"] || [];
|
||
ok(wer.length === 2 && wer.includes("admin") && wer.includes("hand"),
|
||
`die Tafel gibt sie genau an ${wer.join(" und ")}`);
|
||
|
||
/* GEGENPROBE: die rechte Hand kommt hinein. */
|
||
const handApi = await roh("/workspace/api/talente/lage", CREW, { cookie: kHand });
|
||
ok(handApi.code === 200, `die rechte Hand schon (${handApi.code})`);
|
||
|
||
/* Merkmale: ein Klick setzt, der zweite nimmt zurück. */
|
||
const m = tal.TALENT_ALLE[0].schluessel;
|
||
const w = tal.TALENT_WARNZEICHEN[0].schluessel;
|
||
const eins = await roh(`/workspace/api/talente/${idTalent}/merkmal/${m}`, HAUS,
|
||
{ cookie: kDogi }, {}, "PUT");
|
||
ok(eins.code === 200 && json(eins).gesetzt === true, "ein Merkmal wird gesetzt");
|
||
const zwei = await roh(`/workspace/api/talente/${idTalent}/merkmal/${m}`, HAUS,
|
||
{ cookie: kDogi }, {}, "PUT");
|
||
ok(zwei.code === 200 && json(zwei).gesetzt === false, "und der zweite Klick nimmt es zurück");
|
||
await roh(`/workspace/api/talente/${idTalent}/merkmal/${m}`, HAUS, { cookie: kDogi }, {}, "PUT");
|
||
await roh(`/workspace/api/talente/${idTalent}/merkmal/${w}`, HAUS, { cookie: kDogi }, {}, "PUT");
|
||
|
||
const nach = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi })).kandidaten[0];
|
||
ok(nach.merkmale.length === 1 && nach.warnzeichen.length === 1,
|
||
`Merkmale und Warnzeichen stehen getrennt (${nach.merkmale.length} / ${nach.warnzeichen.length})`);
|
||
ok(!nach.merkmale.includes(w),
|
||
"ein Warnzeichen landet nicht zwischen den Merkmalen");
|
||
|
||
/* Die Stufe wandert -- und die Standzeit beginnt von vorn. */
|
||
const weiter = await roh(`/workspace/api/talente/${idTalent}/stufe`, HAUS,
|
||
{ cookie: kDogi }, { stufe: "beobachtet" }, "PUT");
|
||
ok(weiter.code === 200, `ein Schritt weiter im Trichter (${weiter.code})`);
|
||
const nach2 = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi })).kandidaten[0];
|
||
ok(nach2.stufe === "beobachtet" && nach2.tage === 0,
|
||
`Stufe „${nach2.stufe_name}", Standzeit beginnt bei ${nach2.tage}`);
|
||
ok(nach2.liegt === false, "und liegt damit auch nicht");
|
||
|
||
const erfunden = await roh(`/workspace/api/talente/${idTalent}/stufe`, HAUS,
|
||
{ cookie: kDogi }, { stufe: "chef" }, "PUT");
|
||
ok(erfunden.code === 400, `eine erfundene Stufe wird abgelehnt (${erfunden.code})`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
8. LIEGENGEBLIEBEN IST EINE AUSKUNFT ÜBER UNS
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 8. Standzeit ===");
|
||
{
|
||
const stufe = tal.talentStufe("beobachtet");
|
||
const dd = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
dd.prepare("UPDATE talent_stufe SET seit = ? WHERE eintrag_id = ?")
|
||
.run(new Date(Date.now() - (stufe.frist + 11) * 86400000).toISOString(), idTalent);
|
||
dd.close();
|
||
|
||
const r = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
const k = r.kandidaten[0];
|
||
ok(k.liegt === true && k.tage === stufe.frist + 11,
|
||
`nach ${k.tage} Tagen auf einer Stufe mit Frist ${stufe.frist} gilt die Karte als liegengeblieben`);
|
||
const t = (r.trichter || []).find((x) => x.schluessel === "beobachtet");
|
||
ok(t?.liegt === 1, `und der Trichter zählt sie (${t?.liegt})`);
|
||
|
||
/* GEGENPROBE von der anderen Seite der Grenze -- sonst wäre „liegt"
|
||
auch dann grün, wenn es immer liegt. */
|
||
const dd2 = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
dd2.prepare("UPDATE talent_stufe SET seit = ? WHERE eintrag_id = ?")
|
||
.run(new Date(Date.now() - (stufe.frist - 1) * 86400000).toISOString(), idTalent);
|
||
dd2.close();
|
||
const r2 = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
ok(r2.kandidaten[0].liegt === false,
|
||
`einen Tag vor der Frist noch nicht (${r2.kandidaten[0].tage} Tage)`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
9. DER VORLAGENTEXT
|
||
|
||
Er ist der Unterschied zwischen "Ansprechen" als Aufgabe und
|
||
"Ansprechen" als erledigter Sache. Geprueft wird deshalb nicht, DASS
|
||
ein Text kommt, sondern dass er aus den angeklickten Merkmalen
|
||
gebaut ist -- sonst waere es eine Floskel mit eingesetztem Namen.
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 9. Der Vorlagentext ===");
|
||
{
|
||
const zwei = [tal.TALENT_ALLE[0], tal.TALENT_ALLE[1]];
|
||
const text = tal.ansprechtext("Kessi aus dem Chat", zwei.map((m) => m.schluessel));
|
||
|
||
ok(text.startsWith("Hey Kessi,"),
|
||
"die Anrede nimmt nur den ersten Namensteil, nicht den ganzen Eintragstitel");
|
||
ok(zwei.every((m) => text.includes(m.du)),
|
||
"beide angeklickten Merkmale stehen woertlich im Text");
|
||
ok(/kein Druck|nein/.test(text),
|
||
"und der Ausstieg steht drin -- ein Angebot ohne Nein ist keines");
|
||
|
||
/* GEGENPROBE: ohne ein einziges Merkmal darf KEINES drinstehen --
|
||
sonst baut die Funktion sich etwas zusammen, das niemand beobachtet
|
||
hat. Das waere die schlimmste Sorte Vorlage. */
|
||
const leer = tal.ansprechtext("Kessi", []);
|
||
ok(!tal.TALENT_ALLE.some((m) => leer.includes(m.du)),
|
||
"ohne angeklickte Merkmale steht auch keines im Text");
|
||
ok(leer.length > 100, `aber ein vollstaendiger Text bleibt es (${leer.length} Zeichen)`);
|
||
ok(leer !== text, "und er ist ein anderer als der mit Merkmalen");
|
||
|
||
/* HAUSREGEL: In Text, den ein Mensch liest, stehen echte Umlaute.
|
||
"Haettest du Lust" war genau der Fehler, den diese Zeile findet. */
|
||
const beide = text + " " + leer;
|
||
ok(!/\b(fuer|koenn|haett|muess|ueber|waer|moecht)/i.test(beide),
|
||
"keine ASCII-Ersatzumlaute in einem Text, den ein Mensch liest");
|
||
ok(/\b(fuer)/i.test("das ist fuer dich"), "und der Sucher findet so einen auch wirklich");
|
||
|
||
/* UND ER KOMMT UEBER DIE LEITUNG AN, nicht nur aus dem Modul. */
|
||
const lage = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
const k = (lage.kandidaten || [])[0];
|
||
ok(typeof k?.ansprechtext === "string" && k.ansprechtext.length > 100,
|
||
"die Karte bringt ihren Text mit");
|
||
const gesetzt = (k?.merkmale || []).map((s) => tal.TALENT_NACH_SCHLUESSEL.get(s)?.du).filter(Boolean);
|
||
ok(gesetzt.length > 0 && gesetzt.every((d) => k.ansprechtext.includes(d)),
|
||
`und zwar aus ihren ${gesetzt.length} gesetzten Merkmalen`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
10. DIE EIGENE KARTE
|
||
|
||
Sie ist die Gegenprobe zur ganzen Kategorie: Ueber Menschen wird hier
|
||
aufgeschrieben, und wer beschrieben wird, darf es lesen. Aber erst,
|
||
wenn ALLE gesetzt haben -- sonst waere die erste Einschaetzung eine
|
||
Vorgabe fuer die zweite -- und ohne Namen und ohne Anlasstext.
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 10. Die eigene Karte ===");
|
||
{
|
||
const meine = json(await roh("/workspace/api/entwicklung/meine-karte", CREW, { cookie: kModi }));
|
||
ok(meine.hat_karte === true, "der Modi hat eine eigene Karte");
|
||
ok(meine.beurteiler === 2,
|
||
`zwei Augenpaare urteilen ueber ihn (${meine.beurteiler}) -- er selbst zaehlt nicht mit`);
|
||
|
||
const punkte = (meine.bloecke || []).flatMap((b) => b.punkte || []);
|
||
ok(punkte.length > 0, `${punkte.length} Punkte in seiner Karte`);
|
||
|
||
/* Aus Abschnitt 4: DIESEN Punkt haben beide gesetzt (laeuft/waechst). */
|
||
const beide = punkte.find((p) => p.schluessel === kat.ENTWICKLUNG_FREMD[0].schluessel);
|
||
ok(beide && beide.offen === false, "ein Punkt, den beide gesetzt haben, ist offen");
|
||
ok(beide?.antworten?.length === 2,
|
||
`mit beiden Antworten nebeneinander (${(beide?.antworten || []).map((a) => a.name).join(" / ")})`);
|
||
ok(beide?.einig === false, "und dem ehrlichen Hinweis, dass sie sich uneinig sind");
|
||
|
||
/* GEGENPROBE 1 -- und ohne sie beweist die Zeile darueber nichts:
|
||
Einen Punkt, den erst EINER gesetzt hat, bekommt er NICHT. */
|
||
const einer = punkte.find((p) => p.schluessel === kat.ENTWICKLUNG_FREMD[1].schluessel);
|
||
ok(einer && einer.offen === true,
|
||
"einen Punkt, den erst einer gesetzt hat, sieht er noch nicht");
|
||
ok(einer && einer.antworten === undefined,
|
||
"und die Antwort des einen reist dabei auch nicht heimlich mit");
|
||
|
||
/* GEGENPROBE 2: sobald die zweite dazukommt, oeffnet er sich. */
|
||
const nach = await roh(`/workspace/api/entwicklung/person/${idModi}/${kat.ENTWICKLUNG_FREMD[1].schluessel}`,
|
||
CREW, { cookie: kHand }, { stufe: "hakt", anlass: "Zweimal zu spaet zur Schicht." }, "PUT");
|
||
ok(nach.code === 200, `die rechte Hand setzt denselben Punkt (${nach.code})`);
|
||
const meine2 = await roh("/workspace/api/entwicklung/meine-karte", CREW, { cookie: kModi });
|
||
const jetztOffen = (json(meine2).bloecke || []).flatMap((b) => b.punkte || [])
|
||
.find((p) => p.schluessel === kat.ENTWICKLUNG_FREMD[1].schluessel);
|
||
ok(jetztOffen?.offen === false && jetztOffen?.antworten?.length >= 1,
|
||
"danach steht er in seiner Karte");
|
||
|
||
/* KEINE NAMEN UND KEIN ANLASS. Beides steht in der Karte, die
|
||
DogFather sieht -- und beides waere hier ein Vertrauensbruch:
|
||
"wer hat das ueber mich gesagt" macht aus einer Entwicklung eine
|
||
Abrechnung. */
|
||
const roh2 = meine2.text;
|
||
ok(!/Filipe|Rieke/.test(roh2), "kein Name eines Beurteilers in der ganzen Antwort");
|
||
ok(!/zu spaet zur Schicht|Am Samstag/.test(roh2), "und kein einziger Anlasstext");
|
||
ok(/hakt|laeuft|waechst/.test(roh2),
|
||
"die Antworten selbst kommen aber an -- sonst waere die Zeile darueber trivial");
|
||
|
||
/* Block 5 gehoert der Person -- er steht in IHRER Selbstauskunft,
|
||
nicht in der Fremdkarte. Waere er hier, stuenden Antworten
|
||
anderer auf Fragen, die nur sie sich stellt. */
|
||
const selbst = kat.ENTWICKLUNG_SELBST.map((p) => p.schluessel);
|
||
ok(!punkte.some((p) => selbst.includes(p.schluessel)),
|
||
"Block 5 taucht in der eigenen Karte nicht als Fremdurteil auf");
|
||
|
||
/* Wer gar nicht beurteilt wird, bekommt auch keine leere Karte
|
||
vorgesetzt -- eine Karte ohne Inhalt liest sich wie ein Versaeumnis. */
|
||
/* UND DIE RECHTE HAND HAT AUCH EINE. Ueber sie urteilt nur DogFather
|
||
-- sie selbst zaehlt nicht mit, sonst waere ihre Karte erst dann
|
||
vollstaendig, wenn sie sich selbst eingeschaetzt hat. */
|
||
const ihre = json(await roh("/workspace/api/entwicklung/meine-karte", CREW, { cookie: kHand }));
|
||
ok(ihre.hat_karte === true, `auch die rechte Hand hat eine eigene Karte (${JSON.stringify(ihre).slice(0, 90)})`);
|
||
ok(ihre.beurteiler === 1, `ueber sie urteilt genau einer (${ihre.beurteiler})`);
|
||
|
||
const chef = json(await roh("/workspace/api/entwicklung/meine-karte", HAUS, { cookie: kDogi }));
|
||
ok(chef.hat_karte === false, "DogFather selbst hat keine -- ueber ihn urteilt hier niemand");
|
||
}
|
||
|
||
/* =======================================================================
|
||
11. AUS DER PROBE WIRD EIN ZUGANG
|
||
|
||
Der letzte Schritt des Trichters ist kein Schritt, sondern eine
|
||
Entscheidung. Bis heute stand dort ein Satz ("Zugang in Personen &
|
||
Zugaenge anlegen"), und wer ihn vergass, hatte eine Karte auf "Im
|
||
Team" und keinen Menschen darin.
|
||
|
||
GEPRUEFT WIRD VOR ALLEM EINES: dass es dafuer keinen ZWEITEN Weg
|
||
gibt. Ein Zugang entsteht im ganzen Haus an genau einer Stelle.
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 11. Probe → Zugang ===");
|
||
{
|
||
const letzte = tal.TALENT_STUFEN.at(-1);
|
||
ok(!/Personen/.test(letzte.schritt || ""),
|
||
"die letzte Stufe schickt niemanden mehr von Hand in die Personenverwaltung");
|
||
|
||
/* EIN EINZIGER WEG, und es ist der vorhandene. */
|
||
const js = readFileSync(new URL("../workspace/assets/js/talente.js", import.meta.url), "utf8");
|
||
/* OHNE DIE KOMMENTARE gezaehlt: Der Weg wird daneben auch erklaert,
|
||
und eine Erklaerung ist kein zweiter Weg. */
|
||
const jsCode = js.replace(/\/\*[\s\S]*?\*\//g, "");
|
||
const wege = jsCode.split("/workspace/api/verwaltung/personen").length - 1;
|
||
ok(wege === 1, `talente.js kennt genau einen Weg zum Anlegen (${wege})`);
|
||
ok(js.split("/workspace/api/verwaltung/personen").length - 1 > wege,
|
||
"und der Kommentar daneben nennt ihn beim Namen -- sonst zaehlt die Zeile darueber nichts weg");
|
||
const eigen = readFileSync(new URL("../server/workspace-entwicklung.js", import.meta.url), "utf8");
|
||
ok(!/personAnlegen|INSERT INTO personen/.test(eigen),
|
||
"und der Talente-Server legt selbst keinen einzigen Zugang an");
|
||
|
||
/* DIE RECHTE HAND SIEHT DEN TRICHTER, VERGIBT ABER KEINE ZUGAENGE. */
|
||
const hand = await roh("/workspace/api/verwaltung/personen", CREW, { cookie: kHand },
|
||
{ name: "Heimlich", rolle: "modi" });
|
||
ok(hand.code === 404, `die rechte Hand kommt am Anlegen nicht vorbei (${hand.code})`);
|
||
const einModi = await roh("/workspace/api/verwaltung/personen", CREW, { cookie: kModi },
|
||
{ name: "Heimlich", rolle: "modi" });
|
||
ok(einModi.code === 404, `ein Modi erst recht nicht (${einModi.code})`);
|
||
|
||
/* GEGENPROBE: DogFather kann es -- sonst waere "404" oben auch dann
|
||
gruen, wenn der Weg gar nicht existiert. */
|
||
const neu = await roh("/workspace/api/verwaltung/personen", HAUS, { cookie: kDogi },
|
||
{ name: "Kessi", rolle: "modi" });
|
||
ok(neu.code === 201, `DogFather legt den Zugang an (${neu.code})`);
|
||
const person = json(neu);
|
||
ok(person.rolle === "modi", `und zwar als Modi (${person.rolle})`);
|
||
ok(typeof person.code === "string" && person.code.length > 8,
|
||
"der Zugangscode kommt genau einmal zurueck");
|
||
|
||
/* UND DANACH IST ER WEG. Nirgends abrufbar -- auch nicht fuer den,
|
||
der ihn angelegt hat. */
|
||
const liste = await roh("/workspace/api/verwaltung/personen", HAUS, { cookie: kDogi });
|
||
ok(liste.code === 200 && !liste.text.includes(person.code),
|
||
"danach steht er in keiner Liste mehr");
|
||
|
||
/* Erst jetzt wandert die Karte -- in derselben Reihenfolge wie in der
|
||
Oberflaeche: erst der Mensch, dann der Haken. */
|
||
const stufe = await roh(`/workspace/api/talente/${idTalent}/stufe`, HAUS,
|
||
{ cookie: kDogi }, { stufe: "imteam" }, "PUT");
|
||
ok(stufe.code === 200, `und die Karte geht auf "Im Team" (${stufe.code})`);
|
||
const lage = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
const k = (lage.kandidaten || []).find((x) => x.id === idTalent);
|
||
ok(k?.stufe === "imteam" && k?.knopf === null,
|
||
"dahinter kommt kein weiterer Knopf -- der Trichter ist zu Ende");
|
||
|
||
/* Der neue Mensch ist wirklich da, mit allem, was daran haengt. */
|
||
const dd = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const z = dd.prepare("SELECT rolle, aktiv FROM personen WHERE name = 'Kessi'").get();
|
||
dd.close();
|
||
ok(z?.rolle === "modi" && z?.aktiv === 1, "und er steht als aktiver Modi in der Datenbank");
|
||
}
|
||
|
||
/* =======================================================================
|
||
12. DIE REIHENFOLGE — NACH RANG, NICHT NACH NAMEN
|
||
|
||
Filipe, 11.09.2026 mit Bildschirmfoto der Liste "Wen gehst du
|
||
durch?" (Diene, Dogi, VanVan — alphabetisch, die rechte Hand
|
||
ganz rechts): "rechte hand soll immer als erstes sein. ueberall.
|
||
... ausser bei personen und zugaengen soll sie ueber jedem aber
|
||
unter dogfather sein."
|
||
|
||
WARUM DIE NAMEN IM PRUEFSTAND SO GEWAEHLT SIND: Rieke (rechte Hand)
|
||
steht alphabetisch HINTER Frida, Mara und Nina. Waere die Sortierung
|
||
auch nur an einer Stelle wieder die alte, stuende sie dort hinten —
|
||
und die Pruefung wuerde es sehen. Mit einem Namen wie "Anna" waere
|
||
jede Zeile hier gruen, ohne irgendetwas zu messen.
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 12. Die Reihenfolge ===");
|
||
{
|
||
/* Die Quelle selbst: EINE Liste, und der SQL-Ausdruck daraus
|
||
abgeleitet. Zwei gepflegte Listen waeren die Stelle, an der es
|
||
beim naechsten Mal auseinanderlaeuft. */
|
||
const w = await import("./workspace.js");
|
||
const reihe = w.ROLLEN_REIHE;
|
||
ok(reihe.indexOf("hand") === reihe.indexOf("admin") + 1,
|
||
`die rechte Hand steht direkt hinter DogFather (${reihe.join(" > ")})`);
|
||
ok(reihe.every((r, i) => w.ROLLEN_SORTIERUNG.includes(`WHEN '${r}' THEN ${i}`)),
|
||
"der SQL-Ausdruck kennt jede Rolle mit genau ihrer Nummer");
|
||
ok(w.ROLLEN_SORTIERUNG.split("WHEN").length - 1 === reihe.length,
|
||
`und keine darueber hinaus (${w.ROLLEN_SORTIERUNG.split("WHEN").length - 1} von ${reihe.length})`);
|
||
/* Die Aufrufer stellen "rolle" per .replace() auf "p.rolle" um --
|
||
das trifft nur die erste Fundstelle. Kaeme das Wort zweimal vor,
|
||
waere die zweite Haelfte des Ausdrucks still falsch. */
|
||
ok(w.ROLLEN_SORTIERUNG.split("rolle").length - 1 === 1,
|
||
"das Wort „rolle“ kommt darin genau einmal vor");
|
||
ok(!w.ROLLEN_REIHE.includes("gast"),
|
||
"die Community steht nicht in der Rangfolge — sie faellt ans Ende");
|
||
|
||
/* ---- Die Liste aus dem Bildschirmfoto ---- */
|
||
const lage = json(await roh("/workspace/api/entwicklung/lage", HAUS, { cookie: kDogi }));
|
||
const namen = (lage.personen || []).map((p) => p.name);
|
||
ok(namen.length >= 3, `${namen.length} Menschen in „Wen gehst du durch?“ (${namen.join(", ")})`);
|
||
ok(namen[0] === "Rieke", `die rechte Hand steht ganz links (${namen[0]})`);
|
||
/* GEGENPROBE, und ohne sie beweist die Zeile darueber nichts:
|
||
Alphabetisch stuende sie HINTEN. Dass beides verschieden ist, ist
|
||
der eigentliche Beweis, dass hier nach Rang sortiert wird. */
|
||
const alphabetisch = [...namen].sort((a, b) => a.localeCompare(b, "de"));
|
||
ok(alphabetisch[0] !== "Rieke",
|
||
`alphabetisch stuende dort ${alphabetisch[0]} — die Reihenfolge ist also keine Namensfolge`);
|
||
|
||
/* ---- Personen & Zugaenge: unter DogFather, ueber allen anderen ---- */
|
||
const liste = json(await roh("/workspace/api/verwaltung/personen", HAUS, { cookie: kDogi }));
|
||
const alle = (liste.personen || []).map((p) => ({ name: p.name, rolle: p.rolle }));
|
||
ok(alle.length >= 4, `${alle.length} Menschen in „Personen & Zugaenge“`);
|
||
const platz = (rolle) => alle.findIndex((p) => p.rolle === rolle);
|
||
const vonHand = platz("hand");
|
||
ok(vonHand >= 0, "die rechte Hand steht in der Liste");
|
||
ok(platz("admin") >= 0 && platz("admin") < vonHand,
|
||
`DogFather steht ueber ihr (Platz ${platz("admin") + 1} vor ${vonHand + 1})`);
|
||
const darunter = alle.filter((p, i) => i > vonHand).map((p) => p.rolle);
|
||
const darueber = alle.filter((p, i) => i < vonHand).map((p) => p.rolle);
|
||
ok(darueber.every((r) => r === "admin" || r === "spicy"),
|
||
`ueber ihr steht nur die Leitung (${darueber.join(", ") || "niemand"})`);
|
||
ok(darunter.includes("manager") && darunter.includes("modi"),
|
||
`unter ihr stehen Manager und Modis (${[...new Set(darunter)].join(", ")})`);
|
||
|
||
/* ---- Und dieselbe Regel im Haus nebenan ---- */
|
||
const crew = json(await roh("/workspace/api/entwicklung/lage", CREW, { cookie: kHand }));
|
||
const crewNamen = (crew.personen || []).map((p) => p.name);
|
||
ok(crewNamen[0] === "Rieke",
|
||
`auch auf der Team-Adresse steht sie vorn (${crewNamen.join(", ")})`);
|
||
}
|
||
|
||
|
||
/* =======================================================================
|
||
13. DIE PROBEZEIT HAT EINEN INHALT (17.09.2026)
|
||
|
||
Filipe: „wie talente bewertet werden, aufgaben bekommen, analysiert
|
||
werden von vanvan und mir."
|
||
|
||
Gemessen war vorher: Die Stufe „Probe" hatte eine Frist von 30 Tagen
|
||
und sonst nichts. Worauf die Entscheidung am Tag 30 sich gruenden
|
||
soll, stand nirgends -- und dann entscheidet das Bauchgefuehl
|
||
dessen, der zuletzt etwas gesehen hat.
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 13. Die Probezeit ===");
|
||
{
|
||
const probeplan = await import("./workspace-probeplan.js");
|
||
|
||
/* ---- Der Katalog selbst ---- */
|
||
ok(probeplan.PROBE_ALLE.length >= 10,
|
||
`der Plan hat ${probeplan.PROBE_ALLE.length} Schritte in ${probeplan.PROBE_PHASEN.length} Phasen`);
|
||
{
|
||
const s = probeplan.PROBE_ALLE.map((x) => x.schluessel);
|
||
ok(new Set(s).size === s.length, "die Schluessel sind eindeutig");
|
||
}
|
||
{
|
||
/* JEDER SCHRITT HAT EINEN ZUSTAENDIGEN. Ohne ihn wandern in jeder
|
||
Probezeit dieselben drei an niemanden. */
|
||
const ohne = probeplan.PROBE_ALLE.filter((x) => !probeplan.PROBE_WER[x.wer]);
|
||
ok(ohne.length === 0,
|
||
ohne.length ? `ohne Zustaendigen: ${ohne.map((x) => x.schluessel).join(", ")}`
|
||
: "jeder Schritt sagt, WER ihn tut");
|
||
const wer = new Set(probeplan.PROBE_ALLE.map((x) => x.wer));
|
||
ok(wer.size === 3,
|
||
`und es sind wirklich drei verschiedene (${[...wer].join(", ")}) -- `
|
||
+ "eine Probe, die nur der Kandidat abarbeitet, prueft nichts");
|
||
}
|
||
{
|
||
/* JEDER SCHRITT SAGT, WOFUER ER DA IST. Ein Haken, dessen Zweck man
|
||
nicht kennt, wird gesetzt, weil er dasteht. */
|
||
const duenn = probeplan.PROBE_ALLE.filter((x) => (x.wofuer || "").length < 40);
|
||
ok(duenn.length === 0,
|
||
duenn.length ? `ohne Begruendung: ${duenn.map((x) => x.schluessel).join(", ")}`
|
||
: "und jeder sagt, welche Frage er beantwortet");
|
||
}
|
||
|
||
/* ---- Entscheidbar heisst NICHT „alles abgehakt" ---- */
|
||
{
|
||
const leer = probeplan.probeStand([]);
|
||
const voll = probeplan.probeStand(probeplan.PROBE_ALLE.map((x) => x.schluessel));
|
||
ok(leer.entscheidbar === false && leer.fehlt_noetig.length === 3,
|
||
`ohne einen Haken kann man nicht entscheiden (es fehlen ${leer.fehlt_noetig.length})`);
|
||
ok(voll.entscheidbar === true, "mit allen Haken schon");
|
||
/* DER FALL DAZWISCHEN, und der ist der eigentliche Punkt: Neun von
|
||
zwoelf Haken reichen NICHT, wenn die drei noetigen fehlen. Eine
|
||
Schwelle nach Anzahl waere Fleiss beim Abhaken, keine
|
||
Beurteilung. */
|
||
const ohneNoetige = probeplan.PROBE_ALLE
|
||
.map((x) => x.schluessel)
|
||
.filter((s) => !["pr-allein-schicht", "pr-team-gefragt", "pr-er-will-noch"].includes(s));
|
||
const fast = probeplan.probeStand(ohneNoetige);
|
||
ok(fast.getan === probeplan.PROBE_ALLE.length - 3 && fast.entscheidbar === false,
|
||
`${fast.getan} von ${fast.gesamt} Haken reichen nicht -- es kommt auf die drei an, `
|
||
+ "nicht auf die Anzahl");
|
||
/* Und die Gegenprobe dazu: NUR die drei genuegen. */
|
||
const nurDrei = probeplan.probeStand(
|
||
["pr-allein-schicht", "pr-team-gefragt", "pr-er-will-noch"]);
|
||
ok(nurDrei.entscheidbar === true,
|
||
`drei von ${nurDrei.gesamt} genuegen, wenn es die richtigen sind`);
|
||
}
|
||
|
||
/* ---- Am lebenden Kandidaten ----
|
||
|
||
EIN EIGENER, FRISCHER. Der aus den Abschnitten davor ist laengst
|
||
durch den ganzen Trichter gelaufen und steht auf "imteam" -- an ihm
|
||
waere "vor der Probe steht keine Liste" nicht falsch, sondern
|
||
unpruefbar. Beim ersten Anlauf war genau das der Grund fuer vier
|
||
rote Zeilen: meine Annahme, nicht der Code. */
|
||
const neuerTalent = await roh("/workspace/api/bereich/talente", HAUS, { cookie: kDogi },
|
||
{ art: "ruhig", titel: "Jonas aus dem Chat", text: "Faellt seit kurzem auf." });
|
||
ok(neuerTalent.code === 201 || neuerTalent.code === 200,
|
||
`ein frischer Kandidat fuer diesen Abschnitt (${neuerTalent.code})`);
|
||
const lage = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
const kandidat = (lage.kandidaten || []).find((k) => k.titel === "Jonas aus dem Chat");
|
||
ok(!!kandidat, `er steht im Trichter (${kandidat?.stufe})`);
|
||
|
||
/* SOLANGE ER NICHT IN DER PROBE IST, gibt es keine Liste. Eine leere
|
||
Zwoelferliste an einem Beobachteten waere Laerm -- und Laerm liest
|
||
man auch dann weg, wenn er gilt. */
|
||
ok(!kandidat.probe,
|
||
`vor der Probe steht dort keine Liste (${kandidat.probe ? "doch eine" : "keine"})`);
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/pr-erste-schicht`,
|
||
HAUS, { cookie: kDogi }, {}, "PUT");
|
||
ok(r.code === 409,
|
||
`und abhaken geht nicht, solange die Probe nicht laeuft (${r.code})`);
|
||
}
|
||
|
||
/* ---- Jetzt in die Probe ---- */
|
||
/* Ortszeit, nicht UTC: Zwischen 00:00 und 02:00 waere „morgen“ aus
|
||
UTC gerechnet heute -- und der Server lehnt ein Datum in der
|
||
Vergangenheit ab. Die Pruefung waere nachts rot, ohne dass
|
||
irgendetwas kaputt ist. */
|
||
const morgen = tagLokal(1);
|
||
{
|
||
/* Ueber den vorhandenen Weg, nicht an ihm vorbei. */
|
||
let stufe = kandidat.stufe;
|
||
let schutz = 0;
|
||
while (stufe !== "probe" && schutz++ < 6) {
|
||
const naechste = tal.talentNaechste(stufe)?.schluessel;
|
||
if (!naechste) break;
|
||
const r = await roh(`/workspace/api/talente/${kandidat.id}/stufe`, HAUS,
|
||
{ cookie: kDogi },
|
||
naechste === "probe"
|
||
? { stufe: naechste, buddy_id: idModi, erste_schicht: morgen }
|
||
: { stufe: naechste },
|
||
"PUT");
|
||
if (r.code !== 200) break;
|
||
stufe = naechste;
|
||
}
|
||
ok(stufe === "probe", `der Kandidat steht jetzt in der Probe (${stufe})`);
|
||
}
|
||
|
||
{
|
||
const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
|
||
.kandidaten.find((x) => x.id === kandidat.id);
|
||
ok(!!k.probe, "jetzt steht die Liste an der Karte");
|
||
ok(k.probe.gesamt === probeplan.PROBE_ALLE.length && k.probe.getan === 0,
|
||
`${k.probe.getan} von ${k.probe.gesamt} -- und noch nichts abgehakt`);
|
||
ok(k.probe.entscheidbar === false,
|
||
"und noch nicht entscheidbar -- am Tag 1 waere alles andere gelogen");
|
||
const mitWer = k.probe.schritte.filter((s) => s.wer_name);
|
||
ok(mitWer.length === k.probe.gesamt,
|
||
`jeder Schritt bringt seinen Zustaendigen mit (${mitWer.length})`);
|
||
}
|
||
|
||
/* ---- Abhaken, und WER es war ---- */
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/pr-erste-schicht`,
|
||
HAUS, { cookie: kDogi }, {}, "PUT");
|
||
ok(r.code === 200 && json(r).fertig === true, `abhaken geht (${r.code})`);
|
||
const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
|
||
.kandidaten.find((x) => x.id === kandidat.id);
|
||
const s = k.probe.schritte.find((x) => x.schluessel === "pr-erste-schicht");
|
||
ok(s.fertig === true && s.von === "Filipe",
|
||
`und es steht dabei, wer es war (${s.von})`);
|
||
ok(k.probe.getan === 1, `der Stand zieht mit (${k.probe.getan} von ${k.probe.gesamt})`);
|
||
}
|
||
{
|
||
/* EIN KNOPF, ZWEI RICHTUNGEN -- wie bei den Merkmalen. */
|
||
const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/pr-erste-schicht`,
|
||
HAUS, { cookie: kDogi }, {}, "PUT");
|
||
ok(r.code === 200 && json(r).fertig === false, "ein zweiter Klick nimmt zurueck");
|
||
const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
|
||
.kandidaten.find((x) => x.id === kandidat.id);
|
||
ok(k.probe.getan === 0, "und der Stand geht mit zurueck");
|
||
}
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/voellig-erfunden`,
|
||
HAUS, { cookie: kDogi }, {}, "PUT");
|
||
ok(r.code === 404, `ein erfundener Schritt wird abgewiesen (${r.code})`);
|
||
}
|
||
|
||
/* ---- Und die Frage, wegen der das alles da ist ---- */
|
||
{
|
||
for (const s of ["pr-allein-schicht", "pr-team-gefragt", "pr-er-will-noch"]) {
|
||
await roh(`/workspace/api/talente/${kandidat.id}/probe/${s}`, HAUS,
|
||
{ cookie: kDogi }, {}, "PUT");
|
||
}
|
||
const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
|
||
.kandidaten.find((x) => x.id === kandidat.id);
|
||
ok(k.probe.entscheidbar === true,
|
||
`mit den drei noetigen Schritten ist es entscheidbar (${k.probe.getan} von ${k.probe.gesamt})`);
|
||
ok(Array.isArray(k.probe.fragen) && k.probe.fragen.length === 3,
|
||
`und drei Fragen stehen bereit (${k.probe.fragen?.length})`);
|
||
}
|
||
|
||
/* ---- Wer was gesehen hat ---- */
|
||
{
|
||
const m = tal.TALENT_MERKMALE[tal.TALENT_GRUPPEN[0].schluessel][0].schluessel;
|
||
await roh(`/workspace/api/talente/${kandidat.id}/merkmal/${m}`, HAUS,
|
||
{ cookie: kDogi }, {}, "PUT");
|
||
const k = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }))
|
||
.kandidaten.find((x) => x.id === kandidat.id);
|
||
ok(k.gesehen_von?.[m] === "Filipe",
|
||
`an einem Merkmal steht, wer es gesehen hat (${k.gesehen_von?.[m]})`);
|
||
/* GEGENPROBE: Ein nicht gesetztes Merkmal hat auch keinen Namen --
|
||
sonst hiesse "steht dabei" nur, dass ueberall etwas steht. */
|
||
const ander = tal.TALENT_MERKMALE[tal.TALENT_GRUPPEN[0].schluessel][1]?.schluessel;
|
||
ok(!ander || !k.gesehen_von?.[ander],
|
||
"und an einem nicht gesetzten steht keiner");
|
||
}
|
||
|
||
/* ---- Die Community kommt an nichts davon heran ---- */
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${kandidat.id}/probe/pr-erste-schicht`,
|
||
CREW, { cookie: kModi }, {}, "PUT");
|
||
ok(r.code === 404, `ein Modi kann nichts abhaken -- und erfaehrt nicht, dass es das gibt (${r.code})`);
|
||
}
|
||
}
|
||
|
||
/* =======================================================================
|
||
14. DER AUSGANG AUS DEM TRICHTER (17.09.2026)
|
||
|
||
Filipe: „alles moegliche, wie gesagt ich will hoch profissionel
|
||
arbeiten."
|
||
|
||
Gemessen vor dem Bau: talentNaechste kettet aufgefallen -> beobachtet
|
||
-> angesprochen -> probe -> imteam, und danach kommt nichts. Ein
|
||
Kandidat, der nicht passt, blieb auf seiner Stufe stehen -- mit
|
||
wachsender Standzeit und rotem "liegt"-Zeichen -- obwohl der Text der
|
||
Stufe woertlich verspricht: "uebernehmen ... oder sauber beenden".
|
||
|
||
Geprueft wird hier DREIERLEI, und der dritte Punkt ist der, wegen dem
|
||
es die Spalten und nicht eine neue Stufe geworden ist:
|
||
1. Der Satz ist Pflicht -- und die Grenze beisst wirklich.
|
||
2. Beendete verschwinden aus der Arbeitsliste, nicht aus dem Haus.
|
||
3. Die STUFE bleibt stehen: Man sieht, WO es geendet hat.
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 14. Der Ausgang ===");
|
||
{
|
||
/* Jonas steht aus Abschnitt 13 in der Probe -- genau der interessante
|
||
Fall: Wer in der Probe aussteigt, hat eine andere Geschichte als
|
||
wer nach dem ersten Hinsehen aussteigt. */
|
||
const vorher = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
const jonas = (vorher.kandidaten || []).find((k) => k.titel === "Jonas aus dem Chat");
|
||
ok(!!jonas && jonas.stufe === "probe",
|
||
`Jonas steht in der Arbeitsliste, Stufe ${jonas?.stufe}`);
|
||
const stufeVorher = (vorher.trichter || []).find((x) => x.schluessel === "probe")?.anzahl;
|
||
|
||
/* ---- Der Satz ist Pflicht ---- */
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${jonas.id}/beenden`, HAUS,
|
||
{ cookie: kDogi }, { grund: "" }, "PUT");
|
||
ok(r.code === 400, `ohne Satz geht es nicht (${r.code})`);
|
||
ok((json(r).fehler || "").length > 20,
|
||
"und es steht dabei, warum der Satz verlangt wird");
|
||
}
|
||
{
|
||
/* DIE GRENZE BEISST WIRKLICH. "Passt nicht" hat neun Zeichen -- die
|
||
haeufigste Nicht-Begruendung ueberhaupt, und genau die soll
|
||
auffallen. Ohne diese Zeile wuesste man nur, dass ein LEERES Feld
|
||
abgewiesen wird, und das ist eine andere, viel schwaechere
|
||
Aussage. */
|
||
const r = await roh(`/workspace/api/talente/${jonas.id}/beenden`, HAUS,
|
||
{ cookie: kDogi }, { grund: "passt nix" }, "PUT");
|
||
ok(r.code === 400, `neun Zeichen sind noch kein Satz (${r.code})`);
|
||
}
|
||
|
||
/* ---- Beenden ---- */
|
||
const GRUND = "Hat sich nach der zweiten Schicht nicht mehr gemeldet.";
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${jonas.id}/beenden`, HAUS,
|
||
{ cookie: kDogi }, { grund: GRUND }, "PUT");
|
||
ok(r.code === 200 && json(r).beendet === true, `mit Satz geht es (${r.code})`);
|
||
}
|
||
{
|
||
const l = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
ok(!(l.kandidaten || []).some((k) => k.id === jonas.id),
|
||
"er steht nicht mehr in der Arbeitsliste");
|
||
const b = (l.beendete || []).find((k) => k.id === jonas.id);
|
||
ok(!!b, "aber er ist da -- unter den Beendeten");
|
||
ok(b?.beendet?.grund === GRUND, `der Satz steht dabei (${b?.beendet?.grund})`);
|
||
ok(b?.beendet?.von === "Filipe", `und wer es war (${b?.beendet?.von})`);
|
||
/* DER EIGENTLICHE PUNKT: Die Stufe blieb stehen. Waere daraus ein
|
||
eigener Stufenwert "beendet" geworden, stuende hier "beendet" --
|
||
und die Frage "wie weit war er gekommen?" waere fuer immer
|
||
unbeantwortbar. */
|
||
ok(b?.stufe === "probe",
|
||
`und WO es geendet hat: ${b?.stufe_name} -- nicht bloss "beendet"`);
|
||
ok(b?.liegt === false,
|
||
"er liegt nicht mehr -- eine beendete Karte wird nicht rot");
|
||
const nachher = (l.trichter || []).find((x) => x.schluessel === "probe")?.anzahl;
|
||
ok(nachher === stufeVorher - 1,
|
||
`der Trichter zaehlt ihn nicht mehr mit (${stufeVorher} -> ${nachher})`);
|
||
}
|
||
|
||
/* ---- Wieder aufnehmen ---- */
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${jonas.id}/wieder`, HAUS,
|
||
{ cookie: kDogi }, null, "PUT");
|
||
ok(r.code === 200, `wieder aufnehmen geht (${r.code})`);
|
||
const l = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
const k = (l.kandidaten || []).find((x) => x.id === jonas.id);
|
||
ok(!!k, "er steht wieder in der Arbeitsliste");
|
||
ok(k?.stufe === "aufgefallen",
|
||
`und faengt vorne an (${k?.stufe}) -- ein Jahr altes Urteil gilt nicht weiter`);
|
||
/* DER SATZ VON DAMALS BLEIBT. Er ist beim zweiten Anlauf das
|
||
Wertvollste, was man hat -- und genau er wuerde beim Zuruecksetzen
|
||
am leichtesten verschwinden. */
|
||
ok((k?.notiz || "").includes(GRUND),
|
||
"der Grund von damals steht in der Notiz");
|
||
ok(!k?.beendet, "und die Karte ist nicht mehr als beendet gezeichnet");
|
||
/* Die Probe faengt neu an -- alte Haken wuerden eine Probezeit
|
||
beschreiben, die vier Wochen zurueckliegt. */
|
||
ok(!(l.beendete || []).some((x) => x.id === jonas.id),
|
||
"aus der Sammlung der Beendeten ist er heraus");
|
||
}
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${jonas.id}/wieder`, HAUS,
|
||
{ cookie: kDogi }, null, "PUT");
|
||
ok(r.code === 409, `wer laeuft, kann nicht wieder aufgenommen werden (${r.code})`);
|
||
}
|
||
|
||
/* ---- Wer im Team ist, wird nicht hier beendet ----
|
||
|
||
Gefunden am Bildschirmfoto: Auf einer Karte auf "Im Team" stand
|
||
"Nichts mehr zu tun -- der Zugang steht" und direkt darunter
|
||
"Passt doch nicht?". Ein Beenden dort haette die KARTE stillgelegt
|
||
und den ZUGANG offengelassen -- und das ist schlimmer als gar kein
|
||
Ausgang, weil man glaubt, gehandelt zu haben. */
|
||
{
|
||
const l = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
const drin = (l.kandidaten || []).find((k) => k.stufe === "imteam");
|
||
ok(!!drin, `es gibt einen im Team zum Gegenprobieren (${drin?.titel})`);
|
||
const r = await roh(`/workspace/api/talente/${drin.id}/beenden`, HAUS,
|
||
{ cookie: kDogi }, { grund: GRUND }, "PUT");
|
||
ok(r.code === 409, `wer im Team ist, wird nicht hier beendet (${r.code})`);
|
||
ok((json(r).fehler || "").includes("Zug"),
|
||
`und es steht dabei, wo stattdessen (${(json(r).fehler || "").slice(0, 40)}...)`);
|
||
const l2 = json(await roh("/workspace/api/talente/lage", HAUS, { cookie: kDogi }));
|
||
ok((l2.kandidaten || []).some((k) => k.id === drin.id),
|
||
"er steht unveraendert in der Liste -- nichts halb passiert");
|
||
}
|
||
|
||
/* ---- Und die Gegenproben ---- */
|
||
{
|
||
const r = await roh("/workspace/api/talente/999999/beenden", HAUS,
|
||
{ cookie: kDogi }, { grund: GRUND }, "PUT");
|
||
ok(r.code === 404, `eine erfundene Nummer wird abgewiesen (${r.code})`);
|
||
}
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${jonas.id}/beenden`, CREW,
|
||
{ cookie: kModi }, { grund: GRUND }, "PUT");
|
||
ok(r.code === 404,
|
||
`ein Modi kann niemanden beenden -- und erfaehrt nicht, dass es das gibt (${r.code})`);
|
||
}
|
||
{
|
||
const r = await roh(`/workspace/api/talente/${jonas.id}/wieder`, CREW,
|
||
{ cookie: kModi }, null, "PUT");
|
||
ok(r.code === 404, `dasselbe beim Wiederaufnehmen (${r.code})`);
|
||
}
|
||
}
|
||
|
||
/* =======================================================================
|
||
15. DIE TALENTE-SEITE IM ECHTEN BROWSER (17.09.2026)
|
||
|
||
Der erste Browserblick auf diese Seite ueberhaupt. Er ist faellig:
|
||
|
||
Heute Mittag hat ein Bildschirmfoto zwei Dinge gefunden, die keine
|
||
Zahl gefunden haette -- ein Wasserzeichen, das durch vertraulichen
|
||
Text hindurchschien (color-mix mit DURCHSICHTIG statt mit Weiss),
|
||
und eine Klassenkollision, bei der .t-schritt fuer zwei verschiedene
|
||
Dinge stand. Beides war gruen in jeder Prueflinie und falsch auf dem
|
||
Schirm.
|
||
|
||
GEKLICKT WIRD WIRKLICH, nicht ueber die Schnittstelle. Der ganze Weg
|
||
-- aufklappen, tippen, absenden -- ist der, der kaputtgehen kann; was
|
||
darunter liegt, ist in Abschnitt 14 schon bewiesen.
|
||
======================================================================= */
|
||
melde("");
|
||
melde("=== 15. Im echten Browser ===");
|
||
{
|
||
let chromium;
|
||
try {
|
||
({ chromium } = await import(
|
||
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs"));
|
||
} catch { chromium = null; }
|
||
|
||
if (!chromium) {
|
||
unklar("kein Playwright gefunden -- die Oberflaeche wurde nicht angesehen");
|
||
} else {
|
||
const browser = await chromium.launch();
|
||
try {
|
||
/* 390 x 844 -- ein Handy. Filipe arbeitet am Handy, und die
|
||
Kopfleiste ist genau dort im September zerbrochen. */
|
||
const sicht = await browser.newContext({ viewport: { width: 390, height: 844 } });
|
||
await sicht.addCookies(kDogi.split("; ").map((c) => {
|
||
const [name, ...rest] = c.split("=");
|
||
return { name, value: rest.join("="), domain: "127.0.0.1", path: "/" };
|
||
}));
|
||
const seite = await sicht.newPage();
|
||
const konsole = [];
|
||
seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
|
||
await seite.goto(`http://127.0.0.1:${PORT}/workspace/talente.html`,
|
||
{ waitUntil: "domcontentloaded" });
|
||
await seite.waitForTimeout(1200);
|
||
|
||
const karten = await seite.locator(".t-karte").count();
|
||
ok(karten > 0, `die Seite zeigt ${karten} Karten`);
|
||
/* ABGELEITET, NICHT ABGESCHRIEBEN: An jeder Karte IM TRICHTER
|
||
steht ein Ausgang -- an denen im Team ausdruecklich nicht.
|
||
Feste Zahlen waeren hier die Rechnung von gestern: Kommt ein
|
||
Kandidat dazu, muesste man sie nachziehen. */
|
||
const imTeam = await seite.locator('.t-karte[data-stufe="imteam"]').count();
|
||
const ausgaenge = await seite.locator(".t-ausgang__auf").count();
|
||
ok(ausgaenge === karten - imTeam,
|
||
`an jeder Karte im Trichter ein Ausgang (${ausgaenge} von ${karten} `
|
||
+ `- ${imTeam} im Team)`);
|
||
ok(imTeam > 0 && await seite.locator(".t-ausgang__anderswo").count() === imTeam,
|
||
`und an denen im Team steht stattdessen der Weg zum Zugang (${imTeam})`);
|
||
ok(await seite.locator('.t-karte[data-stufe="imteam"] .t-ausgang__auf').count() === 0,
|
||
"dort gibt es das Feld nicht einmal zum Aufklappen");
|
||
|
||
/* ---- Der Weg: aufklappen, zu kurz, dann richtig ----
|
||
Gezielt eine Karte AUS DEM TRICHTER, nicht einfach die erste:
|
||
Welche oben steht, entscheidet die Sortierung, und die haengt
|
||
an Standzeiten. */
|
||
const erste = seite.locator('.t-karte:not([data-stufe="imteam"])').first();
|
||
const titel = (await erste.locator(".t-karte__titel").textContent())?.trim();
|
||
ok(await erste.locator(".t-ausgang__form").isHidden(),
|
||
"das Feld ist zugeklappt -- der Ausgang draengt sich nicht auf");
|
||
await erste.locator(".t-ausgang__auf").click();
|
||
await seite.waitForTimeout(200);
|
||
ok(await erste.locator(".t-ausgang__form").isVisible(),
|
||
"nach einem Klick steht es da");
|
||
|
||
{
|
||
/* ZU KURZ -- und zwar im Browser, nicht nur am Server. Was der
|
||
Browser prueft, ist Hoeflichkeit; faellt sie aus, sieht man
|
||
statt eines Satzes eine rohe Fehlermeldung. */
|
||
await erste.locator(".t-ausgang__feld").fill("passt nix");
|
||
await erste.locator(".t-ausgang__knopf").click();
|
||
await seite.waitForTimeout(400);
|
||
const meldung = (await seite.locator("#fehler").textContent())?.trim() || "";
|
||
ok(meldung.length > 10, `ein zu kurzer Satz wird abgewiesen ("${meldung}")`);
|
||
ok(await seite.locator(".t-karte").count() === karten,
|
||
"und die Karte bleibt stehen");
|
||
}
|
||
|
||
const GRUND_B = "Kam dreimal nicht zur Schicht, ohne Bescheid zu sagen.";
|
||
{
|
||
await erste.locator(".t-ausgang__feld").fill(GRUND_B);
|
||
await erste.locator(".t-ausgang__knopf").click();
|
||
await seite.waitForTimeout(900);
|
||
const uebrig = await seite.locator(".t-karte").count();
|
||
ok(uebrig === karten - 1,
|
||
`mit Satz verschwindet sie aus der Arbeitsliste (${karten} -> ${uebrig})`);
|
||
ok(await seite.locator(".t-beendet__auf").count() === 1,
|
||
"und unten steht die Sammlung der Beendeten");
|
||
const wort = (await seite.locator(".t-beendet__auf").textContent())?.trim() || "";
|
||
ok(/[0-9]/.test(wort), `zugeklappt mit Zahl ("${wort}")`);
|
||
}
|
||
|
||
{
|
||
await seite.locator(".t-beendet__auf").click();
|
||
await seite.waitForTimeout(300);
|
||
const karte = seite.locator(".t-beendet__karte").first();
|
||
ok(await karte.isVisible(), "aufgeklappt steht die Karte da");
|
||
ok((await karte.locator(".t-beendet__titel").textContent())?.trim() === titel,
|
||
"mit dem richtigen Namen");
|
||
ok((await karte.locator(".t-beendet__grund").textContent())?.includes(GRUND_B),
|
||
"und dem Satz von damals");
|
||
const stufe = (await karte.locator(".t-beendet__stufe").textContent())?.trim() || "";
|
||
ok(stufe.length > 3, `und WO es geendet hat (${stufe})`);
|
||
/* GEGENPROBE ZUR SICHTBARKEIT: An einer beendeten Karte steht
|
||
KEIN zweiter Ausgang -- sonst koennte man beenden, was schon
|
||
beendet ist, und der Grund wuerde ueberschrieben. */
|
||
ok(await karte.locator(".t-ausgang__auf").count() === 0,
|
||
"an einer beendeten Karte steht kein zweiter Ausgang");
|
||
ok(await karte.locator(".t-beendet__wieder").count() === 1,
|
||
"sondern der Weg zurueck");
|
||
}
|
||
|
||
{
|
||
/* DIE KOPFZEILE BEI 390 px. margin-inline-start: auto schiebt
|
||
das Datum nach rechts -- genau die Bauart, die im September
|
||
in der Kopfleiste zwei Knoepfe uebereinandergelegt hat. Eine
|
||
Messung statt einer Zahl im CSS. */
|
||
const k = seite.locator(".t-beendet__karte").first();
|
||
const a = await k.locator(".t-beendet__titel").boundingBox();
|
||
const b = await k.locator(".t-beendet__zeit").boundingBox();
|
||
const ueber = a && b
|
||
&& a.x < b.x + b.width && b.x < a.x + a.width
|
||
&& a.y < b.y + b.height && b.y < a.y + a.height;
|
||
ok(!!a && !!b && !ueber,
|
||
`Name und Datum liegen nicht uebereinander (${Math.round(a?.x ?? -1)}+`
|
||
+ `${Math.round(a?.width ?? 0)} | ${Math.round(b?.x ?? -1)})`);
|
||
/* Und der Weg zurueck muss mit einem Finger zu treffen sein. */
|
||
const w = await k.locator(".t-beendet__wieder").boundingBox();
|
||
ok(!!w && w.height >= 28 && w.width >= 100,
|
||
`der Weg zurueck ist treffbar (${Math.round(w?.width ?? 0)} x ${Math.round(w?.height ?? 0)})`);
|
||
}
|
||
|
||
{
|
||
await seite.locator(".t-beendet__wieder").first().click();
|
||
await seite.waitForTimeout(900);
|
||
const zurueck = await seite.locator(".t-karte").count();
|
||
ok(zurueck === karten, `wieder aufnehmen bringt sie zurueck (${zurueck})`);
|
||
ok(await seite.locator(".t-beendet__auf").count() === 0,
|
||
"und die Sammlung verschwindet, wenn nichts mehr drin ist");
|
||
}
|
||
|
||
ok(konsole.length === 0,
|
||
konsole.length ? `Konsolenfehler: ${konsole[0]}` : "kein einziger Konsolenfehler");
|
||
|
||
/* Das Bildschirmfoto -- der Teil, den keine Zahl ersetzt. */
|
||
await seite.locator('.t-karte:not([data-stufe="imteam"]) .t-ausgang__auf')
|
||
.first().click().catch(() => {});
|
||
await seite.waitForTimeout(300);
|
||
await seite.screenshot({ path: "server/pruef-nachwuchs-ausgang.png", fullPage: true });
|
||
melde(" -- Bildschirmfoto: server/pruef-nachwuchs-ausgang.png");
|
||
} finally {
|
||
await browser.close();
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ------------------------------------------------------------------- */
|
||
melde("");
|
||
melde(`${geprueft} Pruefungen, ${fehler} Fehler`
|
||
+ (offen ? `, ${offen} nicht nachsehbar` : ""));
|
||
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
|
||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
|
||
process.exit(fehler ? 1 : 0);
|