DogFatherGitandClaude Opus 5
fab545db71
Nachtrag zum Umbau von vorhin -- gefunden, als ich nach dem Ausliefern
in die echte Datenbank gesehen habe:
100 Danke 5
500 Starke Runde 15
2000 Starke Runde 45
5000 Rudel-Legende 0 <- die hoechste, und als Einzige aus
Die erste Nachruestung fuellte `glanz_minuten` nur dort, wo noch die
WERKSGRENZE steht (100/500/2000 Cent). Das war vorsichtig gemeint: Wer
seine Leiter umgebaut hat, soll nicht ploetzlich einen Glanz bekommen,
den er nie eingestellt hat. Auf dem echten Server war es die falsche
Vorsicht -- dort stehen vier Stufen, und die oberste bekam nichts.
Ein Glanz, der mit der Hoehe waechst und ausgerechnet bei der
hoechsten Stufe aufhoert, sieht nicht nach Vorsicht aus, sondern nach
einem Fehler.
Also nach RANG statt nach Betrag: unterste Stufe 5 Minuten, oberste
45, dazwischen verteilt und auf Fuenferschritte gerundet. Dieselbe
Idee wie bei den Muenzen -- nicht die Zahl abschreiben, sondern die
Reihenfolge lesen. Eine Leiter mit sechs Stufen rechnet damit genauso
richtig wie eine mit drei.
ES PASSIERT GENAU EINMAL und nur bei Stufen, die noch auf 0 stehen.
Wer spaeter bewusst eine Null einstellt, behaelt sie -- der Merker ist
dann laengst gesetzt.
Geprueft an einer frischen Datenbank mit genau dieser Leiter (vier
Stufen, oberste bei 5000): 5 / 20 / 30 / 45. Und mit Gegenprobe, dass
eine bewusst gesetzte Null stehen bleibt -- ohne sie bewiese der Lauf
nur, dass irgendetwas gefuellt wird.
pruef-spenden 215 -> 218 (0 Fehler), pruef-reaktion 478 (0).
Co-Authored-By: Claude Opus 5 <[email protected]>
1472 lines
71 KiB
JavaScript
1472 lines
71 KiB
JavaScript
/* =====================================================================
|
|
DIE SPENDEN (28.09.2026)
|
|
|
|
Geprueft wird der ganze Weg aus Filipes Ansage:
|
|
|
|
Betragsknoepfe -> PayPal -> melden -> wartet ->
|
|
bestaetigen -> Karte im Bild
|
|
|
|
---------------------------------------------------------------------
|
|
WARUM DIESE PRUEFUNG UEBER DIE HAUSADRESSE SPRICHT
|
|
|
|
Dieselbe Begruendung wie bei der Reaction: Die Community meldet
|
|
sich ueber den stillen Zugang an, und der ist auf einer
|
|
Pruefadresse absichtlich abgeschaltet. `fetch` kann die
|
|
Host-Kopfzeile nicht setzen, deshalb node:http.
|
|
|
|
Aufrufen mit: node server/pruef-spenden.mjs
|
|
===================================================================== */
|
|
import { mkdtempSync, rmSync, readFileSync, statSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join, dirname } from "node:path";
|
|
import { fileURLToPath } from "node:url";
|
|
import { request } from "node:http";
|
|
|
|
const HIER = dirname(fileURLToPath(import.meta.url));
|
|
const ordner = mkdtempSync(join(tmpdir(), "ws-spend-"));
|
|
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
|
|
|
import { notbremse } from "./helfer-notbremse.mjs";
|
|
const { eigenerPort } = await import("./helfer-port.mjs");
|
|
const PORT = await eigenerPort(import.meta, "die Spenden-Pruefung");
|
|
|
|
process.env.PORT = `${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 }); };
|
|
await import("./index.js");
|
|
notbremse(200_000, "pruef-spenden");
|
|
await new Promise((r) => setTimeout(r, 900));
|
|
|
|
let fehler = 0, geprueft = 0;
|
|
const ok = (b, t) => { geprueft++; console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
|
const melde = (t) => console.log(t);
|
|
process.on("exit", () => { try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ } });
|
|
|
|
const CREW = "crew.dogfather-universe.com";
|
|
const AGENTUR = "workspace.dogfather-universe.com";
|
|
|
|
/* ---------- Zugaenge anlegen -------------------------------------------- */
|
|
const { DatabaseSync } = await import("node:sqlite");
|
|
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
|
|
const d = new DatabaseSync(process.env.WORKSPACE_DB);
|
|
const nun = new Date().toISOString();
|
|
const kennSchluessel = randomBytes(32).toString("hex");
|
|
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
|
|
+ " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
|
|
.run("code_kennung_schluessel", kennSchluessel, nun);
|
|
|
|
/* 200 Tage alt: Der Treff hat Stufen, und wer neu ist, darf weniger.
|
|
Fuer die Reaction spielt das keine Rolle -- aber ein Zugang von
|
|
heute waere ein Sonderfall, den niemand im Blick hat. */
|
|
const ALT = new Date(Date.now() - 200 * 86400000).toISOString();
|
|
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", kennSchluessel).update(code).digest("hex"), ALT);
|
|
return d.prepare("SELECT last_insert_rowid() AS id").get().id;
|
|
}
|
|
const ROLLEN = [["admin", "Filipe"], ["hand", "VanVan"], ["linke", "Funny"],
|
|
["modi", "Miss"], ["gast", "Nachtfalter"], ["gast2", "Lenny"], ["creator", "Luna"]];
|
|
const CODES = {}; const IDS = {};
|
|
for (const [i, [rolle, name]] of ROLLEN.entries()) {
|
|
CODES[rolle] = `CODE-R${String(i).padStart(2, "0")}-000001`;
|
|
IDS[rolle] = anlegen(name, rolle === "gast2" ? "gast" : rolle, CODES[rolle]);
|
|
}
|
|
d.close();
|
|
|
|
/* ---------- Sprechen mit Hausadresse ------------------------------------ */
|
|
/** `roher` schickt Bytes statt JSON.
|
|
*
|
|
* Gebraucht fuer das Hochladen eines Bildes: Die Route nimmt
|
|
* `express.raw()` entgegen, und ein als JSON verpacktes Bild waere
|
|
* etwas anderes als das, was ein Browser schickt -- die Pruefung
|
|
* wuerde dann einen Weg pruefen, den es gar nicht gibt. */
|
|
function roh(host, pfad, { method = "GET", keks = "", rumpf = null, roher = null, origin } = {}) {
|
|
return new Promise((fertig, schief) => {
|
|
const daten = roher !== null ? roher
|
|
: (rumpf === null ? null : Buffer.from(JSON.stringify(rumpf)));
|
|
const a = request({
|
|
host: "127.0.0.1", port: PORT, path: pfad, method,
|
|
headers: {
|
|
Host: host,
|
|
Origin: origin === undefined ? `https://${host}` : origin,
|
|
...(keks ? { Cookie: keks } : {}),
|
|
...(daten ? {
|
|
"Content-Type": roher !== null ? "application/octet-stream" : "application/json",
|
|
"Content-Length": daten.length,
|
|
} : {}),
|
|
},
|
|
}, (antwort) => {
|
|
const teile = [];
|
|
antwort.on("data", (s) => teile.push(s));
|
|
antwort.on("end", () => {
|
|
const text = Buffer.concat(teile).toString("utf8");
|
|
let j = null; try { j = JSON.parse(text); } catch { /* kein JSON */ }
|
|
fertig({ code: antwort.statusCode, text, j, kopf: antwort.headers });
|
|
});
|
|
});
|
|
a.on("error", schief);
|
|
if (daten) a.write(daten);
|
|
a.end();
|
|
});
|
|
}
|
|
|
|
async function anmelden(rolle, host) {
|
|
const a = await roh(host, "/workspace/api/anmelden", {
|
|
method: "POST", rumpf: { rolle: rolle === "gast2" ? "gast" : rolle,
|
|
code: CODES[rolle], alter_ok: true },
|
|
});
|
|
const keks = [].concat(a.kopf["set-cookie"] || []).map((z) => z.split(";")[0]).join("; ");
|
|
return a.code === 200 && keks ? keks : null;
|
|
}
|
|
|
|
const k = {};
|
|
for (const [rolle] of ROLLEN) k[rolle] = await anmelden(rolle, CREW);
|
|
|
|
/* =======================================================================
|
|
1. DAS RECHNEN MIT GELD
|
|
======================================================================= */
|
|
melde("=== 1. Rechnen mit Geld ===");
|
|
{
|
|
/* NIE MIT KOMMAZAHLEN. 0.1 + 0.2 ist in jeder Programmiersprache
|
|
nicht 0.3, und bei Geld faellt das irgendwann jemandem auf --
|
|
meistens dem, der zahlt. */
|
|
const { mitBetrag, stufeFuer } = await import("./workspace-spenden.js");
|
|
|
|
ok(mitBetrag("https://paypal.me/probe", 500) === "https://paypal.me/probe/5EUR",
|
|
`runde Betraege ohne Nachkommastellen (${mitBetrag("https://paypal.me/probe", 500)})`);
|
|
ok(mitBetrag("https://paypal.me/probe", 750) === "https://paypal.me/probe/7.50EUR",
|
|
`krumme mit zweien (${mitBetrag("https://paypal.me/probe", 750)})`);
|
|
ok(mitBetrag("https://paypal.me/probe/", 200) === "https://paypal.me/probe/2EUR",
|
|
"ein Schraegstrich am Ende macht keinen doppelten");
|
|
|
|
/* AN EINER FREMDEN ADRESSE WIRD NICHTS ANGEHAENGT. Ein Betrag an
|
|
einer Seite, die ihn nicht versteht, fuehrt zu einer Seite, auf
|
|
der etwas anderes steht als auf dem Knopf. */
|
|
ok(mitBetrag("https://example.com/spenden", 500) === null,
|
|
"an einer fremden Adresse wird nichts angehaengt");
|
|
ok(mitBetrag("", 500) === null, "und an gar keiner auch nicht");
|
|
|
|
/* DIE HOECHSTE STUFE, DIE NOCH PASST. */
|
|
ok(stufeFuer(50) === null, "unter der kleinsten Stufe gibt es keine");
|
|
ok(stufeFuer(100)?.name === "Danke", `0,1 Dogen ergibt ${stufeFuer(100)?.name}`);
|
|
ok(stufeFuer(499)?.name === "Danke", "0,499 Dogen bleibt darunter");
|
|
ok(stufeFuer(500)?.name === "Starke Runde", `0,5 Dogen ergibt ${stufeFuer(500)?.name}`);
|
|
ok(stufeFuer(5000)?.name === "Rudel-Legende", `5 Dogen ergibt ${stufeFuer(5000)?.name}`);
|
|
}
|
|
|
|
/* =======================================================================
|
|
2. DIE AGENTUR KENNT DIE SPENDEN NICHT
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 2. Getrennte Haeuser ===");
|
|
{
|
|
const kCreator = await anmelden("creator", AGENTUR);
|
|
ok(!!kCreator, "eine Creatorin meldet sich im Agenturhaus an");
|
|
const a = await roh(AGENTUR, "/workspace/api/spenden", { keks: kCreator });
|
|
ok(a.code === 404, `und sieht die Spenden nicht (${a.code})`);
|
|
|
|
/* GEGENPROBE: Im eigenen Haus geht derselbe Weg. Sonst koennte die
|
|
404 auch daran liegen, dass es den Weg gar nicht gibt. */
|
|
const b = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
ok(b.code === 200, `im Teamhaus schon (${b.code})`);
|
|
}
|
|
|
|
/* =======================================================================
|
|
3. DIE BETRAGSKNOEPFE
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 3. Die Betragsknoepfe ===");
|
|
{
|
|
const ohne = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
ok(Array.isArray(ohne.j?.knoepfe) && ohne.j.knoepfe.length === 0,
|
|
`ohne hinterlegte Adresse gibt es keine Knoepfe (${ohne.j?.knoepfe?.length})`);
|
|
ok(ohne.j?.paypal === null, "und auch keinen Weg");
|
|
|
|
/* Jetzt eine eintragen -- ueber den echten Weg, nicht in die
|
|
Datenbank. Genau diese Pruefungen sollen ja mitlaufen. */
|
|
const wege = await roh(CREW, "/workspace/api/unterstuetzung", { keks: k.admin });
|
|
const pp = (wege.j?.wege || wege.j?.liste || []).find((w) => w.schluessel === "paypal");
|
|
ok(!!pp, "der PayPal-Weg steht in der Unterstuetzen-Liste");
|
|
await roh(CREW, `/workspace/api/unterstuetzung/${pp.id}`, {
|
|
method: "PUT", keks: k.admin,
|
|
rumpf: { ziel: "https://paypal.me/probehase", knopf: "Dogi was ausgeben", sichtbar: true },
|
|
});
|
|
|
|
const mit = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
ok(mit.j?.knoepfe?.length === 4, `jetzt gibt es vier (${mit.j?.knoepfe?.length})`);
|
|
ok(mit.j?.knoepfe?.[0]?.ziel === "https://paypal.me/probehase/2EUR",
|
|
`mit dem Betrag in der Adresse (${mit.j?.knoepfe?.[0]?.ziel})`);
|
|
ok(mit.j?.paypal?.knopf === "Dogi was ausgeben",
|
|
"und die Aufschrift kommt von der Unterstuetzen-Seite");
|
|
|
|
/* WER NICHT DIE LEITUNG IST, SIEHT KEINE FREMDEN BETRAEGE. */
|
|
ok(mit.j?.offen === null && mit.j?.letzte === null,
|
|
"ein Zuschauer bekommt die Liste fremder Spenden NICHT");
|
|
const alsChef = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
ok(Array.isArray(alsChef.j?.offen), "die Leitung schon");
|
|
}
|
|
|
|
/* =======================================================================
|
|
4. MELDEN — EINE BEHAUPTUNG, KEINE TATSACHE
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 4. Melden ===");
|
|
{
|
|
const mist = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast, rumpf: { dogen_mille: 0 },
|
|
});
|
|
ok(mist.code === 400 && mist.j?.fehler === "betrag_unklar",
|
|
`null Euro ist kein Betrag (${mist.code}/${mist.j?.fehler})`);
|
|
const zuViel = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast, rumpf: { dogen_mille: 99999999 },
|
|
});
|
|
ok(zuViel.code === 400, `und eine Million auch nicht (${zuViel.code})`);
|
|
|
|
const a = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast, rumpf: { dogen_mille: 1500, gruss: "Danke fuer alles" },
|
|
});
|
|
ok(a.code === 201 && a.j?.wartet === true,
|
|
`die Meldung wird angenommen -- und sie WARTET (${a.code})`);
|
|
|
|
/* EINE JE MINUTE. Nicht gegen Betrug -- die Leitung bestaetigt ja
|
|
-- sondern gegen den Doppelklick und gegen eine Liste, die man
|
|
nicht mehr durchsieht. */
|
|
const zweite = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast, rumpf: { dogen_mille: 1500 },
|
|
});
|
|
ok(zweite.code === 429, `zweimal in derselben Minute nicht (${zweite.code})`);
|
|
|
|
const beiDerLeitung = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
const wartet = (beiDerLeitung.j?.offen || [])[0];
|
|
ok(wartet?.dogen_mille === 1500 && wartet?.stand === "offen",
|
|
`sie steht im Pult und wartet (${wartet?.dogen_mille} Tausendstel, ${wartet?.stand})`);
|
|
ok(wartet?.name === "Nachtfalter", `mit dem Namen der Person (${wartet?.name})`);
|
|
ok(wartet?.stufe?.name === "Starke Runde",
|
|
`und der Stufe, die zum Betrag passt (${wartet?.stufe?.name})`);
|
|
|
|
const beiIhr = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
ok(beiIhr.j?.offen === null, "sie selbst bekommt keine Liste");
|
|
}
|
|
|
|
/* =======================================================================
|
|
5. NUR DIE LEITUNG ENTSCHEIDET
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 5. Wer ueber Geld entscheidet ===");
|
|
{
|
|
const offen = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
const id = offen.j.offen[0].id;
|
|
|
|
for (const rolle of ["linke", "modi", "gast"]) {
|
|
const a = await roh(CREW, `/workspace/api/spenden/${id}/bestaetigen`, {
|
|
method: "POST", keks: k[rolle],
|
|
});
|
|
ok(a.code === 403 && a.j?.fehler === "nur_leitung",
|
|
`${rolle}: bestaetigt nichts (${a.code}/${a.j?.fehler})`);
|
|
const b = await roh(CREW, "/workspace/api/spenden", {
|
|
method: "POST", keks: k[rolle], rumpf: { dogen_mille: 100, name: "X" },
|
|
});
|
|
ok(b.code === 403, `${rolle}: traegt auch nichts ein (${b.code})`);
|
|
}
|
|
|
|
/* DER BETRAG DARF BEIM BESTAETIGEN BERICHTIGT WERDEN. Die Leitung
|
|
hat die PayPal-Meldung vor sich und weiss es besser als die
|
|
Behauptung. */
|
|
const ja = await roh(CREW, `/workspace/api/spenden/${id}/bestaetigen`, {
|
|
method: "POST", keks: k.hand, rumpf: { dogen_mille: 1200 },
|
|
});
|
|
ok(ja.code === 200 && ja.j?.stand === "bestaetigt" && ja.j?.dogen_mille === 1200,
|
|
`die rechte Hand bestaetigt und berichtigt (${ja.j?.dogen_mille} Tausendstel)`);
|
|
|
|
/* ZWEIMAL BESTAETIGEN IST KEIN FEHLER -- aber auch kein Grund, die
|
|
Karte noch einmal zu zeigen. Zwei Leute tippen gleichzeitig. */
|
|
const nochmal = await roh(CREW, `/workspace/api/spenden/${id}/bestaetigen`, {
|
|
method: "POST", keks: k.admin,
|
|
});
|
|
ok(nochmal.code === 200 && nochmal.j?.dogen_mille === 1200,
|
|
"ein zweites Mal aendert nichts und ist kein Fehler");
|
|
|
|
const danach = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
ok((danach.j?.offen || []).length === 0, "danach wartet nichts mehr");
|
|
ok((danach.j?.letzte || []).some((z) => z.id === id), "und sie steht bei den gezeigten");
|
|
}
|
|
|
|
/* =======================================================================
|
|
6. VON HAND EINTRAGEN — DER WEG, DER IMMER GEHT
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 6. Von Hand eintragen ===");
|
|
{
|
|
const ohneName = await roh(CREW, "/workspace/api/spenden", {
|
|
method: "POST", keks: k.admin, rumpf: { dogen_mille: 500 },
|
|
});
|
|
ok(ohneName.code === 400 && ohneName.j?.fehler === "name_fehlt",
|
|
`ohne Namen keine Karte -- er steht ja darauf (${ohneName.code})`);
|
|
|
|
const a = await roh(CREW, "/workspace/api/spenden", {
|
|
method: "POST", keks: k.admin,
|
|
rumpf: { dogen_mille: 5000, name: "Miss", gruss: "Weiter so!" },
|
|
});
|
|
ok(a.code === 201 && a.j?.stand === "bestaetigt",
|
|
`eingetragen gilt sofort (${a.code}/${a.j?.stand})`);
|
|
ok(a.j?.stufe?.name === "Rudel-Legende" && a.j?.stufe?.dauer_ms === 11000,
|
|
`mit der hoechsten Stufe und ihrer Dauer (${a.j?.stufe?.name}, ${a.j?.stufe?.dauer_ms} ms)`);
|
|
|
|
const wieder = await roh(CREW, `/workspace/api/spenden/${a.j.id}/nochmal`, {
|
|
method: "POST", keks: k.admin,
|
|
});
|
|
ok(wieder.code === 200, `und laesst sich noch einmal zeigen (${wieder.code})`);
|
|
const ablehnen = await roh(CREW, `/workspace/api/spenden/${a.j.id}/ablehnen`, {
|
|
method: "POST", keks: k.admin,
|
|
});
|
|
ok(ablehnen.code === 409 && ablehnen.j?.fehler === "nicht_offen",
|
|
`was schon lief, laesst sich nicht mehr ablehnen (${ablehnen.code})`);
|
|
}
|
|
|
|
/* =======================================================================
|
|
7. DIESELBE ZAHLUNG NUR EINMAL
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 7. Keine Spende zweimal ===");
|
|
{
|
|
/* Ein Webhook wird bei einer Stoerung wiederholt. Ohne diese
|
|
Sperre stuende dieselbe Spende zweimal im Bild -- und zwar
|
|
ausgerechnet dann, wenn das Netz hakt. */
|
|
const { DatabaseSync: DB2 } = await import("node:sqlite");
|
|
const d2 = new DB2(process.env.WORKSPACE_DB);
|
|
const nun = new Date().toISOString();
|
|
const rein = (nummer) => d2.prepare(
|
|
"INSERT INTO spenden (betrag_cent, waehrung, name, herkunft, stand, fremd_id, erstellt)"
|
|
+ " VALUES (?,?,?,?,?,?,?)").run(300, "EUR", "Webhook", "paypal", "bestaetigt", nummer, nun);
|
|
|
|
rein("PAY-1");
|
|
let zweimal = false;
|
|
try { rein("PAY-1"); zweimal = true; } catch { /* genau so soll es sein */ }
|
|
ok(!zweimal, "dieselbe Zahlungsnummer laesst sich kein zweites Mal eintragen");
|
|
|
|
/* GEGENPROBE: Ohne Nummer duerfen beliebig viele nebeneinander
|
|
stehen -- sonst koennte man nur eine Spende von Hand eintragen. */
|
|
let ohneNummer = 0;
|
|
for (let i = 0; i < 3; i++) {
|
|
d2.prepare("INSERT INTO spenden (betrag_cent, waehrung, name, herkunft, stand, erstellt)"
|
|
+ " VALUES (?,?,?,?,?,?)").run(100, "EUR", "Ohne", "hand", "bestaetigt", nun);
|
|
ohneNummer++;
|
|
}
|
|
ok(ohneNummer === 3, "Gegenprobe: ohne Nummer stehen beliebig viele nebeneinander");
|
|
d2.close();
|
|
}
|
|
|
|
|
|
/* =======================================================================
|
|
8. DIE GESTALTUNG
|
|
|
|
Filipe: „mach paar fertige und so dass ich auch hochladen kann.
|
|
auch so dass ich das anders gestalten kann oder die groesse
|
|
veraendern kann. ... auch spezielle sachen bei speziellen spenden."
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 8. Die Gestaltung der Karten ===");
|
|
{
|
|
/* Wie viele Spenden es gibt -- gebraucht fuer den Nachweis, dass
|
|
die Probe KEINE anlegt. Gezaehlt wird in der Datenbank und nicht
|
|
in einer Liste der Oberflaeche: Eine Liste zeigt nur, was sie
|
|
zeigen soll. */
|
|
const { DatabaseSync: DBZ } = await import("node:sqlite");
|
|
const dz = new DBZ(process.env.WORKSPACE_DB, { readOnly: true });
|
|
const zaehle = () => dz.prepare("SELECT COUNT(*) AS n FROM spenden").get().n;
|
|
|
|
const { VORLAGEN, STUFEN_MAX, GROESSE_MIN, GROESSE_MAX, DAUER_MS_MIN, DAUER_MS_MAX }
|
|
= await import("./spenden-tabellen.js");
|
|
|
|
/* ---- Die Vorlagen sind an BEIDEN Enden dieselben ----
|
|
Ein Name, den nur eine Seite kennt, waere eine Vorlage, die sich
|
|
auswaehlen laesst und dann als Herz erscheint. */
|
|
{
|
|
const karte = readFileSync(
|
|
join(HIER, "..", "workspace", "assets", "js", "spendenkarte.js"), "utf8");
|
|
const block = karte.match(/const VORLAGEN = \{([\s\S]*?)\n \};/);
|
|
const inKarte = [...(block ? block[1] : "").matchAll(/^\s{4}([a-z]+):/gm)].map((m) => m[1]);
|
|
ok(inKarte.length >= 5, `die Karte kennt ${inKarte.length} Zeichnungen`);
|
|
/* „dogen" IST EINE VORLAGE, ABER KEINE ZEICHNUNG. Sie zeigt
|
|
die Muenze des gewaehlten Satzes und steht deshalb nicht im
|
|
Zeichnungsblock -- verglichen wird ohne sie. Dass die Karte
|
|
sie trotzdem behandelt, prueft die Zeile darunter: Ohne sie
|
|
waere „dogen" eine Auswahl, die als Herz erscheint. */
|
|
const zeichnungen = VORLAGEN.filter((v) => v !== "dogen");
|
|
const fehlt = zeichnungen.filter((v) => !inKarte.includes(v));
|
|
const zuviel = inKarte.filter((v) => !zeichnungen.includes(v));
|
|
ok(fehlt.length === 0 && zuviel.length === 0,
|
|
(fehlt.length || zuviel.length)
|
|
? `UNGLEICH: fehlt ${fehlt.join(",")} / zuviel ${zuviel.join(",")}`
|
|
: `Server und Karte kennen dieselben ${zeichnungen.length} Zeichnungen`);
|
|
ok(VORLAGEN.includes("dogen") && /vorlage === 'dogen'/.test(karte),
|
|
"und die Karte behandelt die Muenze als eigene Vorlage");
|
|
ok(!VORLAGEN.includes("wolke"), "Gegenprobe: eine erfundene Zeichnung steht in keiner Liste");
|
|
}
|
|
|
|
/* ---- Wer gestalten darf ---- */
|
|
const guteLeiter = {
|
|
stufen: [
|
|
{ ab_mille: 100, name: "Danke", vorlage: "herz", farbe: "#8ec9ff", dauer_ms: 6000, groesse: 1 },
|
|
{ ab_mille: 2000, name: "Legende", vorlage: "krone", farbe: "#e0a13a", dauer_ms: 11000, groesse: 1.45 },
|
|
],
|
|
};
|
|
for (const rolle of ["linke", "modi", "gast"]) {
|
|
const a = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k[rolle], rumpf: guteLeiter,
|
|
});
|
|
ok(a.code === 403, `${rolle}: gestaltet nicht (${a.code})`);
|
|
}
|
|
|
|
/* ---- Was eine Leiter sein muss ---- */
|
|
const schlecht = [
|
|
[{ stufen: [] }, 400, "keine_stufe", "eine leere Leiter"],
|
|
[{ stufen: null }, 400, "stufen_fehlen", "gar keine Leiter"],
|
|
[{ stufen: Array.from({ length: STUFEN_MAX + 1 }, (x, i) => ({
|
|
ab_mille: (i + 1) * 100, name: `S${i}`, vorlage: "herz",
|
|
farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 })) }, 400, "zu_viele_stufen",
|
|
`${STUFEN_MAX + 1} Stufen`],
|
|
[{ stufen: [{ ab_mille: 0, name: "X", vorlage: "herz", farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 }] },
|
|
400, "stufe_betrag_unklar", "null Dogen"],
|
|
[{ stufen: [{ ab_mille: 100, name: " ", vorlage: "herz", farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 }] },
|
|
400, "stufe_name_fehlt", "ein leerer Name"],
|
|
[{ stufen: [{ ab_mille: 100, name: "X", vorlage: "wolke", farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 }] },
|
|
400, "vorlage_unbekannt", "eine erfundene Zeichnung"],
|
|
/* DIE FARBE IST DIE HEIKELSTE STELLE: Sie landet als CSS-Wert in
|
|
der Karte. Ein freier Text waere dort eine Einschleusung. */
|
|
[{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz",
|
|
farbe: "red; background:url(javascript:1)", dauer_ms: 5000, groesse: 1 }] },
|
|
400, "farbe_unklar", "eine eingeschleuste Farbe"],
|
|
[{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "blau", dauer_ms: 5000, groesse: 1 }] },
|
|
400, "farbe_unklar", "ein Farbwort"],
|
|
[{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "#8ec9ff",
|
|
dauer_ms: DAUER_MS_MAX + 1000, groesse: 1 }] }, 400, "dauer_unklar", "zu lange"],
|
|
[{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "#8ec9ff",
|
|
dauer_ms: DAUER_MS_MIN - 500, groesse: 1 }] }, 400, "dauer_unklar", "zu kurz"],
|
|
[{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "#8ec9ff",
|
|
dauer_ms: 5000, groesse: GROESSE_MAX + 1 }] }, 400, "groesse_unklar", "zu gross"],
|
|
[{ stufen: [{ ab_mille: 100, name: "X", vorlage: "herz", farbe: "#8ec9ff",
|
|
dauer_ms: 5000, groesse: GROESSE_MIN - 0.5 }] }, 400, "groesse_unklar", "zu klein"],
|
|
[{ stufen: [
|
|
{ ab_mille: 500, name: "A", vorlage: "herz", farbe: "#8ec9ff", dauer_ms: 5000, groesse: 1 },
|
|
{ ab_mille: 500, name: "B", vorlage: "welle", farbe: "#a98bff", dauer_ms: 5000, groesse: 1 },
|
|
] }, 409, "stufe_doppelt", "zwei Stufen beim selben Betrag"],
|
|
];
|
|
for (const [rumpf, code, wort, was] of schlecht) {
|
|
const a = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf,
|
|
});
|
|
ok(a.code === code && a.j?.fehler === wort,
|
|
`${was} wird abgelehnt (${a.code}/${a.j?.fehler})`);
|
|
}
|
|
|
|
/* NACH ALL DEN ABLEHNUNGEN MUSS DIE ALTE LEITER NOCH STEHEN.
|
|
Eine Pruefung, die nur den Fehlercode ansieht, uebersieht genau
|
|
das: Ein Abbruch mitten im Schreiben haette die Leiter halb
|
|
geleert zurueckgelassen -- und dann faellt in der naechsten
|
|
Sendung eine Spende in gar keine Stufe. */
|
|
const heil = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
ok((heil.j?.stufen || []).length >= 3,
|
|
`die alte Leiter steht unveraendert (${heil.j?.stufen?.length} Stufen)`);
|
|
|
|
/* ---- Und was geht ---- */
|
|
const gut = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf: guteLeiter,
|
|
});
|
|
ok(gut.code === 200 && gut.j?.stufen?.length === 2,
|
|
`zwei Stufen werden gespeichert (${gut.code})`);
|
|
ok(gut.j?.stufen?.[0]?.ab_mille === 100 && gut.j?.stufen?.[1]?.ab_mille === 2000,
|
|
"und stehen aufsteigend");
|
|
ok(gut.j?.stufen?.[1]?.groesse === 1.45,
|
|
`die Groesse kommt an (${gut.j?.stufen?.[1]?.groesse})`);
|
|
|
|
/* ---- UMSORTIEREN MUSS GEHEN ----
|
|
`ab_cent` ist eindeutig. Wer zwei vorhandene Stufen ihre Betraege
|
|
TAUSCHEN laesst, stoesst beim Umschreiben auf sich selbst --
|
|
obwohl das Ergebnis voellig in Ordnung waere. Gemessen ist genau
|
|
das passiert („UNIQUE constraint failed"), und der ganze Vorgang
|
|
brach mit 503 ab. */
|
|
{
|
|
const jetzige = gut.j.stufen;
|
|
const getauscht = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin,
|
|
rumpf: { stufen: [
|
|
{ ...jetzige[0], ab_mille: 2000 },
|
|
{ ...jetzige[1], ab_mille: 100 },
|
|
] },
|
|
});
|
|
ok(getauscht.code === 200, `zwei Stufen tauschen ihre Betraege (${getauscht.code})`);
|
|
ok(getauscht.j?.stufen?.[0]?.name === jetzige[1].name,
|
|
`und die Leiter steht richtig herum (${getauscht.j?.stufen?.[0]?.name})`);
|
|
/* Und wieder zurueck -- der Rest des Abschnitts rechnet damit. */
|
|
await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf: { stufen: jetzige },
|
|
});
|
|
}
|
|
|
|
/* SPEZIELLE SACHEN BEI SPEZIELLEN SPENDEN: Die Stufe entscheidet
|
|
sich am Betrag, und zwar immer die hoechste passende. */
|
|
const { stufeFuer } = await import("./workspace-spenden.js");
|
|
ok(stufeFuer(100)?.name === "Danke", "0,1 Dogen -> Danke");
|
|
ok(stufeFuer(1999)?.name === "Danke", "1,999 Dogen -> immer noch Danke");
|
|
ok(stufeFuer(2000)?.name === "Legende", "2 Dogen -> Legende");
|
|
ok(stufeFuer(50000)?.name === "Legende", "50 Dogen -> Legende");
|
|
ok(stufeFuer(99) === null, "unter der ersten Stufe gibt es keine");
|
|
|
|
/* ---- Die Probe legt KEINE Spende an ----
|
|
Der naheliegende Weg waere gewesen, eine Spende einzutragen und
|
|
danach zu loeschen. In ein laufendes System kommen keine
|
|
Testdaten -- und „geloescht" heisst bei Geld nicht „war nie da". */
|
|
const vorher = zaehle();
|
|
const probe = await roh(CREW, "/workspace/api/spenden/probe", {
|
|
method: "POST", keks: k.admin, rumpf: { dogen_mille: 2000 },
|
|
});
|
|
ok(probe.code === 200 && probe.j?.karte?.stufe?.name === "Legende",
|
|
`die Probe zeigt die richtige Stufe (${probe.j?.karte?.stufe?.name})`);
|
|
ok(probe.j?.karte?.stand === "probe", "und ist als Probe gekennzeichnet");
|
|
ok(zaehle() === vorher,
|
|
`und es entsteht KEINE Spende daraus (${vorher} -> ${zaehle()})`);
|
|
const probeNein = await roh(CREW, "/workspace/api/spenden/probe", {
|
|
method: "POST", keks: k.modi, rumpf: { dogen_mille: 2000 },
|
|
});
|
|
ok(probeNein.code === 403, `ein Modi probiert nicht (${probeNein.code})`);
|
|
|
|
/* ---- Das Bild ---- */
|
|
const id = gut.j.stufen[1].id;
|
|
const keinBild = await roh(CREW, `/workspace/api/spenden/stufe/${id}/bild`, {
|
|
method: "POST", keks: k.admin, roher: Buffer.from("das ist kein Bild"),
|
|
});
|
|
ok(keinBild.code === 400 && keinBild.j?.fehler === "kein_bild",
|
|
`Text statt Bild wird abgelehnt (${keinBild.code})`);
|
|
|
|
/* EIN ECHTES PNG -- der kleinste gueltige, den es gibt. Ein
|
|
erfundener Kopf wuerde nur beweisen, dass die Pruefung dieselbe
|
|
Annahme macht wie der Code. */
|
|
const png = Buffer.from(
|
|
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==",
|
|
"base64");
|
|
const hoch = await roh(CREW, `/workspace/api/spenden/stufe/${id}/bild`, {
|
|
method: "POST", keks: k.admin, roher: png,
|
|
});
|
|
ok(hoch.code === 200 && /^\/workspace\/api\/buehne\/spendenbild\/[a-f0-9]{32}\.png$/
|
|
.test(hoch.j?.bild || ""), `ein PNG wird angenommen (${hoch.j?.bild})`);
|
|
|
|
/* DAS BILD MUSS OHNE ANMELDUNG ZU HOLEN SEIN. Die Spendentafel in
|
|
OBS hat keine Sitzung -- ein 401 als JSON in einem <img> ergibt
|
|
ein kaputtes Bild ohne jeden Hinweis. */
|
|
const ohne = await roh(CREW, hoch.j.bild, {});
|
|
ok(ohne.code === 200, `und ohne Anmeldung abrufbar (${ohne.code})`);
|
|
ok(String(ohne.kopf["content-type"]).startsWith("image/png"),
|
|
`als Bild und nicht als etwas anderes (${ohne.kopf["content-type"]})`);
|
|
ok(ohne.kopf["x-content-type-options"] === "nosniff",
|
|
"der Browser darf den Typ nicht selbst raten");
|
|
|
|
/* KEIN AUSBRUCH AUS DEM ORDNER.
|
|
GEPRUEFT WIRD, WAS HERAUSKOMMT -- nicht, welche Zahl dabeisteht.
|
|
„../../workspace.db" wird vom Server zu „/workspace/api/workspace.db"
|
|
zusammengefaltet, bevor diese Route ueberhaupt drankommt; die
|
|
Antwort ist dann 401 von einer ganz anderen Stelle. Auf 404 zu
|
|
bestehen hiesse, eine Nebensaechlichkeit zu pruefen und den
|
|
eigentlichen Punkt zu verfehlen: Es darf keine Datei
|
|
herauskommen. */
|
|
for (const boes of ["../../workspace.db", "..%2f..%2fworkspace.db",
|
|
"%2e%2e%2f%2e%2e%2fworkspace.db", "nicht-vorhanden.png"]) {
|
|
const a = await roh(CREW, `/workspace/api/buehne/spendenbild/${boes}`, {});
|
|
ok(a.code !== 200 && !a.text.includes("SQLite format"),
|
|
`„${boes}" liefert keine Datei (${a.code})`);
|
|
}
|
|
/* GEGENPROBE: Die richtige Adresse liefert sehr wohl etwas --
|
|
sonst waere die Pruefung oben eine, die immer bestaetigt. */
|
|
{
|
|
const a = await roh(CREW, hoch.j.bild, {});
|
|
ok(a.code === 200 && a.text.length > 0,
|
|
"Gegenprobe: die richtige Adresse liefert das Bild");
|
|
}
|
|
|
|
/* DAS BILD UEBERLEBT DAS NAECHSTE SPEICHERN. Wer nur den Namen
|
|
aendert, soll sein Bild nicht verlieren. */
|
|
const nochmal = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin,
|
|
rumpf: { stufen: gut.j.stufen.map((z) => ({ ...z, name: z.name + "!" })) },
|
|
});
|
|
const jetztBild = (nochmal.j?.stufen || []).find((z) => z.ab_mille === 2000)?.bild;
|
|
ok(jetztBild === hoch.j.bild,
|
|
`nach dem Umbenennen haengt das Bild noch dran (${jetztBild ? "ja" : "nein"})`);
|
|
|
|
/* DIE KENNUNG MUSS DAS SPEICHERN UEBERLEBT HABEN. Vorher wurde
|
|
beim Speichern geloescht und neu eingefuegt -- jede Stufe bekam
|
|
dabei eine neue Kennung, und ein Bild-Hochladen gegen die eben
|
|
noch gueltige antwortete mit 404. Im Alltag trifft das jeden,
|
|
der einen zweiten Bildschirm offen hat. */
|
|
const nachId = (nochmal.j?.stufen || []).find((z) => z.ab_mille === 2000)?.id;
|
|
ok(nachId === id, `die Kennung bleibt ueber das Speichern hinweg (${id} -> ${nachId})`);
|
|
|
|
const weg = await roh(CREW, `/workspace/api/spenden/stufe/${id}/bild`,
|
|
{ method: "DELETE", keks: k.admin });
|
|
ok(weg.code === 200, `das Bild laesst sich wegnehmen (${weg.code})`);
|
|
const fort = await roh(CREW, hoch.j.bild, {});
|
|
ok(fort.code === 404, `und die Datei ist danach wirklich fort (${fort.code})`);
|
|
|
|
/* ---- Was die Oberflaeche braucht, kommt vom Server ---- */
|
|
const lage2 = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
const g2 = lage2.j?.gestaltung;
|
|
ok(!!g2 && Array.isArray(g2.vorlagen) && g2.stufen_max === STUFEN_MAX
|
|
&& g2.groesse_min === GROESSE_MIN && g2.groesse_max === GROESSE_MAX,
|
|
"die Grenzen stehen im Stand und nicht nur in der Oberflaeche");
|
|
}
|
|
|
|
|
|
/* =======================================================================
|
|
9. DOGEN STATT GELD, DER EIGENE TEXT UND DIE PUNKTE
|
|
|
|
Filipe, 28.09.2026:
|
|
„mann soll nie die summe sehen sondern die dogen auch mit dem
|
|
symbol ... es soll auch nie geld da stehen sondern Dogen."
|
|
„der text der dazu erscheint sollen die leute selber schreiben
|
|
koennen ... es sollen personalisierte texte sein von den leuten
|
|
selbst."
|
|
„ich will dass die den leuten auch als punkte hinzugefuegt
|
|
werden."
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 9. Dogen, eigener Text und Punkte ===");
|
|
{
|
|
const { CENT_JE_DOGE, MILLE, centInMille, milleInCent, GRUSS_MAX, KNOEPFE_MILLE }
|
|
= await import("./spenden-tabellen.js");
|
|
|
|
/* ---- DIE RECHNUNG ----
|
|
Bewusst OHNE die Zahl 1000 in der Erwartung: Bei diesem Kurs ist
|
|
ein Tausendstel Doge zufaellig genau ein Cent, und eine Pruefung,
|
|
die auf diesem Zufall steht, wird gruen bleiben, wenn der Kurs
|
|
sich aendert -- und dann nichts mehr pruefen. */
|
|
ok(centInMille(CENT_JE_DOGE) === MILLE,
|
|
`ein ganzer Doge sind ${CENT_JE_DOGE} Cent`);
|
|
ok(milleInCent(MILLE) === CENT_JE_DOGE, "und zurueck genauso");
|
|
ok(milleInCent(centInMille(CENT_JE_DOGE * 7)) === CENT_JE_DOGE * 7,
|
|
"hin und zurueck aendert nichts");
|
|
ok(centInMille(0) === 0 && centInMille(-5) <= 0,
|
|
"Gegenprobe: null bleibt null");
|
|
|
|
/* ---- KEIN GELD IM BROWSER ----
|
|
Die wichtigste Pruefung dieses Abschnitts. Filipe hat „wirklich
|
|
nirgends" gewaehlt, und die einzige Fassung davon, die haelt,
|
|
ist: Was nicht gesendet wird, kann auch nicht angezeigt werden.
|
|
Geprueft werden deshalb die FELDNAMEN der ganzen Antwort und
|
|
nicht die Oberflaeche -- eine Oberflaeche kann man aendern,
|
|
ohne daran zu denken. */
|
|
const namen = (wert, raus = new Set()) => {
|
|
if (Array.isArray(wert)) { for (const w of wert) namen(w, raus); return raus; }
|
|
if (wert && typeof wert === "object") {
|
|
for (const [n, w] of Object.entries(wert)) { raus.add(n); namen(w, raus); }
|
|
}
|
|
return raus;
|
|
};
|
|
/* ==== ZWEI AUSNAHMEN, UND NUR DIESE ZWEI =====================
|
|
|
|
Am 28.09. stand hier „kein Geldfeld, fuer niemanden". Das war
|
|
fuer alles richtig, was ANZEIGE ist -- und falsch fuer die eine
|
|
Stelle, an der jemand KAUFT. Filipe: „die leute sollen nur
|
|
sehen was dogen kosten. sonst wissen die ja nicht wie viel es
|
|
kosten wird."
|
|
|
|
Erlaubt sind jetzt GENAU zwei Dinge, und die Pruefung nennt sie
|
|
beim Namen statt die Regel aufzuweichen:
|
|
`knoepfe[].cent` fuer alle -- der Preis am Kaufknopf
|
|
`kurs_cent_je_doge` nur fuer die Leitung
|
|
Alles andere bleibt verboten. Eine Ausnahmeliste, die man
|
|
aufzaehlen kann, ist eine Regel; „irgendwo darf Geld stehen"
|
|
waere keine. */
|
|
const ERLAUBT = new Set(["cent", "kurs_cent_je_doge"]);
|
|
for (const [wer, keks, kursErlaubt] of [
|
|
["die Leitung", k.admin, true],
|
|
["ein Zuschauer", k.gast, false],
|
|
]) {
|
|
const a = await roh(CREW, "/workspace/api/spenden", { keks });
|
|
const felder = namen(a.j);
|
|
const geld = [...felder].filter((n) => /cent|waehrung|euro|eur$/i.test(n))
|
|
.filter((n) => !ERLAUBT.has(n));
|
|
ok(geld.length === 0,
|
|
geld.length ? `UNERLAUBTES GELDFELD (${wer}): ${geld.join(", ")}`
|
|
: `kein unerlaubtes Geldfeld im Stand (${wer}, ${felder.size} Felder)`);
|
|
ok(felder.has("dogen_max_mille") && felder.has("gruss_max"),
|
|
"und die Grenzen stehen als Dogen und Zeichen darin");
|
|
|
|
/* ---- Der Preis steht am Kaufknopf -- fuer alle ---- */
|
|
const knopf = a.j?.knoepfe?.[0];
|
|
ok(typeof knopf?.cent === "number" && knopf.cent > 0,
|
|
`der Preis steht am Knopf (${wer}: ${knopf?.cent} Cent)`);
|
|
|
|
/* ---- Und der Kurs nur bei der Leitung ----
|
|
Er ist der Generalschluessel: Wer ihn hat, kann JEDEN
|
|
Dogenwert in Geld umrechnen. Genau deshalb steckt die
|
|
Erlaubnis in den Daten und nicht in einem `if` der
|
|
Oberflaeche -- eine fehlende Zahl kann man nicht vergessen. */
|
|
const kurs = a.j?.kurs_cent_je_doge;
|
|
ok(kursErlaubt ? typeof kurs === "number" && kurs > 0 : kurs === null,
|
|
`der Kurs ${kursErlaubt ? "kommt mit" : "bleibt weg"} (${wer}: ${kurs})`);
|
|
|
|
/* Ausser an den Knoepfen darf nirgends ein Eurozeichen stehen --
|
|
auch nicht in einem Text, den jemand eingetippt hat. */
|
|
const ohneKnoepfe = { ...a.j, knoepfe: undefined };
|
|
ok(!JSON.stringify(ohneKnoepfe).includes("€"), `kein Eurozeichen (${wer})`);
|
|
}
|
|
ok([...namen({ a: [{ betrag_cent: 1 }] })].includes("betrag_cent"),
|
|
"Gegenprobe: ein Geldfeld wuerde gefunden");
|
|
|
|
/* ==== DIE KARTE TRAEGT WEITERHIN KEINEN CENT ==================
|
|
Sie geht auch an die Buehnentafel, und die steht im Stream. Ein
|
|
Betrag, der dort ankommt, waere Geld im Bild -- genau das, was
|
|
nirgends stehen soll. Der Preis gehoert an den Kaufknopf und
|
|
nirgendwo sonst. */
|
|
{
|
|
const probe = await roh(CREW, "/workspace/api/spenden/probe", {
|
|
method: "POST", keks: k.admin, rumpf: { dogen_mille: 500 },
|
|
});
|
|
const felder = namen(probe.j?.karte);
|
|
const geld = [...felder].filter((n) => /cent|waehrung|euro|eur$/i.test(n));
|
|
ok(geld.length === 0,
|
|
geld.length ? `GELD AUF DER KARTE: ${geld.join(", ")}`
|
|
: `die Karte traegt keinen Betrag (${felder.size} Felder)`);
|
|
}
|
|
|
|
/* ---- DIE KNOEPFE FUEHREN ZU EINEM EURO-BETRAG, ZEIGEN ABER DOGEN ----
|
|
Der Euro entsteht erst in der PayPal-Adresse, weil PayPal ihn
|
|
braucht. Das ist der einzige Ort, an dem er ueberhaupt noch
|
|
auftaucht. */
|
|
{
|
|
const a = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
const knopf = a.j?.knoepfe?.[0];
|
|
ok(knopf?.mille === KNOEPFE_MILLE[0],
|
|
`der erste Knopf steht auf ${knopf?.mille} Tausendsteln`);
|
|
ok(knopf?.ziel?.endsWith("EUR"),
|
|
`und fuehrt zu einer Zahlung (${knopf?.ziel})`);
|
|
/* ==== UND DER PREIS STEHT DABEI ============================
|
|
Hier stand bis zum 28.09. das Gegenteil: „der Euro-Betrag
|
|
selbst kommt nicht mit". Das war die Regel „nie Geld", bis
|
|
eine Stelle ihr widersprach -- die einzige, an der jemand
|
|
BEZAHLT. Wer auf „0,2 Dogen" drueckt, muss vorher wissen,
|
|
dass ihn das zwei Euro kostet; den Preis erst auf der
|
|
Zahlseite zu erfahren ist keiner.
|
|
Die Zahl muss zur Adresse PASSEN -- sonst steht am Knopf ein
|
|
Preis und bei PayPal ein anderer, und das merkt niemand
|
|
vorher. */
|
|
ok(knopf?.cent === milleInCent(knopf?.mille),
|
|
`und der Preis dazu (${knopf?.cent} Cent) passt zur Zahlung`);
|
|
}
|
|
|
|
/* ---- DER TEXT KOMMT VON DEM, DER GIBT ---- */
|
|
const langer = "A".repeat(GRUSS_MAX + 60);
|
|
/* Die Bremse von einer Meldung je Minute gilt je Person -- deshalb
|
|
meldet hier der ZWEITE Gast. */
|
|
const gemeldet = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast2,
|
|
rumpf: { dogen_mille: 700, name: "Lenny vom Rudel", gruss: langer },
|
|
});
|
|
ok(gemeldet.code === 201, `ein Zuschauer meldet mit eigenem Text (${gemeldet.code})`);
|
|
const wartend = (await roh(CREW, "/workspace/api/spenden", { keks: k.admin }))
|
|
.j?.offen?.find((z) => z.name === "Lenny vom Rudel");
|
|
ok(!!wartend, "die Meldung steht im Pult");
|
|
ok(wartend?.gruss?.length === GRUSS_MAX,
|
|
`ein zu langer Text wird auf ${GRUSS_MAX} gekuerzt (${wartend?.gruss?.length})`);
|
|
ok(wartend?.dogen_mille === 700, `und traegt Dogen (${wartend?.dogen_mille})`);
|
|
|
|
/* ---- DIE LEITUNG DARF IHN BERICHTIGEN ----
|
|
Das ist die Schranke vor dem Stream. Ohne sie bliebe nur „ganz
|
|
ablehnen" -- und dann faellt wegen eines Wortes eine echte
|
|
Spende unter den Tisch. */
|
|
const berichtigt = await roh(CREW, `/workspace/api/spenden/${wartend.id}/bestaetigen`, {
|
|
method: "POST", keks: k.admin,
|
|
rumpf: { name: "Lenny", gruss: "Bleibt so" },
|
|
});
|
|
ok(berichtigt.code === 200 && berichtigt.j?.name === "Lenny"
|
|
&& berichtigt.j?.gruss === "Bleibt so",
|
|
`Name und Text lassen sich beim Bestaetigen aendern (${berichtigt.j?.gruss})`);
|
|
ok(berichtigt.j?.dogen_mille === 700,
|
|
"und der Betrag bleibt dabei stehen, wenn keiner mitkommt");
|
|
|
|
/* ---- DIE PUNKTE ----
|
|
Gemessen werden UNTERSCHIEDE und keine absoluten Staende: Vor
|
|
diesem Abschnitt sind schon Spenden durchgelaufen, und eine
|
|
Pruefung, die eine feste Zahl erwartet, bricht beim naechsten
|
|
Test, der davor eingefuegt wird. */
|
|
const standVon = async (keks) =>
|
|
(await roh(CREW, "/workspace/api/spenden", { keks })).j?.ich?.dogen_mille ?? -1;
|
|
|
|
const lenny = await standVon(k.gast2);
|
|
ok(lenny === 700, `die bestaetigte Meldung wurde gutgeschrieben (${lenny})`);
|
|
|
|
/* NOCHMAL ZEIGEN DARF NICHT NOCHMAL GUTSCHREIBEN. Die Sperre ist
|
|
ein eindeutiger Index in der Datenbank und keine Bedingung im
|
|
Programm -- deshalb wird sie hier auch wirklich angegriffen. */
|
|
await roh(CREW, `/workspace/api/spenden/${wartend.id}/nochmal`,
|
|
{ method: "POST", keks: k.admin });
|
|
await roh(CREW, `/workspace/api/spenden/${wartend.id}/bestaetigen`,
|
|
{ method: "POST", keks: k.admin });
|
|
ok(await standVon(k.gast2) === lenny,
|
|
"nochmal zeigen und nochmal bestaetigen aendern nichts daran");
|
|
|
|
/* ---- VON HAND, MIT UND OHNE PERSON ---- */
|
|
const vorher = await standVon(k.gast2);
|
|
const mitPerson = await roh(CREW, "/workspace/api/spenden", {
|
|
method: "POST", keks: k.admin,
|
|
rumpf: { dogen_mille: 300, name: "Lenny", person_id: IDS.gast2 },
|
|
});
|
|
ok(mitPerson.code === 201, `von Hand mit Person (${mitPerson.code})`);
|
|
ok(await standVon(k.gast2) === vorher + 300,
|
|
`die Dogen landen bei der Person (${vorher} -> ${await standVon(k.gast2)})`);
|
|
|
|
const ohnePerson = await roh(CREW, "/workspace/api/spenden", {
|
|
method: "POST", keks: k.admin,
|
|
rumpf: { dogen_mille: 400, name: "Irgendwer vom Handy" },
|
|
});
|
|
ok(ohnePerson.code === 201, "von Hand ohne Person geht auch");
|
|
ok(await standVon(k.gast2) === vorher + 300,
|
|
"und schreibt niemandem etwas gut -- geratene Punkte waeren schlimmer als keine");
|
|
|
|
/* ---- UND NICHT UEBER DIE HAUSGRENZE ----
|
|
`creator` gehoert der Agentur. Eine Gutschrift dorthin waere
|
|
genau die Vermischung, die seit dem 24.09. nicht mehr sein darf
|
|
-- auch nicht durch einen Tippfehler in einer Zahl. */
|
|
const fremd = await roh(CREW, "/workspace/api/spenden", {
|
|
method: "POST", keks: k.admin,
|
|
rumpf: { dogen_mille: 100, name: "X", person_id: IDS.creator },
|
|
});
|
|
ok(fremd.code === 400 && fremd.j?.fehler === "person_unbekannt",
|
|
`eine Person aus dem anderen Haus wird abgelehnt (${fremd.code})`);
|
|
|
|
/* ---- WER DIE STAENDE SIEHT ----
|
|
Filipe hat „jeder nur seine eigenen, du alle" gewaehlt. Eine
|
|
oeffentliche Rangliste macht aus Unterstuetzung einen
|
|
Wettbewerb, und wer wenig geben kann, staende jeden Abend
|
|
darin. */
|
|
const alsLeitung = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
const alsGast = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
ok(Array.isArray(alsLeitung.j?.staende) && alsLeitung.j.staende.length > 0,
|
|
`die Leitung sieht ${alsLeitung.j?.staende?.length} Staende`);
|
|
ok(alsGast.j?.staende === null, "ein Zuschauer sieht keine Rangliste");
|
|
ok(alsGast.j?.personen === null, "und auch keine Namensliste");
|
|
ok(typeof alsGast.j?.ich?.dogen_mille === "number",
|
|
`aber seinen eigenen Stand (${alsGast.j?.ich?.dogen_mille})`);
|
|
ok(alsLeitung.j.staende.every((z) => typeof z.mille === "number" && z.mille !== 0),
|
|
"und in der Liste steht nur, wer wirklich etwas hat");
|
|
|
|
/* ---- DAS ZEICHEN ---- */
|
|
/* SEIT DEM 28.09. IST `zeichen` EINE AUSWAHL UND KEINE ADRESSE:
|
|
drei Muenzen und zwei Grenzen. Das Hochgeladene steht darin als
|
|
`eigen`. Die Saetze selbst prueft Abschnitt 10; hier geht es nur
|
|
um den Weg des eigenen Bildes. */
|
|
const ohneZeichen = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
ok(ohneZeichen.j?.zeichen?.eigen === "", "ohne Hochladen gibt es kein eigenes Zeichen");
|
|
|
|
const png = Buffer.from(
|
|
"89504e470d0a1a0a0000000d494844520000000100000001080600000"
|
|
+ "01f15c4890000000a49444154789c6360000002000100ffff0300000600"
|
|
+ "0557bfabd40000000049454e44ae426082", "hex");
|
|
const hochZ = await roh(CREW, "/workspace/api/spenden/zeichen", {
|
|
method: "POST", keks: k.admin, roher: png,
|
|
});
|
|
ok(hochZ.code === 200
|
|
&& /\/spendenbild\/[a-f0-9]{32}\.png$/.test(hochZ.j?.zeichen?.eigen || ""),
|
|
`das Zeichen laesst sich hochladen (${hochZ.code})`);
|
|
const eigenAdresse = hochZ.j?.zeichen?.eigen || "";
|
|
const abrufbar = await roh(CREW, eigenAdresse, {});
|
|
ok(abrufbar.code === 200,
|
|
`und ist OHNE Anmeldung abrufbar (${abrufbar.code}) -- sonst fehlte es im Stream`);
|
|
|
|
const mitZeichen = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
ok(mitZeichen.j?.zeichen?.eigen === eigenAdresse,
|
|
"es steht im Stand, und zwar fuer alle");
|
|
ok(mitZeichen.j?.zeichen?.niedrig === eigenAdresse,
|
|
"und gilt fuer alle drei Stufen gleich");
|
|
const probe = await roh(CREW, "/workspace/api/spenden/probe", {
|
|
method: "POST", keks: k.admin, rumpf: { dogen_mille: 500 },
|
|
});
|
|
ok(probe.j?.karte?.zeichen?.eigen === eigenAdresse,
|
|
"und reist mit jeder Karte mit");
|
|
|
|
const keinBild = await roh(CREW, "/workspace/api/spenden/zeichen", {
|
|
method: "POST", keks: k.admin, roher: Buffer.from("ich bin kein bild, wirklich nicht"),
|
|
});
|
|
ok(keinBild.code === 400 && keinBild.j?.fehler === "kein_bild",
|
|
`etwas, das kein Bild ist, wird abgelehnt (${keinBild.code})`);
|
|
const fremdeHand = await roh(CREW, "/workspace/api/spenden/zeichen", {
|
|
method: "POST", keks: k.modi, roher: png,
|
|
});
|
|
ok(fremdeHand.code === 403, `ein Modi setzt das Zeichen nicht (${fremdeHand.code})`);
|
|
|
|
const wegZ = await roh(CREW, "/workspace/api/spenden/zeichen",
|
|
{ method: "DELETE", keks: k.admin });
|
|
ok(wegZ.code === 200 && wegZ.j?.zeichen?.eigen === "",
|
|
`es laesst sich wieder wegnehmen (${wegZ.code})`);
|
|
const fortZ = await roh(CREW, eigenAdresse, {});
|
|
ok(fortZ.code === 404, `und die Datei ist danach fort (${fortZ.code})`);
|
|
}
|
|
|
|
|
|
/* =======================================================================
|
|
10. DIE DREI MUENZSAETZE
|
|
|
|
Filipe, 28.09.2026: „ich werde die drei varianten schicken fuer
|
|
niedrige spenden. mittlere und hohe spenden. alle drei varianten
|
|
will ich drauf so dass ich sie aussuchen kann wie ich will. aber
|
|
pass sie sofort diesen 3 kategorien an."
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 10. Die drei Muenzsaetze ===");
|
|
{
|
|
const { DOGEN_SAETZE, DOGEN_STUFEN, muenzeAdresse }
|
|
= await import("./spenden-tabellen.js");
|
|
|
|
ok(DOGEN_SAETZE.length === 3,
|
|
`es gibt ${DOGEN_SAETZE.length} Saetze: ${DOGEN_SAETZE.map((x) => x.name).join(", ")}`);
|
|
ok(DOGEN_STUFEN.length === 3 && DOGEN_STUFEN[0] === "niedrig"
|
|
&& DOGEN_STUFEN[2] === "hoch",
|
|
`und drei Stufen: ${DOGEN_STUFEN.join(", ")}`);
|
|
|
|
/* ---- JEDE MUENZE MUSS ES AUCH GEBEN ----
|
|
Die wichtigste Pruefung hier. Ein fehlendes Bild waere ein
|
|
kaputtes Zeichen neben JEDER Zahl -- im Saal und im Stream, und
|
|
gemerkt haette man es erst im Livestream. */
|
|
{
|
|
const fehlend = [];
|
|
const zuGross = [];
|
|
for (const satz of DOGEN_SAETZE) {
|
|
for (const stufe of DOGEN_STUFEN) {
|
|
const pfad = join(HIER, "..", muenzeAdresse(satz.schluessel, stufe)
|
|
.replace(/^\//, "").split("/").join("/"));
|
|
try {
|
|
const gross = statSync(pfad).size;
|
|
if (gross > 100 * 1024) zuGross.push(`${satz.schluessel}-${stufe} ${Math.round(gross / 1024)} KB`);
|
|
} catch { fehlend.push(`${satz.schluessel}-${stufe}`); }
|
|
}
|
|
}
|
|
ok(fehlend.length === 0,
|
|
fehlend.length ? `ES FEHLEN: ${fehlend.join(", ")}`
|
|
: `alle ${DOGEN_SAETZE.length * DOGEN_STUFEN.length} Muenzen liegen im Baum`);
|
|
/* UND KEINE DARF SCHWER SEIN. Filipes Vorlagen waren je drei
|
|
Megabyte; gezeigt wird die Muenze zwischen 24 und 110 Pixeln.
|
|
Ohne diese Grenze rutscht irgendwann wieder ein Original
|
|
herein, und dann laedt die Karte laenger, als sie steht. */
|
|
ok(zuGross.length === 0,
|
|
zuGross.length ? `ZU SCHWER: ${zuGross.join(", ")}`
|
|
: "und keine ist schwerer als 100 KB");
|
|
}
|
|
|
|
/* ---- UND SIE MUESSEN OHNE ANMELDUNG ZU HABEN SEIN ----
|
|
Die Spendentafel in OBS hat keine Sitzung. Eine Muenze hinter
|
|
der Schranke fehlte ausgerechnet im Stream. */
|
|
{
|
|
const a = await roh(CREW, muenzeAdresse("klassik", "hoch"), {});
|
|
ok(a.code === 200, `eine Muenze kommt ohne Anmeldung (${a.code})`);
|
|
const b = await roh(CREW, "/workspace/assets/dogen/gibtesnicht-hoch.webp", {});
|
|
ok(b.code === 404, `Gegenprobe: eine erfundene Muenze gibt es nicht (${b.code})`);
|
|
}
|
|
|
|
/* ---- WAS DER STAND SAGT ---- */
|
|
const lage = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
const z = lage.j?.zeichen;
|
|
ok(!!z && typeof z.satz === "string" && z.niedrig && z.mittel && z.hoch,
|
|
`der Stand traegt einen Satz („${z?.satz}“) mit drei Muenzen`);
|
|
/* KLEINER ODER GLEICH, nicht echt kleiner. Bei genau ZWEI Stufen
|
|
fallen die beiden Grenzen absichtlich zusammen: Dann gibt es
|
|
niedrig und hoch, und nichts dazwischen. Eine Pruefung auf „echt
|
|
kleiner" haette hier einen Fehler gemeldet, wo das Verhalten
|
|
richtig ist -- und genau das hat sie beim ersten Lauf getan. */
|
|
ok(Array.isArray(z?.grenzen) && z.grenzen.length === 2 && z.grenzen[0] <= z.grenzen[1],
|
|
`und zwei Grenzen (${z?.grenzen?.join(" / ")})`);
|
|
/* DIE GRENZEN KOMMEN AUS DER STUFENLEITER UND NICHT AUS EINER
|
|
ZWEITEN LISTE. Bei drei Stufen ist das genau eine Muenze je
|
|
Stufe. */
|
|
const leiter = (lage.j?.stufen || []).map((x) => x.ab_mille);
|
|
ok(leiter.length < 3
|
|
|| (z.grenzen[0] === leiter[Math.floor(leiter.length / 3)]
|
|
&& z.grenzen[1] === leiter[Math.floor((2 * leiter.length) / 3)]),
|
|
`sie sind aus der Leiter abgeleitet (Leiter ${leiter.join(", ")})`);
|
|
|
|
ok(Array.isArray(lage.j?.saetze) && lage.j.saetze.length >= 3,
|
|
`die Leitung bekommt ${lage.j?.saetze?.length} Saetze zum Aussuchen`);
|
|
const gast = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
ok(gast.j?.saetze === null, "ein Zuschauer bekommt die Auswahl nicht");
|
|
ok(!!gast.j?.zeichen?.niedrig, "aber die Muenzen selbst schon");
|
|
|
|
/* ---- DIE KARTE TRAEGT DEN SATZ ----
|
|
Eine Form ueberall: Die Karte bekommt dieselbe Auswahl wie der
|
|
Stand und sucht sich daraus die Muenze zu ihrer Zahl. Schickte
|
|
der Server hier EINE Adresse, gaebe es zwei Formen desselben
|
|
Dinges. */
|
|
const probe = await roh(CREW, "/workspace/api/spenden/probe", {
|
|
method: "POST", keks: k.admin, rumpf: { dogen_mille: 2500 },
|
|
});
|
|
ok(!!probe.j?.karte?.zeichen?.hoch && Array.isArray(probe.j.karte.zeichen.grenzen),
|
|
"und jede Karte bekommt ihn mit");
|
|
|
|
/* ---- AUSSUCHEN ---- */
|
|
for (const satz of DOGEN_SAETZE) {
|
|
const a = await roh(CREW, "/workspace/api/spenden/zeichen/satz", {
|
|
method: "PUT", keks: k.admin, rumpf: { satz: satz.schluessel },
|
|
});
|
|
ok(a.code === 200 && a.j?.zeichen?.satz === satz.schluessel,
|
|
`„${satz.name}“ laesst sich waehlen (${a.code})`);
|
|
ok((a.j?.zeichen?.hoch || "").includes(`${satz.schluessel}-hoch`),
|
|
`und die hohe Muenze kommt aus diesem Satz`);
|
|
}
|
|
const quatsch = await roh(CREW, "/workspace/api/spenden/zeichen/satz", {
|
|
method: "PUT", keks: k.admin, rumpf: { satz: "platin" },
|
|
});
|
|
ok(quatsch.code === 400 && quatsch.j?.fehler === "satz_unbekannt",
|
|
`ein erfundener Satz wird abgelehnt (${quatsch.code})`);
|
|
/* „eigen" OHNE HOCHGELADENES BILD GIBT ES NICHT -- sonst stuende
|
|
neben jeder Zahl ein Bild, das 404 antwortet. */
|
|
const ohneEigenes = await roh(CREW, "/workspace/api/spenden/zeichen/satz", {
|
|
method: "PUT", keks: k.admin, rumpf: { satz: "eigen" },
|
|
});
|
|
ok(ohneEigenes.code === 400,
|
|
`„eigen“ ohne eigenes Bild wird abgelehnt (${ohneEigenes.code})`);
|
|
const fremd = await roh(CREW, "/workspace/api/spenden/zeichen/satz", {
|
|
method: "PUT", keks: k.modi, rumpf: { satz: "neon" },
|
|
});
|
|
ok(fremd.code === 403, `ein Modi waehlt den Satz nicht (${fremd.code})`);
|
|
|
|
/* ---- EIN EIGENES ZEICHEN GILT SOFORT UND FAELLT SAUBER ZURUECK ---- */
|
|
const png = Buffer.from(
|
|
"89504e470d0a1a0a0000000d494844520000000100000001080600000"
|
|
+ "01f15c4890000000a49444154789c6360000002000100ffff0300000600"
|
|
+ "0557bfabd40000000049454e44ae426082", "hex");
|
|
const hoch = await roh(CREW, "/workspace/api/spenden/zeichen", {
|
|
method: "POST", keks: k.admin, roher: png,
|
|
});
|
|
ok(hoch.code === 200 && hoch.j?.zeichen?.satz === "eigen",
|
|
`ein hochgeladenes Zeichen gilt sofort (${hoch.j?.zeichen?.satz})`);
|
|
ok(hoch.j?.zeichen?.niedrig === hoch.j?.zeichen?.hoch,
|
|
"es gilt fuer alle drei Stufen gleich");
|
|
ok((hoch.j?.saetze || []).some((x) => x.schluessel === "eigen"),
|
|
"und steht ab jetzt in der Auswahl");
|
|
|
|
const weg = await roh(CREW, "/workspace/api/spenden/zeichen",
|
|
{ method: "DELETE", keks: k.admin });
|
|
ok(weg.code === 200 && weg.j?.zeichen?.satz === DOGEN_SAETZE[0].schluessel,
|
|
`nach dem Loeschen gilt wieder ein Satz, den es gibt (${weg.j?.zeichen?.satz})`);
|
|
ok(!(weg.j?.saetze || []).some((x) => x.schluessel === "eigen"),
|
|
"und „eigen“ steht nicht mehr zur Wahl");
|
|
|
|
/* ==== DIE MUENZEN HAENGEN VON ANFANG AN AN DEN DREI STUFEN ====
|
|
|
|
Filipe: „aber pass sie sofort diesen 3 kategorien an."
|
|
|
|
GEPRUEFT WIRD AUF EINER FRISCHEN DATENBANK und nicht auf dieser:
|
|
Die Leiter hier ist in Abschnitt 8 umgebaut worden, und danach
|
|
steht sie so da, wie die Pruefung sie gesetzt hat -- nicht so,
|
|
wie ein frisches Haus sie bekommt. Eine Pruefung, die den
|
|
eigenen Kollateralschaden misst, misst sich selbst.
|
|
|
|
Und die zweite Haelfte ist die wichtigere: Eine Stufe, die
|
|
jemand SELBST gewaehlt hat, wird nicht ueberschrieben. Eine
|
|
Verteilung, die sich gegen den Benutzer durchsetzt, wird
|
|
abgeschafft. */
|
|
{
|
|
const { mkdtempSync: neuerOrdner } = await import("node:fs");
|
|
const { tmpdir: tmp2 } = await import("node:os");
|
|
const { DatabaseSync: DBM } = await import("node:sqlite");
|
|
const { spendenTabellen } = await import("./spenden-tabellen.js");
|
|
const ordner2 = neuerOrdner(join(tmp2(), "muenzen-"));
|
|
const d2 = new DBM(join(ordner2, "probe.db"));
|
|
d2.exec(`CREATE TABLE einstellungen (schluessel TEXT PRIMARY KEY,
|
|
wert TEXT NOT NULL, geaendert TEXT, von INTEGER);
|
|
CREATE TABLE personen (id INTEGER PRIMARY KEY);`);
|
|
spendenTabellen(d2);
|
|
const frisch = d2.prepare("SELECT ab_cent, vorlage FROM spenden_stufen ORDER BY ab_cent")
|
|
.all();
|
|
ok(frisch.length === 3 && frisch.every((x) => x.vorlage === "dogen"),
|
|
`ein frisches Haus zeigt die Muenze auf allen ${frisch.length} Stufen `
|
|
+ `(${frisch.map((x) => x.vorlage).join(", ")})`);
|
|
|
|
/* Gegenprobe: eine selbst gewaehlte Vorlage bleibt stehen -- auch
|
|
wenn die Verteilung noch einmal laufen wuerde. */
|
|
d2.exec("UPDATE spenden_stufen SET vorlage = 'stern' WHERE ab_cent = 500");
|
|
d2.exec("DELETE FROM einstellungen WHERE schluessel = 'dogen_muenzen_verteilt'");
|
|
spendenTabellen(d2);
|
|
const nachDemZweiten = d2.prepare("SELECT vorlage FROM spenden_stufen WHERE ab_cent = 500")
|
|
.get();
|
|
ok(nachDemZweiten?.vorlage === "stern",
|
|
`Gegenprobe: eine selbst gewaehlte Vorlage bleibt (${nachDemZweiten?.vorlage})`);
|
|
d2.close();
|
|
rmSync(ordner2, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
/* =======================================================================
|
|
11. DIE FERTIGEN SAETZE (08.10.2026)
|
|
|
|
Filipe: „es soll fertige sätze geben und wenn jemand die auswählt
|
|
muss keiner es bestätigen dan wird es sofort angezeigt und wenn
|
|
jemand selber was schreibt dan muss bestätigt werden damit es
|
|
angezeigt wird."
|
|
|
|
---------------------------------------------------------------------
|
|
WAS HIER WIRKLICH AUF DEM SPIEL STEHT
|
|
|
|
Eine Karte, die OHNE Bestaetigung in einen Livestream geht, ist die
|
|
offenste Tuer des ganzen Hauses. Sie darf nur deshalb offen sein,
|
|
weil der Text NICHT vom Absender kommt, sondern aus der Datenbank.
|
|
Genau das wird hier angegriffen: Es wird versucht, neben der
|
|
Satzkennung einen eigenen Text einzuschmuggeln.
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 11. Die fertigen Saetze ===");
|
|
{
|
|
const { db } = await import("./workspace.js");
|
|
/* Die Bremse „eine Meldung je Minute und Person" steht allen
|
|
folgenden Pruefungen im Weg -- sie brauchen mehrere Meldungen
|
|
derselben Person. Zurueckdatieren statt warten: Eine Pruefung,
|
|
die Minuten wartet, wird beim naechsten Mal uebersprungen. */
|
|
const bremseLoesen = (personId) => {
|
|
db().prepare("UPDATE spenden SET erstellt = ? WHERE person_id = ?")
|
|
.run(new Date(Date.now() - 600_000).toISOString(), personId);
|
|
};
|
|
|
|
const lage = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
const saetze = lage.j?.fertige_saetze || [];
|
|
ok(saetze.length >= 3,
|
|
`ab Werk stehen ${saetze.length} fertige Saetze zum Aussuchen bereit`);
|
|
ok(saetze.every((s) => s.id && s.text),
|
|
"jeder hat eine Kennung und einen Text");
|
|
|
|
const beimGast = await roh(CREW, "/workspace/api/spenden", { keks: k.gast });
|
|
ok((beimGast.j?.fertige_saetze || []).length === saetze.length,
|
|
"ein Zuschauer bekommt sie auch -- er soll ja einen aussuchen");
|
|
|
|
/* ==== SOFORT INS BILD, ABER NICHT INS BUCH ===================== */
|
|
bremseLoesen(IDS.gast);
|
|
const standVorher = (await roh(CREW, "/workspace/api/spenden", { keks: k.gast }))
|
|
.j?.ich?.dogen_mille ?? -1;
|
|
|
|
const sofort = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast,
|
|
rumpf: { dogen_mille: 500, satz_id: saetze[0].id, gruss: "HIER STEHT ETWAS ANDERES" },
|
|
});
|
|
ok(sofort.code === 201 && sofort.j?.sofort === true,
|
|
`ein fertiger Satz geht sofort ins Bild (${sofort.code}/${sofort.j?.sofort})`);
|
|
ok(sofort.j?.wartet === false,
|
|
"und er wartet ausdruecklich NICHT auf eine Bestaetigung");
|
|
|
|
const imPult = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
const frisch = (imPult.j?.offen || []).find((x) => x.dogen_mille === 500);
|
|
ok(!!frisch, "sie steht trotzdem im Pult");
|
|
ok(frisch?.schon_gezeigt === true,
|
|
"und zwar mit dem Vermerk, dass sie schon gelaufen ist");
|
|
/* ==== DER ANGRIFF: EIN EIGENER TEXT NEBEN DER KENNUNG =========
|
|
Wer `gruss` mitschickt, hat wieder ein freies Feld -- nur mit
|
|
einem Haken daneben, auf dem „ist ja ein fertiger" steht. Der
|
|
Text MUSS aus der Datenbank kommen. */
|
|
ok(frisch?.gruss === saetze[0].text,
|
|
`der Text kommt aus der Datenbank, nicht aus der Leitung ("${frisch?.gruss}")`);
|
|
ok(frisch?.gruss !== "HIER STEHT ETWAS ANDERES",
|
|
"Gegenprobe: der mitgeschickte eigene Text gilt NICHT");
|
|
|
|
/* ==== GEZEIGT IST NICHT GEBUCHT ==============================
|
|
Sonst stellte sich jede Minute jeder seine eigene Waehrung aus. */
|
|
const standNachher = (await roh(CREW, "/workspace/api/spenden", { keks: k.gast }))
|
|
.j?.ich?.dogen_mille ?? -1;
|
|
ok(standNachher === standVorher,
|
|
`gezeigt, aber noch nicht gutgeschrieben (${standVorher} -> ${standNachher})`);
|
|
|
|
/* ==== DIE BESTAETIGUNG BUCHT -- UND ZEIGT NICHT NOCH EINMAL === */
|
|
const vorBest = db().prepare("SELECT gezeigt_am FROM spenden WHERE id = ?").get(frisch.id);
|
|
const best = await roh(CREW, `/workspace/api/spenden/${frisch.id}/bestaetigen`, {
|
|
method: "POST", keks: k.admin, rumpf: {},
|
|
});
|
|
ok(best.code === 200, `die Leitung bestaetigt sie nachtraeglich (${best.code})`);
|
|
const standBest = (await roh(CREW, "/workspace/api/spenden", { keks: k.gast }))
|
|
.j?.ich?.dogen_mille ?? -1;
|
|
ok(standBest === standVorher + 500,
|
|
`erst jetzt gibt es die Dogen (${standVorher} -> ${standBest})`);
|
|
const nachBest = db().prepare("SELECT gezeigt_am FROM spenden WHERE id = ?").get(frisch.id);
|
|
ok(nachBest?.gezeigt_am === vorBest?.gezeigt_am,
|
|
"und die Karte laeuft NICHT ein zweites Mal (der Zeitpunkt steht still)");
|
|
|
|
/* ==== EIN FREIER TEXT WARTET WEITERHIN ======================== */
|
|
bremseLoesen(IDS.gast2);
|
|
const frei = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast2,
|
|
rumpf: { dogen_mille: 500, gruss: "Selbst getippt" },
|
|
});
|
|
ok(frei.code === 201 && frei.j?.sofort !== true && frei.j?.wartet === true,
|
|
`ein selbst geschriebener Text wartet (${frei.code}/sofort=${frei.j?.sofort})`);
|
|
const freiImPult = (await roh(CREW, "/workspace/api/spenden", { keks: k.admin }))
|
|
.j?.offen?.find((x) => x.gruss === "Selbst getippt");
|
|
ok(freiImPult?.schon_gezeigt === false,
|
|
"und ist nicht im Bild gewesen");
|
|
|
|
/* ==== EINE FREIE ZAHL GEHT AUCH MIT SATZ NICHT SOFORT =========
|
|
Filipes Ansage galt dem SATZ, nicht der Summe. Wer eine eigene
|
|
Zahl eintraegt, behauptet eine Hoehe -- und „25 Dogen" ungesehen
|
|
gross im Stream ist der Fehler, den man nicht mehr einfangen
|
|
kann, wenn hundert Leute zusehen. */
|
|
bremseLoesen(IDS.gast2);
|
|
const krumm = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast2, rumpf: { dogen_mille: 777, satz_id: saetze[0].id },
|
|
});
|
|
ok(krumm.code === 201 && krumm.j?.sofort === false,
|
|
`ein Betrag, den kein Knopf anbietet, wartet trotz Satz (${krumm.j?.sofort})`);
|
|
/* GEGENPROBE: Mit einem Knopfbetrag waere derselbe Satz sofort
|
|
gelaufen -- sonst bewiese das Obige nur, dass irgendetwas
|
|
nicht sofort geht. */
|
|
bremseLoesen(IDS.gast2);
|
|
const rund = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast2, rumpf: { dogen_mille: 200, satz_id: saetze[0].id },
|
|
});
|
|
ok(rund.j?.sofort === true,
|
|
"Gegenprobe: mit einem Knopfbetrag geht derselbe Satz sofort");
|
|
|
|
/* ==== EINE KENNUNG, DIE ES NICHT GIBT ======================== */
|
|
bremseLoesen(IDS.gast2);
|
|
const falsch = await roh(CREW, "/workspace/api/spenden/melden", {
|
|
method: "POST", keks: k.gast2, rumpf: { dogen_mille: 200, satz_id: 999999 },
|
|
});
|
|
ok(falsch.code === 400 && falsch.j?.fehler === "fertigsatz_unbekannt",
|
|
`eine erfundene Satzkennung wird abgelehnt (${falsch.code}/${falsch.j?.fehler})`);
|
|
|
|
/* ==== DIE LEITUNG PFLEGT DIE LISTE =========================== */
|
|
const neu = await roh(CREW, "/workspace/api/spenden/fertige-saetze", {
|
|
method: "PUT", keks: k.admin,
|
|
rumpf: { fertige_saetze: ["Erster Satz", " ", "Zweiter Satz"] },
|
|
});
|
|
ok(neu.code === 200 && (neu.j?.fertige_saetze || []).length === 2,
|
|
`leere Zeilen fallen weg (${neu.j?.fertige_saetze?.length} statt 3)`);
|
|
ok(neu.j.fertige_saetze[0].text === "Erster Satz"
|
|
&& neu.j.fertige_saetze[1].text === "Zweiter Satz",
|
|
"und die Reihenfolge bleibt");
|
|
|
|
for (const rolle of ["linke", "modi", "gast"]) {
|
|
const a = await roh(CREW, "/workspace/api/spenden/fertige-saetze", {
|
|
method: "PUT", keks: k[rolle], rumpf: { fertige_saetze: ["Ich auch"] },
|
|
});
|
|
ok(a.code === 403, `${rolle}: darf die Saetze nicht aendern (${a.code})`);
|
|
}
|
|
const zuViele = await roh(CREW, "/workspace/api/spenden/fertige-saetze", {
|
|
method: "PUT", keks: k.admin,
|
|
rumpf: { fertige_saetze: Array.from({ length: 9 }, (_, i) => `Satz ${i}`) },
|
|
});
|
|
ok(zuViele.code === 400 && zuViele.j?.fehler === "zu_viele_saetze",
|
|
`neun sind zu viele (${zuViele.code}/${zuViele.j?.fehler})`);
|
|
}
|
|
|
|
/* =======================================================================
|
|
12. WO DIE KARTE STEHT UND WER IM CHAT GLAENZT (08.10.2026)
|
|
======================================================================= */
|
|
melde("");
|
|
melde("=== 12. Platz und Spender-Glanz ===");
|
|
{
|
|
const { db } = await import("./workspace.js");
|
|
const { spenderGlanz } = await import("./workspace-spenden.js");
|
|
|
|
/* ---- Der Platz ---- */
|
|
const l0 = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
ok(l0.j?.platz === "mitte", `die Vorgabe ist die Mitte (${l0.j?.platz})`);
|
|
ok((l0.j?.gestaltung?.plaetze || []).join(",") === "mitte,rand",
|
|
"und es gibt genau zwei Plaetze");
|
|
|
|
/* ==== DIESER ABSCHNITT SETZT SEINE EIGENE LEITER ==============
|
|
|
|
Die Abschnitte davor haben an der Stufenleiter gearbeitet --
|
|
verschoben, geloescht, neu angelegt. Sich darauf zu verlassen,
|
|
was dabei uebrig geblieben ist, waere die Kopplung, die spaeter
|
|
jemand aus Versehen zerreisst; dann faellt ein Abschnitt um, an
|
|
dem nichts falsch ist. (Genau so ist dieser Abschnitt beim
|
|
ersten Lauf rot geworden: zwei Stufen statt drei, beide ohne
|
|
Glanz.)
|
|
|
|
Die drei Werte sind dieselben wie ab Werk -- 5, 15, 45 --, damit
|
|
die Pruefung auch das misst, was ein frisches Haus mitbringt. */
|
|
const leiterSoll = [
|
|
{ id: 0, ab_mille: 100, name: "Danke", vorlage: "herz", farbe: "#8ec9ff",
|
|
dauer_ms: 6000, groesse: 1, glanz_minuten: 5 },
|
|
{ id: 0, ab_mille: 500, name: "Starke Runde", vorlage: "welle", farbe: "#a98bff",
|
|
dauer_ms: 8000, groesse: 1.15, glanz_minuten: 15 },
|
|
{ id: 0, ab_mille: 2000, name: "Rudel-Legende", vorlage: "krone", farbe: "#e0a13a",
|
|
dauer_ms: 11000, groesse: 1.45, glanz_minuten: 45 },
|
|
];
|
|
const gesetzt = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf: { stufen: leiterSoll },
|
|
});
|
|
ok(gesetzt.code === 200 && (gesetzt.j?.stufen || []).length === 3,
|
|
`drei Stufen fuer diesen Abschnitt gesetzt (${gesetzt.j?.stufen?.length})`);
|
|
ok((gesetzt.j?.stufen || []).map((s) => s.glanz_minuten).join("/") === "5/15/45",
|
|
`und der Glanz kommt zurueck, wie er hingeschickt wurde `
|
|
+ `(${(gesetzt.j?.stufen || []).map((s) => s.glanz_minuten).join("/")})`);
|
|
|
|
const stufenJetzt = (gesetzt.j?.stufen || []).map((s) => ({
|
|
id: s.id, ab_mille: s.ab_mille, name: s.name, vorlage: s.vorlage,
|
|
farbe: s.farbe, dauer_ms: s.dauer_ms, groesse: s.groesse,
|
|
glanz_minuten: s.glanz_minuten,
|
|
}));
|
|
const amRand = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf: { stufen: stufenJetzt, platz: "rand" },
|
|
});
|
|
ok(amRand.code === 200 && amRand.j?.platz === "rand",
|
|
`er laesst sich auf „rand" stellen (${amRand.j?.platz})`);
|
|
const falscherPlatz = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf: { stufen: stufenJetzt, platz: "oben" },
|
|
});
|
|
ok(falscherPlatz.code === 400 && falscherPlatz.j?.fehler === "platz_unklar",
|
|
`ein erfundener Platz wird abgelehnt (${falscherPlatz.code}/${falscherPlatz.j?.fehler})`);
|
|
|
|
/* ==== DER PLATZ REIST MIT DER KARTE ==========================
|
|
Die Spendentafel in OBS hat keine Sitzung und kann nichts
|
|
nachfragen -- was sie nicht mitbekommt, kann sie nicht
|
|
anzeigen. */
|
|
const mitKarte = await roh(CREW, "/workspace/api/spenden", { keks: k.admin });
|
|
const eine = (mitKarte.j?.letzte || [])[0];
|
|
ok(eine?.platz === "rand", `jede Karte traegt den Platz mit (${eine?.platz})`);
|
|
|
|
await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf: { stufen: stufenJetzt, platz: "mitte" },
|
|
});
|
|
|
|
/* ---- Der Glanz im Chat ---- */
|
|
const werte = stufenJetzt.map((s) => s.glanz_minuten);
|
|
ok(werte.length >= 3 && werte[0] > 0 && werte[2] > werte[0],
|
|
`je hoeher die Stufe, desto laenger der Glanz (${werte.join(" / ")} Minuten)`);
|
|
|
|
const glanz = spenderGlanz();
|
|
const meiner = glanz.get(IDS.gast);
|
|
ok(!!meiner, "wer eben gespendet hat, glaenzt im Chat");
|
|
ok(meiner?.farbe && /^#[0-9a-fA-F]{6}$/.test(meiner.farbe),
|
|
`in der Farbe seiner Stufe (${meiner?.farbe})`);
|
|
ok(!!meiner?.stufe, `und mit ihrem Namen (${meiner?.stufe})`);
|
|
ok(meiner?.noch_ms > 0, `und mit einer Restdauer (${meiner?.noch_ms} ms)`);
|
|
/* ALS ALTER UND NICHT ALS UHRZEIT -- eine Uhr im Handy kann falsch
|
|
gehen, eine Dauer nicht. Dieselbe Lehre wie beim Gleichlauf des
|
|
Videos am 30.09.2026. */
|
|
ok(meiner?.noch_ms <= werte[1] * 60_000 + 1000,
|
|
"und die Restdauer passt zur Stufe");
|
|
|
|
/* ==== DIE STAERKSTE STUFE GEWINNT, NICHT DIE LETZTE ==========
|
|
Wer erst viel und dann wenig gibt, soll nicht herabgestuft
|
|
werden -- das laese sich wie eine Bestrafung dafuer, dass er
|
|
noch einmal gegeben hat. */
|
|
{
|
|
const gross = stufenJetzt[stufenJetzt.length - 1].ab_mille;
|
|
db().prepare(`INSERT INTO spenden
|
|
(betrag_cent, waehrung, name, gruss, person_id, herkunft, stand, erstellt, gezeigt_am)
|
|
VALUES (?,?,?,?,?,'hand','bestaetigt',?,?)`)
|
|
.run(gross * 10, "EUR", "Probe", "", IDS.gast,
|
|
new Date(Date.now() - 60_000).toISOString(),
|
|
new Date(Date.now() - 60_000).toISOString());
|
|
db().prepare(`INSERT INTO spenden
|
|
(betrag_cent, waehrung, name, gruss, person_id, herkunft, stand, erstellt, gezeigt_am)
|
|
VALUES (?,?,?,?,?,'hand','bestaetigt',?,?)`)
|
|
.run(100, "EUR", "Probe", "", IDS.gast, new Date().toISOString(),
|
|
new Date().toISOString());
|
|
const g2 = spenderGlanz().get(IDS.gast);
|
|
ok(g2?.stufe === stufenJetzt[stufenJetzt.length - 1].name,
|
|
`die hoechste noch gueltige Stufe gewinnt (${g2?.stufe})`);
|
|
}
|
|
|
|
/* ==== NULL MINUTEN HEISST GAR NICHT ==========================
|
|
Eine gueltige Einstellung und kein fehlender Wert. */
|
|
{
|
|
const aus = stufenJetzt.map((s) => ({ ...s, glanz_minuten: 0 }));
|
|
const a = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf: { stufen: aus },
|
|
});
|
|
ok(a.code === 200, `alle Stufen auf null (${a.code})`);
|
|
ok(spenderGlanz().size === 0,
|
|
"dann glaenzt niemand mehr -- auch nicht, wer eben gespendet hat");
|
|
const zurueck = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin, rumpf: { stufen: stufenJetzt },
|
|
});
|
|
ok(zurueck.code === 200 && spenderGlanz().size > 0,
|
|
"Gegenprobe: mit Minuten glaenzt er wieder");
|
|
}
|
|
|
|
/* ==== UND NACH DER ZEIT IST SCHLUSS ========================== */
|
|
{
|
|
const lange = stufenJetzt[stufenJetzt.length - 1].glanz_minuten;
|
|
db().prepare("UPDATE spenden SET gezeigt_am = ? WHERE person_id = ?")
|
|
.run(new Date(Date.now() - (lange + 10) * 60_000).toISOString(), IDS.gast);
|
|
ok(!spenderGlanz().get(IDS.gast),
|
|
`nach ${lange} Minuten ist der Glanz vorbei`);
|
|
}
|
|
|
|
const grenze = await roh(CREW, "/workspace/api/spenden/stufen", {
|
|
method: "PUT", keks: k.admin,
|
|
rumpf: { stufen: stufenJetzt.map((s) => ({ ...s, glanz_minuten: 9999 })) },
|
|
});
|
|
ok(grenze.code === 400 && grenze.j?.fehler === "glanz_unklar",
|
|
`und 9999 Minuten sind zu viel (${grenze.code}/${grenze.j?.fehler})`);
|
|
|
|
/* ==== DER GLANZ WIRD NACH RANG VERTEILT, NICHT NACH BETRAG =====
|
|
(08.10.2026, nach einem Fund auf dem echten Server)
|
|
|
|
Die erste Nachruestung fuellte nur Stufen mit der WERKSGRENZE
|
|
(100/500/2000 Cent). Auf dem Server stehen vier Stufen, und die
|
|
oberste liegt bei 5000 -- sie bekam als EINZIGE nichts, waehrend
|
|
eine mittlere 45 Minuten bekam. Ein Glanz, der mit der Hoehe
|
|
waechst und bei der hoechsten Stufe aufhoert, sieht nicht nach
|
|
Vorsicht aus, sondern nach einem Fehler.
|
|
|
|
Geprueft wird an einer eigenen, frischen Datenbank -- die
|
|
laufende hat ihren Merker laengst gesetzt, und ein Lauf gegen
|
|
sie bewiese nur, dass nichts mehr passiert. */
|
|
{
|
|
const { DatabaseSync: DBM } = await import("node:sqlite");
|
|
const { mkdtempSync: neuerOrdner, rmSync: wegDamit } = await import("node:fs");
|
|
const { tmpdir: tmp2 } = await import("node:os");
|
|
const { spendenTabellen } = await import("./spenden-tabellen.js");
|
|
|
|
const ordner3 = neuerOrdner(join(tmp2(), "glanz-"));
|
|
const d3 = new DBM(join(ordner3, "probe.db"));
|
|
d3.exec(`CREATE TABLE einstellungen (schluessel TEXT PRIMARY KEY,
|
|
wert TEXT NOT NULL, geaendert TEXT, von INTEGER);
|
|
CREATE TABLE personen (id INTEGER PRIMARY KEY);`);
|
|
spendenTabellen(d3);
|
|
|
|
/* Eine Leiter wie auf dem Server: vier Stufen, die oberste weit
|
|
oberhalb der Werksgrenze -- und alle vier ohne Glanz, so wie
|
|
sie nach dem ersten Nachruesten dastuenden. */
|
|
d3.exec("DELETE FROM einstellungen WHERE schluessel = 'spenden_glanz_verteilt'");
|
|
d3.exec("UPDATE spenden_stufen SET glanz_minuten = 0");
|
|
d3.prepare(`INSERT INTO spenden_stufen
|
|
(ab_cent, name, vorlage, farbe, dauer_ms, groesse, glanz_minuten, geaendert)
|
|
VALUES (5000,'Rudel-Legende','dogen','#e0a13a',11000,1.45,0,'')`).run();
|
|
spendenTabellen(d3);
|
|
|
|
const nachher = d3.prepare("SELECT ab_cent, glanz_minuten FROM spenden_stufen"
|
|
+ " ORDER BY ab_cent").all();
|
|
const werte = nachher.map((z) => z.glanz_minuten);
|
|
ok(werte.length === 4 && werte.every((w) => w > 0),
|
|
`alle vier Stufen bekommen Glanz (${werte.join(" / ")} Minuten)`);
|
|
ok(werte[3] > werte[0] && werte[3] >= werte[2] && werte[2] >= werte[1],
|
|
"und er waechst mit dem Rang -- die hoechste Stufe am laengsten");
|
|
|
|
/* ==== DIE GEGENPROBE: EINE BEWUSSTE NULL BLEIBT ============
|
|
Ohne sie bewiese das Obige nur, dass irgendetwas gefuellt
|
|
wird -- und beim naechsten Neustart stuende die Null, die
|
|
jemand ausdruecklich gesetzt hat, wieder auf 20. */
|
|
d3.exec("UPDATE spenden_stufen SET glanz_minuten = 0 WHERE ab_cent = 100");
|
|
spendenTabellen(d3);
|
|
const nochmal = d3.prepare("SELECT glanz_minuten FROM spenden_stufen"
|
|
+ " WHERE ab_cent = 100").get();
|
|
ok(nochmal?.glanz_minuten === 0,
|
|
`Gegenprobe: eine bewusst gesetzte Null bleibt (${nochmal?.glanz_minuten})`);
|
|
|
|
d3.close();
|
|
wegDamit(ordner3, { recursive: true, force: true });
|
|
}
|
|
}
|
|
|
|
melde("");
|
|
melde(`${geprueft} Pruefungen, ${fehler} Fehler`);
|
|
melde(fehler === 0 ? "ALLES IN ORDNUNG" : "NICHT IN ORDNUNG");
|
|
process.exit(fehler === 0 ? 0 : 1);
|