431 lines
18 KiB
TypeScript
431 lines
18 KiB
TypeScript
import { beforeEach, describe, expect, it } from "vitest";
|
||
import { Betriebsmodus, Herkunft } from "@/generated/prisma/enums";
|
||
import {
|
||
MITARBEITER_IMPORT_HOECHSTZEILEN,
|
||
mitarbeiterImportieren,
|
||
type MitarbeiterImportErgebnis,
|
||
} from "@/server/services/mitarbeiter";
|
||
import { datenbankLeeren, datenbankVerfuegbar, testPrisma } from "./helpers/db";
|
||
|
||
/**
|
||
* CSV-Import der Personen (#016).
|
||
*
|
||
* Festgehalten wird vor allem, was in #011 am Geräteimport schiefging: der
|
||
* Import meldete „3 von 3 angelegt“, obwohl Zeilen verschluckt worden waren.
|
||
* Deshalb prüft hier fast jeder Test die **Summe** mit — je Zeile genau ein Fach,
|
||
* und die Datenbank danach genauso, wie die Zahlen es behaupten.
|
||
*
|
||
* Dazu die zweite Regel des Hauses: was aus dem Verzeichnis kommt, wird nicht von
|
||
* Hand überschrieben.
|
||
*/
|
||
|
||
const KOPF = "givenName,sn,displayName,mail,upn,sam,department,title";
|
||
|
||
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: "ADMIN" },
|
||
});
|
||
return { eigene, admin: { id: benutzer.id, rolle: benutzer.rolle } };
|
||
}
|
||
|
||
/** Jede Zeile landet in genau einem Fach – sonst lügt die Erfolgsmeldung. */
|
||
function summePruefen(ergebnis: MitarbeiterImportErgebnis): void {
|
||
expect(ergebnis.angelegt + ergebnis.aktualisiert + ergebnis.unveraendert + ergebnis.abgewiesen.length).toBe(
|
||
ergebnis.gesamt,
|
||
);
|
||
}
|
||
|
||
describe.runIf(datenbankVerfuegbar)("Personen aus einer CSV-Datei", () => {
|
||
beforeEach(async () => {
|
||
await datenbankLeeren();
|
||
delete process.env["OIDC_CUSTOMER_GROUP_PREFIX"];
|
||
});
|
||
|
||
describe("Zeile für Zeile", () => {
|
||
it("legt die guten Zeilen an und meldet die kaputte mit ihrer Zeilennummer", async () => {
|
||
const { admin } = await grundbestand();
|
||
const text = [
|
||
KOPF,
|
||
"Anna,Muster,Anna Muster,anna@firma.example,anna@firma.example,amuster,Vertrieb,Innendienst",
|
||
'Bert,"Berg,Bert Berg,bert@firma.example,,bberg,Vertrieb,', // Anführungszeichen nicht geschlossen
|
||
"Clara,Cloud,Clara Cloud,clara@firma.example,,ccloud,Technik,",
|
||
",,,dora@firma.example,,dfehlt,,", // kein Name in der Zeile
|
||
"Emil,Eck,Emil Eck,,,eeck,,",
|
||
].join("\n");
|
||
|
||
const ergebnis = await mitarbeiterImportieren(text, admin);
|
||
|
||
expect(ergebnis.gesamt).toBe(5);
|
||
expect(ergebnis.angelegt).toBe(3);
|
||
summePruefen(ergebnis);
|
||
// Zeilennummern wie in der Datei: die Kopfzeile ist 1.
|
||
expect(ergebnis.abgewiesen.map((abweisung) => abweisung.zeile)).toEqual([3, 5]);
|
||
expect(ergebnis.abgewiesen[0]?.grund).toMatch(/Anführungszeichen/);
|
||
expect(ergebnis.abgewiesen[1]?.grund).toMatch(/fehlt ein Name/);
|
||
|
||
const namen = (await testPrisma.mitarbeiter.findMany({ select: { anzeigename: true } }))
|
||
.map((zeile) => zeile.anzeigename)
|
||
.sort();
|
||
expect(namen).toEqual(["Anna Muster", "Clara Cloud", "Emil Eck"]);
|
||
});
|
||
|
||
it("legt als MANUELL an und protokolliert die Zeilennummer", async () => {
|
||
// MANUELL, weil niemand aus dieser Datei im Verzeichnis steht — und weil
|
||
// eine so angelegte Person änderbar bleiben muss.
|
||
const { admin, eigene } = await grundbestand();
|
||
await mitarbeiterImportieren([KOPF, "Anna,Muster,,,,amuster,Vertrieb,"].join("\n"), admin);
|
||
|
||
const person = await testPrisma.mitarbeiter.findFirstOrThrow();
|
||
expect(person.herkunft).toBe(Herkunft.MANUELL);
|
||
expect(person.kundeId).toBe(eigene.id);
|
||
expect(person.anzeigename).toBe("Anna Muster");
|
||
expect(person.abteilung).toBe("Vertrieb");
|
||
|
||
const eintrag = await testPrisma.protokoll.findFirstOrThrow({
|
||
where: { aktion: "Mitarbeiter aus CSV angelegt" },
|
||
});
|
||
expect(eintrag.nachher).toMatchObject({ anzeigename: "Anna Muster", zeile: 2 });
|
||
});
|
||
|
||
it("versteht deutsches Excel: Semikolon, BOM und deutsche Spaltennamen", async () => {
|
||
const { admin } = await grundbestand();
|
||
const text =
|
||
"Vorname;Nachname;Anzeigename;Mail;UPN;sAMAccountName;Abteilung;Titel\r\n" +
|
||
'Jörg;Öz;"Öz, Jörg";joerg@firma.example;joerg@firma.example;joez;Technik;"Leiter ""IT"""\r\n';
|
||
|
||
const ergebnis = await mitarbeiterImportieren(text, admin);
|
||
expect(ergebnis.angelegt).toBe(1);
|
||
summePruefen(ergebnis);
|
||
await expect(testPrisma.mitarbeiter.findFirstOrThrow()).resolves.toMatchObject({
|
||
vorname: "Jörg",
|
||
nachname: "Öz",
|
||
anzeigename: "Öz, Jörg",
|
||
titel: 'Leiter "IT"',
|
||
});
|
||
});
|
||
|
||
it("teilt displayName am letzten Leerzeichen, lässt den Anzeigenamen aber stehen", async () => {
|
||
const { admin } = await grundbestand();
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
["displayName,sam", "Anna van der Berg,aberg"].join("\n"),
|
||
admin,
|
||
);
|
||
|
||
expect(ergebnis.angelegt).toBe(1);
|
||
summePruefen(ergebnis);
|
||
// Die Teilung ist eine Annahme; der Anzeigename ist es nicht — und nur er
|
||
// steht später in der Oberfläche und im Laufzettel.
|
||
await expect(testPrisma.mitarbeiter.findFirstOrThrow()).resolves.toMatchObject({
|
||
vorname: "Anna van der",
|
||
nachname: "Berg",
|
||
anzeigename: "Anna van der Berg",
|
||
});
|
||
});
|
||
|
||
it("gibt die Regel des Dienstes auch zeilenweise weiter", async () => {
|
||
// Die 20-Zeichen-Grenze des sAMAccountName steht im Dienst und nirgends
|
||
// sonst. Der Import geht durch denselben Weg, also gilt sie hier auch.
|
||
const { admin } = await grundbestand();
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
[KOPF, "Anna,Muster,,,,viel-zu-langer-anmeldename,,", "Bert,Berg,,,,bberg,,"].join("\n"),
|
||
admin,
|
||
);
|
||
|
||
expect(ergebnis.angelegt).toBe(1);
|
||
summePruefen(ergebnis);
|
||
expect(ergebnis.abgewiesen[0]).toMatchObject({ zeile: 2 });
|
||
expect(ergebnis.abgewiesen[0]?.grund).toMatch(/höchstens 20/);
|
||
});
|
||
|
||
it("weist eine Datei ohne Namensspalte als Ganzes ab", async () => {
|
||
const { admin } = await grundbestand();
|
||
await expect(mitarbeiterImportieren("mail,sam\nanna@firma.example,amuster\n", admin)).rejects.toThrow(
|
||
/displayName/,
|
||
);
|
||
expect(await testPrisma.mitarbeiter.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: MITARBEITER_IMPORT_HOECHSTZEILEN + 1 },
|
||
(_, index) => `Anna,Muster${index},,,,a${index},,`,
|
||
);
|
||
await expect(mitarbeiterImportieren([KOPF, ...zeilen].join("\n"), admin)).rejects.toThrow(
|
||
new RegExp(`mehr als ${MITARBEITER_IMPORT_HOECHSTZEILEN} Zeilen`),
|
||
);
|
||
expect(await testPrisma.mitarbeiter.count()).toBe(0);
|
||
});
|
||
});
|
||
|
||
describe("Wiedererkennen statt verdoppeln", () => {
|
||
it("erkennt ein Duplikat innerhalb derselben Datei und nennt die erste Zeile", async () => {
|
||
const { admin } = await grundbestand();
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
[
|
||
KOPF,
|
||
"Anna,Muster,,anna@firma.example,,amuster,Vertrieb,",
|
||
"Bert,Berg,,bert@firma.example,,bberg,Vertrieb,",
|
||
"Anna,Muster-Neu,,anna@firma.example,,AMUSTER,Vertrieb,", // dieselbe Kennung
|
||
].join("\n"),
|
||
admin,
|
||
);
|
||
|
||
expect(ergebnis.angelegt).toBe(2);
|
||
summePruefen(ergebnis);
|
||
expect(ergebnis.abgewiesen[0]?.zeile).toBe(4);
|
||
expect(ergebnis.abgewiesen[0]?.grund).toMatch(/schon in Zeile 2/);
|
||
expect(await testPrisma.mitarbeiter.count()).toBe(2);
|
||
// Und die erste Zeile gilt, nicht die dritte.
|
||
await expect(
|
||
testPrisma.mitarbeiter.findFirstOrThrow({ where: { sam: "amuster" } }),
|
||
).resolves.toMatchObject({ nachname: "Muster" });
|
||
});
|
||
|
||
it("legt dieselbe Datei beim zweiten Einlesen nicht erneut an", async () => {
|
||
// Der eigentliche Zweck der Wiedererkennung: eine Onboarding-Liste wandert
|
||
// mehrfach durch dieses Feld, und niemand zählt vorher nach.
|
||
const { admin } = await grundbestand();
|
||
const text = [
|
||
KOPF,
|
||
"Anna,Muster,Anna Muster,anna@firma.example,anna@firma.example,amuster,Vertrieb,Innendienst",
|
||
"Bert,Berg,Bert Berg,bert@firma.example,bert@firma.example,bberg,Technik,",
|
||
].join("\n");
|
||
|
||
const erster = await mitarbeiterImportieren(text, admin);
|
||
expect(erster.angelegt).toBe(2);
|
||
|
||
const zweiter = await mitarbeiterImportieren(text, admin);
|
||
expect(zweiter).toMatchObject({ gesamt: 2, angelegt: 0, aktualisiert: 0, unveraendert: 2 });
|
||
summePruefen(zweiter);
|
||
expect(await testPrisma.mitarbeiter.count()).toBe(2);
|
||
});
|
||
|
||
it("erkennt über den UPN, wenn kein sam in der Datei steht", async () => {
|
||
const { admin, eigene } = await grundbestand();
|
||
await testPrisma.mitarbeiter.create({
|
||
data: {
|
||
kundeId: eigene.id,
|
||
vorname: "Anna",
|
||
nachname: "Muster",
|
||
anzeigename: "Anna Muster",
|
||
upn: "anna.muster@firma.example",
|
||
sam: "amuster",
|
||
},
|
||
});
|
||
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
["givenName,sn,upn,department", "Anna,Muster,ANNA.MUSTER@firma.example,Vertrieb"].join("\n"),
|
||
admin,
|
||
);
|
||
|
||
expect(ergebnis).toMatchObject({ angelegt: 0, aktualisiert: 1 });
|
||
summePruefen(ergebnis);
|
||
const person = await testPrisma.mitarbeiter.findFirstOrThrow();
|
||
expect(person.abteilung).toBe("Vertrieb");
|
||
// Gross- und Kleinschreibung unterscheidet keine Personen, deshalb bleibt
|
||
// der vorhandene Wert stehen, statt ihn zu überschreiben.
|
||
expect(person.upn).toBe("anna.muster@firma.example");
|
||
});
|
||
|
||
it("erkennt ohne sam und ohne UPN über den Anzeigenamen", async () => {
|
||
// Die Onboarding-Liste mit Name und Abteilung und sonst nichts. Ohne diesen
|
||
// Rückfall stünde jede Person nach dem zweiten Einlesen doppelt da.
|
||
const { admin } = await grundbestand();
|
||
const text = ["displayName,department", "Anna Muster,Vertrieb"].join("\n");
|
||
|
||
expect(await mitarbeiterImportieren(text, admin)).toMatchObject({ angelegt: 1 });
|
||
expect(await mitarbeiterImportieren(text, admin)).toMatchObject({ angelegt: 0, unveraendert: 1 });
|
||
expect(await testPrisma.mitarbeiter.count()).toBe(1);
|
||
});
|
||
|
||
it("weist eine Zeile ab, die auf zwei Personen passt", async () => {
|
||
// Hier zu raten hieße, die Stammdaten der falschen Person zu überschreiben.
|
||
const { admin, eigene } = await grundbestand();
|
||
for (const [vorname, sam, upn] of [
|
||
["Anna", "amuster", "a.muster@firma.example"],
|
||
["Anneliese", "amuster2", "anna@firma.example"],
|
||
] as const) {
|
||
await testPrisma.mitarbeiter.create({
|
||
data: { kundeId: eigene.id, vorname, nachname: "Muster", anzeigename: vorname, sam, upn },
|
||
});
|
||
}
|
||
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
[KOPF, "Anna,Muster,,,anna@firma.example,amuster,Vertrieb,"].join("\n"),
|
||
admin,
|
||
);
|
||
|
||
expect(ergebnis).toMatchObject({ angelegt: 0, aktualisiert: 0, unveraendert: 0 });
|
||
summePruefen(ergebnis);
|
||
expect(ergebnis.abgewiesen[0]?.grund).toMatch(/passt auf/);
|
||
expect(await testPrisma.mitarbeiter.count()).toBe(2);
|
||
});
|
||
|
||
it("aktiviert eine deaktivierte Person nicht wieder", async () => {
|
||
// Das Wiedereinstellen ist eine Entscheidung und keine Zeile in einer
|
||
// Datei. Die Oberfläche sagt es genauso — also muss es hier auch gelten.
|
||
const { admin, eigene } = await grundbestand();
|
||
await testPrisma.mitarbeiter.create({
|
||
data: {
|
||
kundeId: eigene.id,
|
||
vorname: "Anna",
|
||
nachname: "Muster",
|
||
anzeigename: "Anna Muster",
|
||
sam: "amuster",
|
||
aktiv: false,
|
||
},
|
||
});
|
||
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
[KOPF, "Anna,Muster,,,,amuster,Vertrieb,"].join("\n"),
|
||
admin,
|
||
);
|
||
|
||
expect(ergebnis).toMatchObject({ angelegt: 0, aktualisiert: 1 });
|
||
summePruefen(ergebnis);
|
||
await expect(testPrisma.mitarbeiter.findFirstOrThrow()).resolves.toMatchObject({
|
||
aktiv: false,
|
||
abteilung: "Vertrieb",
|
||
});
|
||
});
|
||
|
||
it("lässt eine leere Zelle nichts löschen", async () => {
|
||
const { admin, eigene } = await grundbestand();
|
||
await testPrisma.mitarbeiter.create({
|
||
data: {
|
||
kundeId: eigene.id,
|
||
vorname: "Anna",
|
||
nachname: "Muster",
|
||
anzeigename: "Muster, Anna",
|
||
sam: "amuster",
|
||
titel: "Innendienst",
|
||
mail: "anna@firma.example",
|
||
},
|
||
});
|
||
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
[KOPF, "Anna,Muster,,,,amuster,Vertrieb,"].join("\n"),
|
||
admin,
|
||
);
|
||
|
||
expect(ergebnis).toMatchObject({ aktualisiert: 1 });
|
||
summePruefen(ergebnis);
|
||
await expect(testPrisma.mitarbeiter.findFirstOrThrow()).resolves.toMatchObject({
|
||
abteilung: "Vertrieb",
|
||
titel: "Innendienst",
|
||
mail: "anna@firma.example",
|
||
// Kein displayName in der Zeile heißt: der vorhandene bleibt, auch wenn
|
||
// er anders lautet als „Vorname Nachname“.
|
||
anzeigename: "Muster, Anna",
|
||
});
|
||
});
|
||
});
|
||
|
||
describe("Herkunft ABGLEICH", () => {
|
||
it("überschreibt eine Person aus dem Verzeichnis nicht, sondern meldet die Zeile", async () => {
|
||
// Der nächste Abgleich drehte die Änderung ohnehin zurück. Stillschweigend
|
||
// zu überspringen wäre das Schlimmere: der Import meldete dann einen
|
||
// Erfolg, den es nicht gab.
|
||
const { admin, eigene } = await grundbestand();
|
||
await testPrisma.mitarbeiter.create({
|
||
data: {
|
||
kundeId: eigene.id,
|
||
vorname: "Maria",
|
||
nachname: "Huber",
|
||
anzeigename: "Maria Huber",
|
||
sam: "mhuber",
|
||
abteilung: "Buchhaltung",
|
||
titel: "Leitung",
|
||
herkunft: Herkunft.ABGLEICH,
|
||
},
|
||
});
|
||
const protokollVorher = await testPrisma.protokoll.count();
|
||
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
[KOPF, "Maria,Huber-Neu,,neu@firma.example,,mhuber,Vertrieb,Sachbearbeitung"].join("\n"),
|
||
admin,
|
||
);
|
||
|
||
expect(ergebnis).toMatchObject({ gesamt: 1, angelegt: 0, aktualisiert: 0, unveraendert: 0 });
|
||
summePruefen(ergebnis);
|
||
expect(ergebnis.abgewiesen[0]?.zeile).toBe(2);
|
||
expect(ergebnis.abgewiesen[0]?.grund).toMatch(/kommt aus dem Verzeichnis/);
|
||
|
||
await expect(testPrisma.mitarbeiter.findFirstOrThrow()).resolves.toMatchObject({
|
||
nachname: "Huber",
|
||
abteilung: "Buchhaltung",
|
||
titel: "Leitung",
|
||
mail: null,
|
||
});
|
||
expect(await testPrisma.protokoll.count()).toBe(protokollVorher);
|
||
});
|
||
});
|
||
|
||
describe("Mandantengrenze", () => {
|
||
it("verwirft im Modus INTERN eine mitgeschickte Kundenkennung", async () => {
|
||
const { admin, eigene } = await grundbestand();
|
||
const fremder = await testPrisma.kunde.create({ data: { name: "Fremder", kuerzel: "FREMD" } });
|
||
|
||
await mitarbeiterImportieren([KOPF, "Anna,Muster,,,,amuster,,"].join("\n"), admin, fremder.id);
|
||
|
||
await expect(testPrisma.mitarbeiter.findFirstOrThrow()).resolves.toMatchObject({
|
||
kundeId: eigene.id,
|
||
});
|
||
});
|
||
|
||
it("erkennt nur innerhalb desselben Kunden – und schreibt nicht für einen fremden", async () => {
|
||
await grundbestand(Betriebsmodus.DIENSTLEISTUNG);
|
||
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: "TECHNIKER" },
|
||
});
|
||
await testPrisma.benutzerKunde.create({ data: { benutzerId: techniker.id, kundeId: meiner.id } });
|
||
process.env["OIDC_CUSTOMER_GROUP_PREFIX"] = "lz-kunde-";
|
||
const handelnder = { id: techniker.id, rolle: techniker.rolle };
|
||
|
||
// Dieselbe Kennung gibt es beim fremden Kunden schon. Sie darf hier nichts
|
||
// treffen: sonst schriebe dieser Import in fremde Stammdaten.
|
||
await testPrisma.mitarbeiter.create({
|
||
data: {
|
||
kundeId: fremder.id,
|
||
vorname: "Anna",
|
||
nachname: "Fremd",
|
||
anzeigename: "Anna Fremd",
|
||
sam: "amuster",
|
||
},
|
||
});
|
||
|
||
const ergebnis = await mitarbeiterImportieren(
|
||
[KOPF, "Anna,Muster,,,,amuster,Vertrieb,"].join("\n"),
|
||
handelnder,
|
||
meiner.id,
|
||
);
|
||
expect(ergebnis).toMatchObject({ angelegt: 1 });
|
||
summePruefen(ergebnis);
|
||
await expect(
|
||
testPrisma.mitarbeiter.findFirstOrThrow({ where: { kundeId: fremder.id } }),
|
||
).resolves.toMatchObject({ nachname: "Fremd", abteilung: null });
|
||
|
||
// Und für einen Kunden, der diesem Techniker nicht gehört, geht gar nichts.
|
||
await expect(
|
||
mitarbeiterImportieren([KOPF, "Bert,Berg,,,,bberg,,"].join("\n"), handelnder, fremder.id),
|
||
).rejects.toThrow(/Berechtigung/);
|
||
expect(await testPrisma.mitarbeiter.count({ where: { kundeId: fremder.id } })).toBe(1);
|
||
});
|
||
|
||
it("verlangt im Modus DIENSTLEISTUNG eine Kundenwahl", async () => {
|
||
const { admin } = await grundbestand(Betriebsmodus.DIENSTLEISTUNG);
|
||
await expect(
|
||
mitarbeiterImportieren([KOPF, "Anna,Muster,,,,amuster,,"].join("\n"), admin),
|
||
).rejects.toThrow(/Kunde/);
|
||
expect(await testPrisma.mitarbeiter.count()).toBe(0);
|
||
});
|
||
});
|
||
});
|