560 lines
24 KiB
TypeScript
560 lines
24 KiB
TypeScript
import { beforeEach, describe, expect, it } from "vitest";
|
||
import { Betriebsmodus, GeraeteTyp, Rolle } from "@/generated/prisma/enums";
|
||
import { istTagCode } from "@/lib/tagcode";
|
||
import {
|
||
GERAETE_IMPORT_HOECHSTZEILEN,
|
||
GeraeteFehler,
|
||
geraeteImportieren,
|
||
geraetAnlegen,
|
||
geraetArchivieren,
|
||
geraetBearbeiten,
|
||
geraetLoeschen,
|
||
} from "@/server/services/geraete";
|
||
import { besitzerKandidaten, geraetHolen, geraeteListe } from "@/server/queries/geraete";
|
||
import { datenbankLeeren, datenbankVerfuegbar, testPrisma } from "./helpers/db";
|
||
|
||
/**
|
||
* Geräte, Tag-Codes und der CSV-Import (#011).
|
||
*
|
||
* Festgehalten werden die Zusagen aus dem Auftrag: ein registriertes Gerät hat
|
||
* einen Namen, ein `tagCode` ändert sich nie und kommt nie zurück, an einem
|
||
* Gerät mit Läufen wird nichts gelöscht, und eine kaputte CSV-Zeile bricht den
|
||
* Import nicht ab. Dazu die Mandantensicht des Lesemodells — im Review von #009
|
||
* war genau dort ein Suchfilter, der die Kundenbedingung überschrieben hat.
|
||
*/
|
||
|
||
async function grundbestand(modus: Betriebsmodus = Betriebsmodus.INTERN) {
|
||
const eigene = await testPrisma.kunde.create({
|
||
data: { name: "Eigene Organisation", kuerzel: "EIGEN", istEigeneOrganisation: true },
|
||
});
|
||
await testPrisma.einstellung.create({ data: { id: "global", modus } });
|
||
const benutzer = await testPrisma.benutzer.create({
|
||
data: { email: "admin@firma.example", name: "Administrator", rolle: Rolle.ADMIN },
|
||
});
|
||
return { eigene, admin: { id: benutzer.id, rolle: Rolle.ADMIN } };
|
||
}
|
||
|
||
/** Ein Lauf an einem Gerät – mehr braucht es dafür nicht als eine veröffentlichte Version. */
|
||
async function laufAnlegen(kundeId: string, geraetId: string) {
|
||
const vorlage = await testPrisma.vorlage.create({ data: { name: "PC-Neuinstallation" } });
|
||
const version = await testPrisma.vorlagenVersion.create({
|
||
data: {
|
||
vorlageId: vorlage.id,
|
||
version: 1,
|
||
status: "VEROEFFENTLICHT",
|
||
veroeffentlichtAm: new Date(),
|
||
},
|
||
});
|
||
return testPrisma.lauf.create({
|
||
data: { vorlagenVersionId: version.id, titel: "Neuinstallation", kundeId, geraetId },
|
||
});
|
||
}
|
||
|
||
describe.runIf(datenbankVerfuegbar)("Geräte", () => {
|
||
beforeEach(async () => {
|
||
await datenbankLeeren();
|
||
delete process.env["OIDC_CUSTOMER_GROUP_PREFIX"];
|
||
});
|
||
|
||
describe("Anlegen", () => {
|
||
it("erzeugt einen Tag-Code und schreibt ihn ins Vergabebuch", async () => {
|
||
const { admin, eigene } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-VERTRIEB-07", typ: GeraeteTyp.PC }, admin);
|
||
|
||
expect(istTagCode(geraet.tagCode)).toBe(true);
|
||
expect(geraet.kundeId).toBe(eigene.id);
|
||
expect(geraet.registriertAm).not.toBeNull();
|
||
// Beides in einer Transaktion: ein Code ohne Eintrag wäre nach dem Löschen
|
||
// des Geräts wieder frei.
|
||
await expect(
|
||
testPrisma.tagCodeVergabe.findUnique({ where: { tagCode: geraet.tagCode } }),
|
||
).resolves.not.toBeNull();
|
||
});
|
||
|
||
it("lehnt ein registriertes Gerät ohne Hostname und ohne Bezeichnung ab", async () => {
|
||
const { admin } = await grundbestand();
|
||
await expect(geraetAnlegen({ seriennummer: "SN-1" }, admin)).rejects.toThrow(GeraeteFehler);
|
||
await expect(geraetAnlegen({ hostname: " ", bezeichnung: "" }, admin)).rejects.toThrow(
|
||
/Hostname oder eine Bezeichnung/,
|
||
);
|
||
// Und es ist auch kein Tag-Code verbraucht worden.
|
||
expect(await testPrisma.tagCodeVergabe.count()).toBe(0);
|
||
expect(await testPrisma.geraet.count()).toBe(0);
|
||
});
|
||
|
||
it("erlaubt einen vorgedruckten Tag ohne jeden Namen", async () => {
|
||
const { admin } = await grundbestand();
|
||
const tag = await geraetAnlegen({ registrieren: false }, admin);
|
||
expect(tag.registriertAm).toBeNull();
|
||
expect(tag.hostname).toBeNull();
|
||
expect(tag.bezeichnung).toBeNull();
|
||
});
|
||
|
||
it("nimmt einen Besitzer nur, wenn er zum selben Kunden gehört", async () => {
|
||
const { admin, eigene } = await grundbestand();
|
||
const fremder = await testPrisma.kunde.create({ data: { name: "Fremder", kuerzel: "FREMD" } });
|
||
const eigenePerson = await testPrisma.mitarbeiter.create({
|
||
data: { kundeId: eigene.id, vorname: "Ada", nachname: "Lovelace", anzeigename: "Ada Lovelace" },
|
||
});
|
||
const fremdePerson = await testPrisma.mitarbeiter.create({
|
||
data: { kundeId: fremder.id, vorname: "Max", nachname: "Fremd", anzeigename: "Max Fremd" },
|
||
});
|
||
|
||
const geraet = await geraetAnlegen(
|
||
{ hostname: "NB-ADA", typ: GeraeteTyp.NOTEBOOK, mitarbeiterId: eigenePerson.id },
|
||
admin,
|
||
);
|
||
expect(geraet.mitarbeiterId).toBe(eigenePerson.id);
|
||
|
||
await expect(
|
||
geraetAnlegen({ hostname: "NB-MAX", mitarbeiterId: fremdePerson.id }, admin),
|
||
).rejects.toThrow(/anderen Kunden/);
|
||
});
|
||
|
||
it("protokolliert das Anlegen", async () => {
|
||
const { admin } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ bezeichnung: "Serverschrank Keller" }, admin);
|
||
const eintraege = await testPrisma.protokoll.findMany({
|
||
where: { entitaet: "Geraet", entitaetId: geraet.id },
|
||
});
|
||
expect(eintraege).toHaveLength(1);
|
||
expect(eintraege[0]?.aktion).toBe("Gerät angelegt");
|
||
expect(eintraege[0]?.nachher).toMatchObject({ tagCode: geraet.tagCode });
|
||
});
|
||
});
|
||
|
||
describe("Bearbeiten", () => {
|
||
it("weist jeden Änderungsversuch am Tag-Code ab", async () => {
|
||
const { admin } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-1" }, admin);
|
||
|
||
await expect(
|
||
geraetBearbeiten(geraet.id, { tagCode: "LZ-ZZZZZZ", hostname: "PC-2" }, admin),
|
||
).rejects.toThrow(/bleibt, wie er ist/);
|
||
|
||
// Nichts ist passiert – auch nicht der Hostname, der im selben Aufruf stand.
|
||
const frisch = await testPrisma.geraet.findUniqueOrThrow({ where: { id: geraet.id } });
|
||
expect(frisch.tagCode).toBe(geraet.tagCode);
|
||
expect(frisch.hostname).toBe("PC-1");
|
||
});
|
||
|
||
it("lässt den unveränderten Tag-Code mitkommen, ohne sich zu beschweren", async () => {
|
||
const { admin } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-1" }, admin);
|
||
const nachher = await geraetBearbeiten(geraet.id, { tagCode: geraet.tagCode, hostname: "PC-2" }, admin);
|
||
expect(nachher.hostname).toBe("PC-2");
|
||
});
|
||
|
||
it("lässt den Hostname nicht leeren, wenn dann kein Name übrig bleibt", async () => {
|
||
const { admin } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-1" }, admin);
|
||
await expect(geraetBearbeiten(geraet.id, { hostname: "" }, admin)).rejects.toThrow(
|
||
/Hostname oder eine Bezeichnung/,
|
||
);
|
||
// Mit einer Bezeichnung als Ersatz geht es.
|
||
const nachher = await geraetBearbeiten(
|
||
geraet.id,
|
||
{ hostname: "", bezeichnung: "Kiste im Regal" },
|
||
admin,
|
||
);
|
||
expect(nachher.hostname).toBeNull();
|
||
expect(nachher.bezeichnung).toBe("Kiste im Regal");
|
||
});
|
||
|
||
it("protokolliert nur, was sich geändert hat", async () => {
|
||
const { admin } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-1", seriennummer: "SN-1" }, admin);
|
||
await geraetBearbeiten(geraet.id, { hostname: "PC-2", seriennummer: "SN-1" }, admin);
|
||
|
||
const eintrag = await testPrisma.protokoll.findFirstOrThrow({
|
||
where: { entitaet: "Geraet", entitaetId: geraet.id, aktion: { contains: "geändert" } },
|
||
});
|
||
expect(eintrag.aktion).toBe("Hostname geändert");
|
||
expect(eintrag.vorher).toMatchObject({ Hostname: "PC-1" });
|
||
expect(eintrag.nachher).toMatchObject({ Hostname: "PC-2" });
|
||
expect(eintrag.nachher).not.toHaveProperty("Seriennummer");
|
||
});
|
||
|
||
it("schreibt gar nichts, wenn sich nichts geändert hat", async () => {
|
||
const { admin } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-1" }, admin);
|
||
await geraetBearbeiten(geraet.id, { hostname: "PC-1" }, admin);
|
||
expect(await testPrisma.protokoll.count({ where: { aktion: { contains: "geändert" } } })).toBe(0);
|
||
});
|
||
|
||
it("registriert einen vorgedruckten Tag, sobald er einen Namen bekommt", async () => {
|
||
const { admin } = await grundbestand();
|
||
const tag = await geraetAnlegen({ registrieren: false }, admin);
|
||
await expect(geraetBearbeiten(tag.id, { registrieren: true }, admin)).rejects.toThrow(
|
||
/Hostname oder eine Bezeichnung/,
|
||
);
|
||
const nachher = await geraetBearbeiten(tag.id, { registrieren: true, hostname: "PC-NEU" }, admin);
|
||
expect(nachher.registriertAm).not.toBeNull();
|
||
expect(nachher.tagCode).toBe(tag.tagCode);
|
||
});
|
||
});
|
||
|
||
describe("Archivieren und Löschen", () => {
|
||
it("lässt ein Gerät mit Läufen nicht löschen, nur archivieren", async () => {
|
||
const { admin, eigene } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-1" }, admin);
|
||
await laufAnlegen(eigene.id, geraet.id);
|
||
|
||
await expect(geraetLoeschen(geraet.id, admin)).rejects.toThrow(/nur archivieren/);
|
||
expect(await testPrisma.geraet.count()).toBe(1);
|
||
|
||
await geraetArchivieren(geraet.id, true, admin);
|
||
const frisch = await testPrisma.geraet.findUniqueOrThrow({ where: { id: geraet.id } });
|
||
expect(frisch.archiviert).toBe(true);
|
||
// Und zurück.
|
||
await geraetArchivieren(geraet.id, false, admin);
|
||
await expect(testPrisma.geraet.findUniqueOrThrow({ where: { id: geraet.id } })).resolves.toMatchObject({
|
||
archiviert: false,
|
||
});
|
||
});
|
||
|
||
it("gibt einen Tag-Code auch nach dem Löschen nicht zurück", async () => {
|
||
const { admin } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-WEG" }, admin);
|
||
await geraetLoeschen(geraet.id, admin);
|
||
|
||
expect(await testPrisma.geraet.count()).toBe(0);
|
||
// Das Vergabebuch behält ihn: ein übrig gebliebener Aufkleber darf nie auf
|
||
// ein zweites Objekt zeigen.
|
||
await expect(
|
||
testPrisma.tagCodeVergabe.findUnique({ where: { tagCode: geraet.tagCode } }),
|
||
).resolves.not.toBeNull();
|
||
});
|
||
|
||
it("protokolliert das Löschen, und der Eintrag überlebt das Gerät", async () => {
|
||
const { admin } = await grundbestand();
|
||
const geraet = await geraetAnlegen({ hostname: "PC-WEG" }, admin);
|
||
await geraetLoeschen(geraet.id, admin);
|
||
const eintrag = await testPrisma.protokoll.findFirstOrThrow({
|
||
where: { entitaetId: geraet.id, aktion: "Gerät gelöscht" },
|
||
});
|
||
expect(eintrag.vorher).toMatchObject({ tagCode: geraet.tagCode, hostname: "PC-WEG" });
|
||
});
|
||
});
|
||
|
||
describe("CSV-Import", () => {
|
||
it("verliert keine Zeile an einem kaputten Anführungszeichen", async () => {
|
||
/*
|
||
* Der Blocker aus dem Review: ein Anführungszeichen, das in einer Zelle
|
||
* beginnt und nicht schliesst, verschluckte alle Folgezeilen bis zum
|
||
* naechsten `"`. Der Import meldete dafuer **Erfolg** — drei von drei
|
||
* Zeilen angelegt —, und in einer Bezeichnung stand der Text der
|
||
* verschluckten Zeilen. Jetzt endet der Schaden an seiner Zeile.
|
||
*/
|
||
const { admin } = await grundbestand();
|
||
const text = [
|
||
"hostname,label,serialNumber",
|
||
"PC-1,,SN-1",
|
||
'PC-2,"Regal,SN-2',
|
||
"PC-3,,SN-3",
|
||
'PC-4,"Kiste",SN-4',
|
||
"PC-5,,SN-5",
|
||
].join("\n");
|
||
|
||
const ergebnis = await geraeteImportieren(text, admin);
|
||
|
||
expect(ergebnis.angelegt).toBe(4);
|
||
expect(ergebnis.abgewiesen).toHaveLength(1);
|
||
expect(ergebnis.abgewiesen[0]?.zeile).toBe(3);
|
||
expect(ergebnis.abgewiesen[0]?.grund).toMatch(/Anführungszeichen/);
|
||
|
||
const namen = (await testPrisma.geraet.findMany({ select: { hostname: true } }))
|
||
.map((zeile) => zeile.hostname)
|
||
.sort();
|
||
expect(namen).toEqual(["PC-1", "PC-3", "PC-4", "PC-5"]);
|
||
});
|
||
|
||
it("weist eine doppelte Zeile ab, statt den Bestand zu verdoppeln", async () => {
|
||
// Dieselbe Datei zweimal eingelesen verdoppelte sonst alles – und weil ein
|
||
// tagCode nie zurueckkommt, waeren die Aufkleber dafuer schon gedruckt.
|
||
const { admin } = await grundbestand();
|
||
const text = ["hostname", "PC-DOPPELT", "PC-DOPPELT", "PC-EINMAL"].join("\n");
|
||
|
||
const erster = await geraeteImportieren(text, admin);
|
||
expect(erster.angelegt).toBe(2);
|
||
expect(erster.abgewiesen[0]?.grund).toMatch(/schon weiter oben/);
|
||
|
||
const zweiter = await geraeteImportieren(text, admin);
|
||
expect(zweiter.angelegt).toBe(0);
|
||
expect(zweiter.abgewiesen).toHaveLength(3);
|
||
expect(zweiter.abgewiesen[0]?.grund).toMatch(/gibt es schon/);
|
||
expect(await testPrisma.geraet.count()).toBe(2);
|
||
});
|
||
|
||
const KOPF = "hostname,label,serialNumber,inventoryNumber,type,model";
|
||
|
||
it("legt die guten Zeilen an und meldet die kaputten einzeln", async () => {
|
||
const { admin } = await grundbestand();
|
||
const text = [
|
||
KOPF,
|
||
"PC-BUERO-01,,SN-1,INV-1,PC,OptiPlex",
|
||
",Serverschrank Keller,,,SONSTIGES,",
|
||
"PC-KAPUTT,,SN-3,,Tablet,", // unbekannter Typ
|
||
",,SN-4,,PC,", // weder Hostname noch Bezeichnung
|
||
"NB-05,,SN-5,,notebook,Latitude", // Schreibweise unerheblich
|
||
].join("\r\n");
|
||
|
||
const ergebnis = await geraeteImportieren(text, admin);
|
||
expect(ergebnis.gesamt).toBe(5);
|
||
expect(ergebnis.angelegt).toBe(3);
|
||
// Zeilennummern wie in der Datei: Kopfzeile ist 1.
|
||
expect(ergebnis.abgewiesen.map((a) => a.zeile)).toEqual([4, 5]);
|
||
expect(ergebnis.abgewiesen[0]?.grund).toMatch(/kein bekannter Gerätetyp/);
|
||
expect(ergebnis.abgewiesen[1]?.grund).toMatch(/Weder ein Hostname noch eine Bezeichnung/);
|
||
|
||
const geraete = await testPrisma.geraet.findMany({ orderBy: { tagCode: "asc" } });
|
||
expect(geraete.map((g) => g.hostname ?? g.bezeichnung).sort()).toEqual([
|
||
"NB-05",
|
||
"PC-BUERO-01",
|
||
"Serverschrank Keller",
|
||
]);
|
||
expect(geraete.find((g) => g.hostname === "NB-05")?.typ).toBe(GeraeteTyp.NOTEBOOK);
|
||
});
|
||
|
||
it("erzeugt je Zeile einen eigenen Tag-Code und trägt jeden ein", async () => {
|
||
const { admin } = await grundbestand();
|
||
const text = [KOPF, "PC-1,,,,PC,", "PC-2,,,,PC,", "PC-3,,,,PC,"].join("\n");
|
||
await geraeteImportieren(text, admin);
|
||
|
||
const codes = (await testPrisma.geraet.findMany({ select: { tagCode: true } })).map((g) => g.tagCode);
|
||
expect(codes).toHaveLength(3);
|
||
expect(new Set(codes).size).toBe(3);
|
||
expect(codes.every(istTagCode)).toBe(true);
|
||
expect(await testPrisma.tagCodeVergabe.count()).toBe(3);
|
||
});
|
||
|
||
it("versteht deutsches Excel: Semikolon, BOM und deutsche Spaltennamen", async () => {
|
||
const { admin } = await grundbestand();
|
||
const text =
|
||
"Hostname;Bezeichnung;Seriennummer;Inventarnummer;Typ;Modell\r\n" +
|
||
'PC-EXCEL;;"SN;mit;Semikolon";INV-9;Drucker;"Kyocera ""P3260"""\r\n';
|
||
|
||
const ergebnis = await geraeteImportieren(text, admin);
|
||
expect(ergebnis.angelegt).toBe(1);
|
||
const geraet = await testPrisma.geraet.findFirstOrThrow();
|
||
expect(geraet.seriennummer).toBe("SN;mit;Semikolon");
|
||
expect(geraet.modell).toBe('Kyocera "P3260"');
|
||
expect(geraet.typ).toBe(GeraeteTyp.DRUCKER);
|
||
});
|
||
|
||
it("setzt ohne Typspalte den Standard, ohne etwas zu erfinden", async () => {
|
||
const { admin } = await grundbestand();
|
||
const ergebnis = await geraeteImportieren("hostname\nPC-OHNE-TYP\n", admin);
|
||
expect(ergebnis.angelegt).toBe(1);
|
||
await expect(testPrisma.geraet.findFirstOrThrow()).resolves.toMatchObject({
|
||
typ: GeraeteTyp.SONSTIGES,
|
||
});
|
||
});
|
||
|
||
it("weist eine Datei ohne Namensspalte als Ganzes ab", async () => {
|
||
const { admin } = await grundbestand();
|
||
await expect(geraeteImportieren("serialNumber,type\nSN-1,PC\n", admin)).rejects.toThrow(/hostname/);
|
||
expect(await testPrisma.geraet.count()).toBe(0);
|
||
});
|
||
|
||
it("bricht bei zu vielen Zeilen ab, bevor eine einzige geschrieben ist", async () => {
|
||
const { admin } = await grundbestand();
|
||
const zeilen = Array.from({ length: GERAETE_IMPORT_HOECHSTZEILEN + 1 }, (_, i) => `PC-${i},,,,PC,`);
|
||
await expect(geraeteImportieren([KOPF, ...zeilen].join("\n"), admin)).rejects.toThrow(
|
||
new RegExp(`mehr als ${GERAETE_IMPORT_HOECHSTZEILEN} Zeilen`),
|
||
);
|
||
expect(await testPrisma.geraet.count()).toBe(0);
|
||
});
|
||
|
||
it("protokolliert jede eingelesene Zeile mit ihrer Nummer", async () => {
|
||
const { admin } = await grundbestand();
|
||
await geraeteImportieren([KOPF, "PC-1,,,,PC,"].join("\n"), admin);
|
||
const eintrag = await testPrisma.protokoll.findFirstOrThrow({
|
||
where: { aktion: "Gerät aus CSV angelegt" },
|
||
});
|
||
expect(eintrag.nachher).toMatchObject({ hostname: "PC-1", zeile: 2 });
|
||
});
|
||
});
|
||
|
||
describe("Lesemodell und Filter", () => {
|
||
it("findet über Hostname, Bezeichnung, Seriennummer und Tag-Code", async () => {
|
||
const { admin } = await grundbestand();
|
||
const pc = await geraetAnlegen(
|
||
{ hostname: "PC-BUERO-01", seriennummer: "SN-4711", typ: GeraeteTyp.PC },
|
||
admin,
|
||
);
|
||
await geraetAnlegen({ bezeichnung: "Serverschrank Keller", typ: GeraeteTyp.SERVER }, admin);
|
||
|
||
const namen = async (suche: string) =>
|
||
(await geraeteListe(admin, { suche })).map((zeile) => zeile.anzeige);
|
||
|
||
expect(await namen("buero")).toEqual(["PC-BUERO-01"]);
|
||
expect(await namen("keller")).toEqual(["Serverschrank Keller"]);
|
||
expect(await namen("4711")).toEqual(["PC-BUERO-01"]);
|
||
// Die sechs Zeichen ohne das Präfix genügen – abgetippt vom Aufkleber.
|
||
expect(await namen(pc.tagCode.slice(3))).toEqual(["PC-BUERO-01"]);
|
||
});
|
||
|
||
it("filtert nach Typ und zeigt Archivierte nur auf Wunsch", async () => {
|
||
const { admin } = await grundbestand();
|
||
await geraetAnlegen({ hostname: "PC-1", typ: GeraeteTyp.PC }, admin);
|
||
const drucker = await geraetAnlegen({ bezeichnung: "Drucker Flur", typ: GeraeteTyp.DRUCKER }, admin);
|
||
await geraetArchivieren(drucker.id, true, admin);
|
||
|
||
expect((await geraeteListe(admin)).map((z) => z.anzeige)).toEqual(["PC-1"]);
|
||
expect((await geraeteListe(admin, { auchArchivierte: true })).map((z) => z.anzeige)).toEqual([
|
||
"PC-1",
|
||
"Drucker Flur",
|
||
]);
|
||
expect(
|
||
(await geraeteListe(admin, { typ: GeraeteTyp.DRUCKER, auchArchivierte: true })).map((z) => z.anzeige),
|
||
).toEqual(["Drucker Flur"]);
|
||
expect(await geraeteListe(admin, { typ: GeraeteTyp.FIREWALL })).toEqual([]);
|
||
});
|
||
|
||
it("zeigt Besitzer und Anzahl der Läufe", async () => {
|
||
const { admin, eigene } = await grundbestand();
|
||
const person = await testPrisma.mitarbeiter.create({
|
||
data: { kundeId: eigene.id, vorname: "Ada", nachname: "Lovelace", anzeigename: "Ada Lovelace" },
|
||
});
|
||
const geraet = await geraetAnlegen({ hostname: "NB-ADA", mitarbeiterId: person.id }, admin);
|
||
await laufAnlegen(eigene.id, geraet.id);
|
||
|
||
const zeile = await geraetHolen(geraet.id, admin);
|
||
expect(zeile?.besitzerName).toBe("Ada Lovelace");
|
||
expect(zeile?.besitzerAktiv).toBe(true);
|
||
expect(zeile?.anzahlLaeufe).toBe(1);
|
||
});
|
||
});
|
||
|
||
/**
|
||
* Die Mandantensicht. Der wichtigste Test dieser Datei: ein Suchbegriff darf
|
||
* die Kundenbedingung nicht aushebeln. Vor #009 tat er das, weil zwei `OR` im
|
||
* selben Objektliteral standen und das zweite gewann.
|
||
*/
|
||
describe("Mandantensicht", () => {
|
||
async function zweiKunden() {
|
||
const { eigene } = await grundbestand(Betriebsmodus.DIENSTLEISTUNG);
|
||
process.env["OIDC_CUSTOMER_GROUP_PREFIX"] = "lz-kunde-";
|
||
const meiner = await testPrisma.kunde.create({ data: { name: "Meiner", kuerzel: "MEIN" } });
|
||
const fremder = await testPrisma.kunde.create({ data: { name: "Fremder", kuerzel: "FREMD" } });
|
||
|
||
const techniker = await testPrisma.benutzer.create({
|
||
data: { email: "t@firma.example", name: "Techniker", rolle: Rolle.TECHNIKER },
|
||
});
|
||
await testPrisma.benutzerKunde.create({
|
||
data: { benutzerId: techniker.id, kundeId: meiner.id },
|
||
});
|
||
|
||
await testPrisma.geraet.create({
|
||
data: {
|
||
kundeId: meiner.id,
|
||
tagCode: "LZ-AAAAAA",
|
||
hostname: "GEHEIM-MEIN",
|
||
registriertAm: new Date(),
|
||
},
|
||
});
|
||
await testPrisma.geraet.create({
|
||
data: {
|
||
kundeId: fremder.id,
|
||
tagCode: "LZ-BBBBBB",
|
||
hostname: "GEHEIM-FREMD",
|
||
registriertAm: new Date(),
|
||
},
|
||
});
|
||
|
||
return { eigene, meiner, fremder, techniker: { id: techniker.id, rolle: Rolle.TECHNIKER } };
|
||
}
|
||
|
||
it("zeigt einem gebundenen Techniker nur die Geräte seiner Kunden", async () => {
|
||
const { techniker } = await zweiKunden();
|
||
expect((await geraeteListe(techniker)).map((z) => z.anzeige)).toEqual(["GEHEIM-MEIN"]);
|
||
});
|
||
|
||
it("lässt sich die Kundengrenze nicht durch einen Suchbegriff aushebeln", async () => {
|
||
const { techniker } = await zweiKunden();
|
||
// Genau der Fall aus dem Review: die Suche bringt ein eigenes `OR` mit.
|
||
expect(await geraeteListe(techniker, { suche: "GEHEIM-FREMD" })).toEqual([]);
|
||
expect(await geraeteListe(techniker, { suche: "GEHEIM" })).toHaveLength(1);
|
||
expect(await geraeteListe(techniker, { suche: "LZ-BBBBBB" })).toEqual([]);
|
||
// Und auch nicht mit Typ- und Archivfilter zusammen.
|
||
expect(
|
||
await geraeteListe(techniker, { suche: "GEHEIM", auchArchivierte: true, typ: GeraeteTyp.SONSTIGES }),
|
||
).toHaveLength(1);
|
||
});
|
||
|
||
it("gibt ein fremdes Gerät auch beim Einzelabruf nicht heraus", async () => {
|
||
const { techniker, fremder } = await zweiKunden();
|
||
const fremdesGeraet = await testPrisma.geraet.findFirstOrThrow({
|
||
where: { kundeId: fremder.id },
|
||
});
|
||
expect(await geraetHolen(fremdesGeraet.id, techniker)).toBeUndefined();
|
||
});
|
||
|
||
it("schlägt als Besitzer nur aktive Personen sichtbarer Kunden vor", async () => {
|
||
const { techniker, meiner, fremder } = await zweiKunden();
|
||
await testPrisma.mitarbeiter.createMany({
|
||
data: [
|
||
{ kundeId: meiner.id, vorname: "A", nachname: "Aktiv", anzeigename: "Anna Aktiv" },
|
||
{
|
||
kundeId: meiner.id,
|
||
vorname: "D",
|
||
nachname: "Weg",
|
||
anzeigename: "Dieter Weg",
|
||
aktiv: false,
|
||
},
|
||
{ kundeId: fremder.id, vorname: "F", nachname: "Fremd", anzeigename: "Frida Fremd" },
|
||
],
|
||
});
|
||
|
||
const auswahl = await besitzerKandidaten(techniker);
|
||
expect(auswahl.kandidaten.map((k) => k.anzeigename)).toEqual(["Anna Aktiv"]);
|
||
expect(auswahl.gekuerzt).toBe(false);
|
||
});
|
||
|
||
it("nennt bei jedem Kandidaten den Kunden, damit die Auswahl ihn filtern kann", async () => {
|
||
/*
|
||
* Der Befund aus dem Review: die Seite holt die Kandidaten **einmal** und
|
||
* gab sie in jede Karte. Ein Administrator sieht alle Kunden — die
|
||
* Auswahlliste bot damit Personen an, die der Dienst danach abweist, weil
|
||
* ein Geraet nur einer Person desselben Kunden gehoeren kann. Ohne
|
||
* `kundeId` am Kandidaten laesst sich das in der Oberflaeche nicht
|
||
* verhindern.
|
||
*/
|
||
const { meiner, fremder } = await zweiKunden();
|
||
const admin = await testPrisma.benutzer.create({
|
||
data: { email: "a2@firma.example", name: "Admin", rolle: Rolle.ADMIN },
|
||
});
|
||
await testPrisma.mitarbeiter.createMany({
|
||
data: [
|
||
{ kundeId: meiner.id, vorname: "A", nachname: "A", anzeigename: "Anna A" },
|
||
{ kundeId: fremder.id, vorname: "B", nachname: "B", anzeigename: "Bert B" },
|
||
],
|
||
});
|
||
|
||
const auswahl = await besitzerKandidaten({ id: admin.id, rolle: admin.rolle });
|
||
expect(auswahl.kandidaten.map((k) => k.anzeigename)).toEqual(["Anna A", "Bert B"]);
|
||
expect(auswahl.kandidaten.map((k) => k.kundeId).sort()).toEqual([meiner.id, fremder.id].sort());
|
||
// Was die Oberflaeche daraus macht: nur die des eigenen Kunden.
|
||
expect(auswahl.kandidaten.filter((k) => k.kundeId === meiner.id).map((k) => k.anzeigename)).toEqual([
|
||
"Anna A",
|
||
]);
|
||
});
|
||
|
||
it("sagt, wenn die Besitzerauswahl gekürzt wurde", async () => {
|
||
const { techniker, meiner } = await zweiKunden();
|
||
await testPrisma.mitarbeiter.createMany({
|
||
data: Array.from({ length: 3 }, (_, i) => ({
|
||
kundeId: meiner.id,
|
||
vorname: "P",
|
||
nachname: `Nummer ${i}`,
|
||
anzeigename: `Person ${i}`,
|
||
})),
|
||
});
|
||
const auswahl = await besitzerKandidaten(techniker, 2);
|
||
expect(auswahl.kandidaten).toHaveLength(2);
|
||
expect(auswahl.gekuerzt).toBe(true);
|
||
});
|
||
});
|
||
});
|