579 lines
23 KiB
TypeScript
579 lines
23 KiB
TypeScript
import { beforeEach, describe, expect, it } from "vitest";
|
||
import { GRENZEN, type Austausch } from "@/lib/vorlagen-format";
|
||
import {
|
||
AustauschFehler,
|
||
vorlageExportieren,
|
||
vorlageImportieren,
|
||
} from "@/server/services/vorlagen-austausch";
|
||
import { datenbankLeeren, datenbankVerfuegbar, testPrisma } from "./helpers/db";
|
||
|
||
/**
|
||
* JSON-Austausch fuer Vorlagen (#009).
|
||
*
|
||
* Der Rundlauf ist der eigentliche Prueffall: was exportiert und wieder
|
||
* eingespielt wird, muss dasselbe sein. Alles andere hier haelt fest, was dabei
|
||
* bewusst *nicht* mitwandert (Kennungen, Positionen, Kundenbezug) und was ein
|
||
* Import mit einer krummen Datei tun soll.
|
||
*/
|
||
|
||
/** Ein Befehl mit Platzhaltern – er darf den Rundlauf Zeichen fuer Zeichen ueberleben. */
|
||
const BEFEHL = 'New-ADUser -Name "{{vorname}} {{nachname}}" -Department "{{abteilung}}"';
|
||
|
||
/** Urheber der Protokolleintraege; ohne echten Benutzer greift der Fremdschluessel. */
|
||
async function redakteurAnlegen() {
|
||
return testPrisma.benutzer.create({
|
||
data: { email: "redaktion@firma.example", name: "Redaktion", rolle: "REDAKTEUR" },
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Eine veroeffentlichte Version mit zwei Abschnitten, Schritten verschiedener
|
||
* Typen und zwei Variablen.
|
||
*
|
||
* Die Zeilen werden absichtlich in verkehrter Reihenfolge angelegt: dann zeigt
|
||
* der Export, dass er nach `position` sortiert und nicht danach, wie die
|
||
* Datenbank die Zeilen gerade zurueckgibt.
|
||
*/
|
||
async function beispielVersionAnlegen(): Promise<string> {
|
||
const vorlage = await testPrisma.vorlage.create({
|
||
data: {
|
||
name: "Onboarding Notebook",
|
||
beschreibung: "Neue Person, neues Gerät.",
|
||
kategorie: "Onboarding",
|
||
schlagworte: ["notebook", "eintritt"],
|
||
},
|
||
});
|
||
// Erst als Entwurf anlegen und befuellen, dann veroeffentlichen: an einer
|
||
// veroeffentlichten Version laesst sich nichts mehr anhaengen, dafuer sorgen
|
||
// Trigger in der Datenbank.
|
||
const version = await testPrisma.vorlagenVersion.create({
|
||
data: { vorlageId: vorlage.id, version: 3, status: "ENTWURF" },
|
||
});
|
||
|
||
await testPrisma.vorlagenVariable.create({
|
||
data: {
|
||
versionId: version.id,
|
||
schluessel: "abteilung",
|
||
beschriftung: "Abteilung",
|
||
typ: "AUSWAHL",
|
||
optionen: ["IT", "Vertrieb"],
|
||
pflicht: false,
|
||
position: 1,
|
||
},
|
||
});
|
||
await testPrisma.vorlagenVariable.create({
|
||
data: {
|
||
versionId: version.id,
|
||
schluessel: "vorname",
|
||
beschriftung: "Vorname",
|
||
typ: "TEXT",
|
||
pflicht: true,
|
||
position: 0,
|
||
},
|
||
});
|
||
|
||
const zweiter = await testPrisma.vorlagenAbschnitt.create({
|
||
data: { versionId: version.id, titel: "02 · Konto", position: 1 },
|
||
});
|
||
const erster = await testPrisma.vorlagenAbschnitt.create({
|
||
data: { versionId: version.id, titel: "01 · Vorbereitung", position: 0 },
|
||
});
|
||
|
||
await testPrisma.vorlagenSchritt.createMany({
|
||
data: [
|
||
{
|
||
abschnittId: erster.id,
|
||
titel: "Gerät auspacken",
|
||
typ: "HAKEN",
|
||
pflicht: true,
|
||
position: 0,
|
||
},
|
||
{
|
||
abschnittId: erster.id,
|
||
titel: "Seriennummer erfassen",
|
||
hilfetext: "Aufkleber auf der Unterseite.",
|
||
typ: "TEXT",
|
||
pflicht: true,
|
||
konfig: { mehrzeilig: false },
|
||
dokuUrl: "https://intern.example/seriennummern",
|
||
position: 1,
|
||
},
|
||
{
|
||
abschnittId: erster.id,
|
||
titel: "Arbeitsspeicher prüfen",
|
||
typ: "ZAHL",
|
||
konfig: { min: 8, max: 64, einheit: "GB" },
|
||
position: 2,
|
||
},
|
||
],
|
||
});
|
||
await testPrisma.vorlagenSchritt.createMany({
|
||
data: [
|
||
{
|
||
abschnittId: zweiter.id,
|
||
titel: "Benutzerkonto anlegen",
|
||
typ: "BEFEHL",
|
||
pflicht: true,
|
||
// Ein unbekannter Schluessel: das Schema ist nachsichtig, damit ein
|
||
// Export aus einer spaeteren Fassung hier nichts verliert.
|
||
konfig: { shell: "powershell", befehl: BEFEHL, kuenftigesFeld: { tief: [1, 2] } },
|
||
position: 0,
|
||
},
|
||
{
|
||
abschnittId: zweiter.id,
|
||
titel: "Eintrittsdatum hinterlegen",
|
||
typ: "DATUM",
|
||
position: 1,
|
||
},
|
||
],
|
||
});
|
||
|
||
await testPrisma.vorlagenVersion.update({
|
||
where: { id: version.id },
|
||
data: { status: "VEROEFFENTLICHT", veroeffentlichtAm: new Date() },
|
||
});
|
||
|
||
return version.id;
|
||
}
|
||
|
||
/** Das kleinste Dokument, das durchgeht – Ausgangspunkt fuer die Fehlerfaelle. */
|
||
function dokument(aenderung: Record<string, unknown> = {}): Record<string, unknown> {
|
||
return {
|
||
format: 1,
|
||
name: "Kleine Vorlage",
|
||
struktur: {
|
||
variablen: [{ schluessel: "vorname", beschriftung: "Vorname" }],
|
||
abschnitte: [{ titel: "01 · Start", schritte: [{ titel: "Anfangen" }] }],
|
||
},
|
||
...aenderung,
|
||
};
|
||
}
|
||
|
||
/** Der Rundlauf darf sich in `version` unterscheiden – alles andere nicht. */
|
||
function ohneVersion(austausch: Austausch): Omit<Austausch, "version"> {
|
||
const kopie: Omit<Austausch, "version"> & { version?: number } = { ...austausch };
|
||
delete kopie.version;
|
||
return kopie;
|
||
}
|
||
|
||
/**
|
||
* Diese Faelle scheitern am Schema, also noch vor dem ersten Datenbankzugriff –
|
||
* deshalb laufen sie auch ohne Testdatenbank.
|
||
*/
|
||
describe("Import: Pruefung des Dokuments", () => {
|
||
it("weist ein fehlendes oder falsches Format ab", async () => {
|
||
const ohneFormat = dokument();
|
||
delete ohneFormat["format"];
|
||
await expect(vorlageImportieren(ohneFormat, "wer-auch-immer")).rejects.toThrow(AustauschFehler);
|
||
await expect(vorlageImportieren(dokument({ format: 2 }), "wer")).rejects.toThrow(/Format 1/);
|
||
await expect(vorlageImportieren("kein Objekt", "wer")).rejects.toThrow(AustauschFehler);
|
||
});
|
||
|
||
it("nennt bei einem leeren Schritt-Titel den Pfad", async () => {
|
||
const kaputt = dokument({
|
||
struktur: {
|
||
variablen: [],
|
||
abschnitte: [
|
||
{ titel: "01 · Start", schritte: [{ titel: "Anfangen" }] },
|
||
{
|
||
titel: "02 · Konto",
|
||
schritte: [{ titel: "Erledigen" }, { titel: "Prüfen" }, { titel: " " }],
|
||
},
|
||
],
|
||
},
|
||
});
|
||
await expect(vorlageImportieren(kaputt, "wer")).rejects.toThrow(
|
||
"struktur.abschnitte.1.schritte.2.titel: Ein Schritt braucht einen Titel.",
|
||
);
|
||
});
|
||
|
||
it("weist doppelte Variablenschluessel ab und nennt den Schluessel", async () => {
|
||
const doppelt = dokument({
|
||
struktur: {
|
||
variablen: [
|
||
{ schluessel: "vorname", beschriftung: "Vorname" },
|
||
{ schluessel: "vorname", beschriftung: "Rufname" },
|
||
],
|
||
abschnitte: [],
|
||
},
|
||
});
|
||
await expect(vorlageImportieren(doppelt, "wer")).rejects.toThrow(/„vorname“ gibt es zweimal/);
|
||
});
|
||
|
||
it("weist ungueltige Variablenschluessel ab", async () => {
|
||
// Der Schluessel steht als {{schluessel}} in Texten; ein Grossbuchstabe oder
|
||
// ein Strich liesse sich dort nicht sauber wiedererkennen.
|
||
for (const schluessel of ["Vorname", "mit-strich", "", "1vorname", "mit punkt"]) {
|
||
const falsch = dokument({
|
||
struktur: { variablen: [{ schluessel, beschriftung: "Egal" }], abschnitte: [] },
|
||
});
|
||
await expect(vorlageImportieren(falsch, "wer")).rejects.toThrow(AustauschFehler);
|
||
}
|
||
});
|
||
|
||
it("weist einen Doku-Link ab, der kein http ist", async () => {
|
||
// Der Doku-Link landet in der Abarbeitungsansicht als `href`. Ein
|
||
// `javascript:`-Link darin waere fremder Code im Browser des Technikers –
|
||
// eingespielt ueber eine Datei, die ein Kunde geschickt hat.
|
||
for (const link of [
|
||
"javascript:alert(1)",
|
||
"JavaScript:alert(1)",
|
||
"data:text/html,<script>alert(1)</script>",
|
||
"file:///etc/passwd",
|
||
"intern.example/doku",
|
||
]) {
|
||
const kaputt = dokument({
|
||
struktur: {
|
||
variablen: [],
|
||
abschnitte: [{ titel: "Start", schritte: [{ titel: "Anfangen", dokuUrl: link }] }],
|
||
},
|
||
});
|
||
await expect(vorlageImportieren(kaputt, "wer"), link).rejects.toThrow(/http/);
|
||
}
|
||
});
|
||
|
||
it("nimmt http und https an", async () => {
|
||
for (const link of ["http://intern.example/doku", "https://intern.example/doku"]) {
|
||
const gut = dokument({
|
||
struktur: {
|
||
variablen: [],
|
||
abschnitte: [{ titel: "Start", schritte: [{ titel: "Anfangen", dokuUrl: link }] }],
|
||
},
|
||
});
|
||
// Ohne Datenbank kommt es bis zum Schreiben; abgewiesen wird es nicht.
|
||
await expect(vorlageImportieren(gut, "wer")).rejects.not.toThrow(/http/);
|
||
}
|
||
});
|
||
|
||
it("weist ein Dokument ab, das die Mengengrenzen sprengt", async () => {
|
||
// Eine Datei mit 100 000 Schritten ist kein Import, sondern ein
|
||
// Erschoepfungsangriff auf die Datenbank.
|
||
const zuViele = dokument({
|
||
struktur: {
|
||
variablen: [],
|
||
abschnitte: Array.from({ length: GRENZEN.abschnitte + 1 }, (_, i) => ({
|
||
titel: `Abschnitt ${i}`,
|
||
schritte: [],
|
||
})),
|
||
},
|
||
});
|
||
await expect(vorlageImportieren(zuViele, "wer")).rejects.toThrow(
|
||
new RegExp(`${GRENZEN.abschnitte} Abschnitte`),
|
||
);
|
||
|
||
const zuLang = dokument({
|
||
struktur: {
|
||
variablen: [],
|
||
abschnitte: [{ titel: "Start", schritte: [{ titel: "x".repeat(GRENZEN.text + 1) }] }],
|
||
},
|
||
});
|
||
await expect(vorlageImportieren(zuLang, "wer")).rejects.toThrow(AustauschFehler);
|
||
});
|
||
|
||
it("weist einen unbekannten Schritt-Typ ab", async () => {
|
||
// Ein unbekannter Typ wuerde in der Abarbeitung zu einem Schritt ohne
|
||
// Eingabefeld – der Techniker koennte ihn nie erledigen.
|
||
const kaputt = dokument({
|
||
struktur: {
|
||
variablen: [],
|
||
abschnitte: [{ titel: "Start", schritte: [{ titel: "Anfangen", typ: "AKTION" }] }],
|
||
},
|
||
});
|
||
await expect(vorlageImportieren(kaputt, "wer")).rejects.toThrow(AustauschFehler);
|
||
});
|
||
|
||
it("nennt bei einem ungueltigen Schluessel den Pfad und die Regel", async () => {
|
||
const falsch = dokument({
|
||
struktur: { variablen: [{ schluessel: "Vorname", beschriftung: "Egal" }], abschnitte: [] },
|
||
});
|
||
await expect(vorlageImportieren(falsch, "wer")).rejects.toThrow(
|
||
/^struktur\.variablen\.0\.schluessel: Ein Variablenschlüssel beginnt/,
|
||
);
|
||
});
|
||
});
|
||
|
||
describe.runIf(datenbankVerfuegbar)("Vorlagen-Austausch", () => {
|
||
beforeEach(async () => {
|
||
await datenbankLeeren();
|
||
});
|
||
|
||
describe("Export", () => {
|
||
it("liefert Abschnitte, Schritte und Variablen in der Reihenfolge der Position", async () => {
|
||
const versionId = await beispielVersionAnlegen();
|
||
const austausch = await vorlageExportieren(versionId);
|
||
|
||
expect(austausch.format).toBe(1);
|
||
expect(austausch.name).toBe("Onboarding Notebook");
|
||
expect(austausch.kategorie).toBe("Onboarding");
|
||
expect(austausch.schlagworte).toEqual(["notebook", "eintritt"]);
|
||
expect(austausch.version).toBe(3);
|
||
|
||
expect(austausch.struktur.variablen.map((v) => v.schluessel)).toEqual(["vorname", "abteilung"]);
|
||
expect(austausch.struktur.abschnitte.map((a) => a.titel)).toEqual(["01 · Vorbereitung", "02 · Konto"]);
|
||
expect(austausch.struktur.abschnitte[0]?.schritte.map((s) => s.titel)).toEqual([
|
||
"Gerät auspacken",
|
||
"Seriennummer erfassen",
|
||
"Arbeitsspeicher prüfen",
|
||
]);
|
||
expect(austausch.struktur.abschnitte[1]?.schritte.map((s) => s.typ)).toEqual(["BEFEHL", "DATUM"]);
|
||
});
|
||
|
||
it("enthaelt keine Kennungen, Positionen und keinen Kundenbezug", async () => {
|
||
const versionId = await beispielVersionAnlegen();
|
||
const austausch = await vorlageExportieren(versionId);
|
||
const rohtext = JSON.stringify(austausch);
|
||
|
||
expect(rohtext).not.toContain(versionId);
|
||
for (const feld of ['"id"', "versionId", "abschnittId", "position", "kundeId", "erstelltAm"]) {
|
||
expect(rohtext).not.toContain(feld);
|
||
}
|
||
});
|
||
|
||
it("wirft bei einer unbekannten Version", async () => {
|
||
await expect(vorlageExportieren("gibt-es-nicht")).rejects.toThrow(AustauschFehler);
|
||
});
|
||
});
|
||
|
||
describe("Import", () => {
|
||
it("legt eine neue Vorlage mit Version 1 im Status ENTWURF an", async () => {
|
||
const redakteur = await redakteurAnlegen();
|
||
const quelle = await beispielVersionAnlegen();
|
||
const austausch = await vorlageExportieren(quelle);
|
||
|
||
const { vorlageId, versionId } = await vorlageImportieren(austausch, redakteur.id);
|
||
|
||
// Die Quelle bleibt unberuehrt, es gibt jetzt zwei Vorlagen.
|
||
expect(await testPrisma.vorlage.count()).toBe(2);
|
||
const version = await testPrisma.vorlagenVersion.findUniqueOrThrow({
|
||
where: { id: versionId },
|
||
});
|
||
expect(version.vorlageId).toBe(vorlageId);
|
||
expect(version.version).toBe(1);
|
||
expect(version.status).toBe("ENTWURF");
|
||
expect(version.veroeffentlichtAm).toBeNull();
|
||
expect(await testPrisma.vorlagenVersion.count({ where: { vorlageId } })).toBe(1);
|
||
});
|
||
|
||
it("leitet die Positionen aus der Reihenfolge der Listen ab", async () => {
|
||
const redakteur = await redakteurAnlegen();
|
||
const { versionId } = await vorlageImportieren(
|
||
dokument({
|
||
struktur: {
|
||
variablen: [
|
||
{ schluessel: "vorname", beschriftung: "Vorname" },
|
||
{ schluessel: "nachname", beschriftung: "Nachname" },
|
||
],
|
||
abschnitte: [
|
||
{ titel: "01 · Start", schritte: [{ titel: "Eins" }, { titel: "Zwei" }] },
|
||
{ titel: "02 · Ende", schritte: [{ titel: "Drei" }] },
|
||
],
|
||
},
|
||
}),
|
||
redakteur.id,
|
||
);
|
||
|
||
const variablen = await testPrisma.vorlagenVariable.findMany({
|
||
where: { versionId },
|
||
orderBy: { position: "asc" },
|
||
});
|
||
expect(variablen.map((v) => [v.schluessel, v.position])).toEqual([
|
||
["vorname", 0],
|
||
["nachname", 1],
|
||
]);
|
||
|
||
const abschnitte = await testPrisma.vorlagenAbschnitt.findMany({
|
||
where: { versionId },
|
||
orderBy: { position: "asc" },
|
||
include: { schritte: { orderBy: { position: "asc" } } },
|
||
});
|
||
expect(abschnitte.map((a) => a.position)).toEqual([0, 1]);
|
||
expect(abschnitte[0]?.schritte.map((s) => [s.titel, s.position])).toEqual([
|
||
["Eins", 0],
|
||
["Zwei", 1],
|
||
]);
|
||
expect(abschnitte[1]?.schritte.map((s) => s.position)).toEqual([0]);
|
||
});
|
||
|
||
it("nimmt einen Namen, den es schon gibt, ohne Murren an", async () => {
|
||
const redakteur = await redakteurAnlegen();
|
||
await vorlageImportieren(dokument(), redakteur.id);
|
||
await vorlageImportieren(dokument(), redakteur.id);
|
||
|
||
const gleichnamige = await testPrisma.vorlage.findMany({ where: { name: "Kleine Vorlage" } });
|
||
expect(gleichnamige).toHaveLength(2);
|
||
// Kein angehaengtes "(2)": der Name kommt so an, wie er im Dokument steht.
|
||
expect(gleichnamige.map((v) => v.name)).toEqual(["Kleine Vorlage", "Kleine Vorlage"]);
|
||
});
|
||
|
||
it("schreibt einen Protokolleintrag", async () => {
|
||
const redakteur = await redakteurAnlegen();
|
||
const { vorlageId } = await vorlageImportieren(dokument(), redakteur.id);
|
||
|
||
const eintraege = await testPrisma.protokoll.findMany({
|
||
where: { entitaet: "Vorlage", entitaetId: vorlageId },
|
||
});
|
||
expect(eintraege).toHaveLength(1);
|
||
expect(eintraege[0]?.aktion).toBe("Vorlage importiert");
|
||
expect(eintraege[0]?.benutzerId).toBe(redakteur.id);
|
||
});
|
||
|
||
it("hinterlaesst nach einem Fehlschlag keine halbe Vorlage", async () => {
|
||
// Ein unbekannter Benutzer laesst den Protokolleintrag am Fremdschluessel
|
||
// scheitern – also erst, nachdem Vorlage, Version und Schritte geschrieben
|
||
// sind. Genau dieser Fall zeigt, dass die Transaktion greift.
|
||
await expect(vorlageImportieren(dokument(), "gibt-es-nicht")).rejects.toThrow();
|
||
|
||
expect(await testPrisma.vorlage.count()).toBe(0);
|
||
expect(await testPrisma.vorlagenVersion.count()).toBe(0);
|
||
expect(await testPrisma.vorlagenAbschnitt.count()).toBe(0);
|
||
expect(await testPrisma.vorlagenSchritt.count()).toBe(0);
|
||
expect(await testPrisma.vorlagenVariable.count()).toBe(0);
|
||
expect(await testPrisma.protokoll.count()).toBe(0);
|
||
});
|
||
|
||
it("schreibt nichts, wenn das Dokument abgewiesen wird", async () => {
|
||
await expect(vorlageImportieren(dokument({ format: 99 }), "wer")).rejects.toThrow(AustauschFehler);
|
||
expect(await testPrisma.vorlage.count()).toBe(0);
|
||
});
|
||
});
|
||
|
||
describe("Rundlauf", () => {
|
||
it("ergibt ein inhaltsgleiches Dokument – bis auf die Version", async () => {
|
||
const redakteur = await redakteurAnlegen();
|
||
const quelle = await beispielVersionAnlegen();
|
||
|
||
const erst = await vorlageExportieren(quelle);
|
||
const { versionId } = await vorlageImportieren(erst, redakteur.id);
|
||
const wieder = await vorlageExportieren(versionId);
|
||
|
||
expect(ohneVersion(wieder)).toEqual(ohneVersion(erst));
|
||
// Die Quelle stand auf Version 3, die eingespielte Vorlage faengt bei 1 an.
|
||
expect(erst.version).toBe(3);
|
||
expect(wieder.version).toBe(1);
|
||
});
|
||
|
||
it("laesst einen BEFEHL-Schritt samt Platzhaltern unveraendert", async () => {
|
||
const redakteur = await redakteurAnlegen();
|
||
const quelle = await beispielVersionAnlegen();
|
||
const { versionId } = await vorlageImportieren(await vorlageExportieren(quelle), redakteur.id);
|
||
|
||
const schritt = (await vorlageExportieren(versionId)).struktur.abschnitte[1]?.schritte[0];
|
||
expect(schritt?.typ).toBe("BEFEHL");
|
||
expect(schritt?.konfig["shell"]).toBe("powershell");
|
||
expect(schritt?.konfig["befehl"]).toBe(BEFEHL);
|
||
});
|
||
|
||
it("bewahrt unbekannte konfig-Schluessel", async () => {
|
||
const redakteur = await redakteurAnlegen();
|
||
const quelle = await beispielVersionAnlegen();
|
||
const { versionId } = await vorlageImportieren(await vorlageExportieren(quelle), redakteur.id);
|
||
|
||
const schritt = (await vorlageExportieren(versionId)).struktur.abschnitte[1]?.schritte[0];
|
||
expect(schritt?.konfig["kuenftigesFeld"]).toEqual({ tief: [1, 2] });
|
||
});
|
||
|
||
it("bewahrt Hilfetext, Doku-Link und Zahlengrenzen", async () => {
|
||
const redakteur = await redakteurAnlegen();
|
||
const quelle = await beispielVersionAnlegen();
|
||
const { versionId } = await vorlageImportieren(await vorlageExportieren(quelle), redakteur.id);
|
||
|
||
const schritte = (await vorlageExportieren(versionId)).struktur.abschnitte[0]?.schritte;
|
||
expect(schritte?.[1]?.hilfetext).toBe("Aufkleber auf der Unterseite.");
|
||
expect(schritte?.[1]?.dokuUrl).toBe("https://intern.example/seriennummern");
|
||
expect(schritte?.[2]?.konfig).toEqual({ min: 8, max: 64, einheit: "GB" });
|
||
});
|
||
});
|
||
|
||
describe("Export unsauberer Daten", () => {
|
||
/** Legt einen einzelnen Schritt mit frei gewaehltem `konfig` an. */
|
||
async function schrittMitKonfig(konfig: unknown): Promise<string> {
|
||
const vorlage = await testPrisma.vorlage.create({ data: { name: "Krumm" } });
|
||
const version = await testPrisma.vorlagenVersion.create({
|
||
data: { vorlageId: vorlage.id, version: 1, status: "ENTWURF" },
|
||
});
|
||
const abschnitt = await testPrisma.vorlagenAbschnitt.create({
|
||
data: { versionId: version.id, titel: "Abschnitt" },
|
||
});
|
||
await testPrisma.vorlagenSchritt.create({
|
||
data: {
|
||
abschnittId: abschnitt.id,
|
||
titel: "Schritt",
|
||
typ: "BEFEHL",
|
||
konfig: konfig as never,
|
||
},
|
||
});
|
||
return version.id;
|
||
}
|
||
|
||
it("verliert bei einer unbekannten Shell nicht den Befehl", async () => {
|
||
// Das war ein echter Befund: `safeParse` verwarf bei jeder Beanstandung
|
||
// das ganze `konfig` – eine Shell aus einer spaeteren Fassung kostete
|
||
// lautlos auch den Befehl. Genau die Datei, die jemand zum Umzug braucht.
|
||
const versionId = await schrittMitKonfig({ shell: "zsh", befehl: "echo hallo" });
|
||
const schritt = (await vorlageExportieren(versionId)).struktur.abschnitte[0]?.schritte[0];
|
||
expect(schritt?.konfig["befehl"]).toBe("echo hallo");
|
||
expect(schritt?.konfig["shell"]).toBe("zsh");
|
||
});
|
||
|
||
it("liefert für konfig-Werte, die gar kein Objekt sind, ein leeres Objekt", async () => {
|
||
for (const krumm of ["kaputt", 42, [1, 2], true]) {
|
||
const versionId = await schrittMitKonfig(krumm);
|
||
const schritt = (await vorlageExportieren(versionId)).struktur.abschnitte[0]?.schritte[0];
|
||
expect(schritt?.konfig, JSON.stringify(krumm)).toEqual({});
|
||
await datenbankLeeren();
|
||
}
|
||
});
|
||
|
||
it("lässt sich mit unbekanntem konfig-Schlüssel wieder einspielen", async () => {
|
||
// Der Export muss nicht nur gelingen, er muss auch durch die Pruefung des
|
||
// Imports kommen – sonst waere er eine Datei, die niemand nutzen kann.
|
||
const redakteur = await redakteurAnlegen();
|
||
const versionId = await schrittMitKonfig({ shell: "bash", befehl: "echo", tief: null });
|
||
const { versionId: neu } = await vorlageImportieren(await vorlageExportieren(versionId), redakteur.id);
|
||
const schritt = (await vorlageExportieren(neu)).struktur.abschnitte[0]?.schritte[0];
|
||
expect(schritt?.konfig["befehl"]).toBe("echo");
|
||
expect(schritt?.konfig["tief"]).toBeNull();
|
||
});
|
||
|
||
it("weist eine unbekannte Shell beim Einspielen laut ab", async () => {
|
||
// Hier laufen zwei Regeln absichtlich auseinander, und das ist die
|
||
// Entscheidung: der **Export** gibt eine unbekannte Shell heraus, damit die
|
||
// Datei nichts verliert; der **Import** weist sie ab, weil `shell` darueber
|
||
// entscheidet, wie ein Wert maskiert wird. Eine stillschweigend verworfene
|
||
// Shell hiesse, einen bash-Befehl nach PowerShell-Regeln zu maskieren – das
|
||
// kann auf einem Server Daten kosten. Die Meldung nennt Pfad und erlaubte
|
||
// Werte, also kann der Redakteur die Datei richtigstellen.
|
||
const redakteur = await redakteurAnlegen();
|
||
const versionId = await schrittMitKonfig({ shell: "zsh", befehl: "echo hallo" });
|
||
const dokument = await vorlageExportieren(versionId);
|
||
|
||
await expect(vorlageImportieren(dokument, redakteur.id)).rejects.toThrow(/schritte\.0\.konfig\.shell/);
|
||
await expect(vorlageImportieren(dokument, redakteur.id)).rejects.toThrow(/powershell/);
|
||
// Nur die eine Quellvorlage steht da, keine halb eingespielte zweite.
|
||
expect(await testPrisma.vorlage.count()).toBe(1);
|
||
});
|
||
|
||
it("weist einen bereits gespeicherten javascript-Link beim Wiedereinspielen ab", async () => {
|
||
// Aeltere Zeilen koennten so einen Link tragen, denn die Pruefung kam erst
|
||
// mit #009. Der Export gibt ihn heraus, der Import faengt ihn – die Datei
|
||
// ist dann ein sichtbarer Fehlerfall und kein stiller Durchlaeufer.
|
||
const redakteur = await redakteurAnlegen();
|
||
const vorlage = await testPrisma.vorlage.create({ data: { name: "Alt" } });
|
||
const version = await testPrisma.vorlagenVersion.create({
|
||
data: { vorlageId: vorlage.id, version: 1, status: "ENTWURF" },
|
||
});
|
||
const abschnitt = await testPrisma.vorlagenAbschnitt.create({
|
||
data: { versionId: version.id, titel: "Abschnitt" },
|
||
});
|
||
await testPrisma.vorlagenSchritt.create({
|
||
data: { abschnittId: abschnitt.id, titel: "Schritt", dokuUrl: "javascript:alert(1)" },
|
||
});
|
||
|
||
const dokument = await vorlageExportieren(version.id);
|
||
expect(dokument.struktur.abschnitte[0]?.schritte[0]?.dokuUrl).toBe("javascript:alert(1)");
|
||
await expect(vorlageImportieren(dokument, redakteur.id)).rejects.toThrow(/http/);
|
||
expect(await testPrisma.vorlage.count()).toBe(1);
|
||
});
|
||
});
|
||
});
|