825 lines
33 KiB
TypeScript
825 lines
33 KiB
TypeScript
import type { Entry } from "ldapts";
|
||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||
import { Betriebsmodus } from "@/generated/prisma/enums";
|
||
import { entschluesseln } from "@/lib/geheimnisse";
|
||
import { zertifikatWahl, zuordnungAusEingabe } from "@/lib/verzeichnis";
|
||
import { fehlerMeldung, tlsOptionenBauen, urlPruefen, VerbindungsFehler } from "@/server/ldap/verbindung";
|
||
import {
|
||
AD_ZUORDNUNG,
|
||
angeforderteAttribute,
|
||
dnSchluessel,
|
||
eintragZuordnen,
|
||
STANDARD_FILTER,
|
||
vorgesetzteAufloesen,
|
||
zuordnungLesen,
|
||
} from "@/server/ldap/zuordnung";
|
||
import { abgleichLog, LOG_ZEILEN, quelleHolen, quellenListe } from "@/server/queries/verzeichnis";
|
||
import {
|
||
quelleAnlegen,
|
||
quelleBearbeiten,
|
||
quelleLoeschen,
|
||
verbindungTesten,
|
||
VerzeichnisFehler,
|
||
} from "@/server/services/verzeichnis";
|
||
import { datenbankLeeren, datenbankVerfuegbar, testPrisma } from "./helpers/db";
|
||
import {
|
||
FIXTURE_GELESEN,
|
||
FIXTURE_PERSONEN,
|
||
GUID,
|
||
LDAP_BASIS_DN,
|
||
LDAP_BENUTZER_DN,
|
||
LDAP_BIND_DN,
|
||
LDAP_BIND_PASSWORT,
|
||
LDAP_URL,
|
||
ldapVerfuegbar,
|
||
} from "./fixtures/ldap/container";
|
||
|
||
/**
|
||
* Verzeichnisquellen und das Lesen aus dem Verzeichnis (#016).
|
||
*
|
||
* Drei Arten von Pruefungen stehen hier, und die Trennung ist Absicht:
|
||
*
|
||
* 1. **Reine Funktionen** — Adressen, TLS-Optionen, Attributzuordnung,
|
||
* Fehlermeldungen. Ohne Netz und ohne Datenbank, deshalb vollstaendig in den
|
||
* Sonderfaellen.
|
||
* 2. **Der Service gegen die Datenbank** — Rechte, Betriebsmodus, und dass das
|
||
* Bind-Passwort nirgends herauskommt.
|
||
* 3. **Gegen den echten Container** — dass aus einem AD-aehnlichen Verzeichnis
|
||
* wirklich die erwarteten Felder werden. Das ist der Teil, den keine
|
||
* Attrappe ersetzt: `explicitBufferAttributes`, die Umsortierung der GUID und
|
||
* der Bit-UND-Filter entscheiden sich erst am Server.
|
||
*/
|
||
|
||
const ldapDa = await ldapVerfuegbar();
|
||
|
||
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 admin = await testPrisma.benutzer.create({
|
||
data: { email: "admin@firma.example", name: "Admin", rolle: "ADMIN" },
|
||
});
|
||
const technikerin = await testPrisma.benutzer.create({
|
||
data: { email: "tina@firma.example", name: "Tina", rolle: "TECHNIKER" },
|
||
});
|
||
return {
|
||
eigene,
|
||
admin: { id: admin.id, rolle: admin.rolle },
|
||
technikerin: { id: technikerin.id, rolle: technikerin.rolle },
|
||
};
|
||
}
|
||
|
||
/** Eine Quelle, die auf den Testcontainer zeigt. */
|
||
function quellenEingabe(abweichend: Record<string, unknown> = {}) {
|
||
return {
|
||
name: "Firmen-AD",
|
||
url: LDAP_URL,
|
||
bindDn: LDAP_BIND_DN,
|
||
bindPasswort: LDAP_BIND_PASSWORT,
|
||
basisDn: LDAP_BENUTZER_DN,
|
||
...abweichend,
|
||
};
|
||
}
|
||
|
||
// ---- 1. Reine Funktionen ---------------------------------------------------
|
||
|
||
describe("Adressen", () => {
|
||
it("nimmt ldaps, ldap und das StartTLS-Schema", () => {
|
||
expect(urlPruefen("ldaps://dc1.firma.local:636")).toEqual({
|
||
url: "ldaps://dc1.firma.local:636",
|
||
startTls: false,
|
||
verschluesselt: true,
|
||
});
|
||
expect(urlPruefen("ldap://dc1.firma.local:389")).toEqual({
|
||
url: "ldap://dc1.firma.local:389",
|
||
startTls: false,
|
||
verschluesselt: false,
|
||
});
|
||
});
|
||
|
||
it("macht aus ldap+starttls eine ldap-Adresse und merkt sich die Umschaltung", () => {
|
||
// ldapts kennt nur ldap und ldaps; StartTLS geschieht bei uns nach dem
|
||
// Verbinden. Die getippte Form bleibt in der Datenbank stehen, damit noch
|
||
// erkennbar ist, dass StartTLS gewuenscht war.
|
||
expect(urlPruefen("ldap+starttls://dc1.firma.local:389")).toEqual({
|
||
url: "ldap://dc1.firma.local:389",
|
||
startTls: true,
|
||
verschluesselt: true,
|
||
});
|
||
});
|
||
|
||
it("weist ein fremdes Schema, einen fehlenden Rechner und einen Pfad ab", () => {
|
||
expect(() => urlPruefen("https://dc1.firma.local")).toThrow(VerbindungsFehler);
|
||
expect(() => urlPruefen("dc1.firma.local:389")).toThrow(VerbindungsFehler);
|
||
expect(() => urlPruefen("ldaps://")).toThrow(/Rechnername/u);
|
||
expect(() => urlPruefen("ldaps:///dc=firma,dc=local")).toThrow(/Rechnername/u);
|
||
expect(() => urlPruefen("ldaps://dc1.firma.local/dc=firma,dc=local")).toThrow(/Pfad/u);
|
||
});
|
||
|
||
it("weist Zugangsdaten in der Adresse ab", () => {
|
||
// Sonst stuende das Passwort im Klartext in der Datenbank – verschluesselt
|
||
// wird nur das Feld, das dafuer da ist.
|
||
expect(() => urlPruefen("ldaps://dienst:geheim@dc1.firma.local:636")).toThrow(/Zugangsdaten/u);
|
||
});
|
||
});
|
||
|
||
describe("TLS-Optionen", () => {
|
||
it("verlangt mindestens TLS 1.2", () => {
|
||
expect(tlsOptionenBauen(null).minVersion).toBe("TLSv1.2");
|
||
});
|
||
|
||
it("nimmt ein eigenes CA-Zertifikat auf", () => {
|
||
const pem = "-----BEGIN CERTIFICATE-----\nMIIB\n-----END CERTIFICATE-----";
|
||
expect(tlsOptionenBauen(pem).ca).toEqual([pem]);
|
||
});
|
||
|
||
it("laesst ca weg, wenn keines hinterlegt ist – dann gelten die Systemwurzeln", () => {
|
||
expect(tlsOptionenBauen(null).ca).toBeUndefined();
|
||
expect(tlsOptionenBauen(" ").ca).toBeUndefined();
|
||
});
|
||
|
||
it("hat keinen Schalter, der die Pruefung des Hostnamens abstellt", () => {
|
||
// Ein solcher Schalter waere genau der, der in der Eile gesetzt bleibt.
|
||
const optionen = tlsOptionenBauen(null) as Record<string, unknown>;
|
||
expect(optionen["rejectUnauthorized"]).toBeUndefined();
|
||
expect(optionen["checkServerIdentity"]).toBeUndefined();
|
||
});
|
||
});
|
||
|
||
describe("Fehlermeldungen", () => {
|
||
const passwort = "S3hr-geheim!";
|
||
|
||
it("entfernt das Bind-Passwort restlos", () => {
|
||
const meldung = fehlerMeldung(new Error(`bind failed for cn=dienst with ${passwort}`), [passwort]);
|
||
expect(meldung).not.toContain(passwort);
|
||
expect(meldung).toContain("***");
|
||
});
|
||
|
||
it("entfernt es auch mehrfach und mitten im Wort", () => {
|
||
const meldung = fehlerMeldung(new Error(`${passwort}/${passwort}`), [passwort]);
|
||
expect(meldung).toBe("***/***");
|
||
});
|
||
|
||
it("macht eine Zeile daraus und kuerzt", () => {
|
||
const meldung = fehlerMeldung(new Error(`erste\n zweite\tdritte`), []);
|
||
expect(meldung).toBe("erste zweite dritte");
|
||
expect(fehlerMeldung(new Error("x".repeat(900)), []).length).toBeLessThanOrEqual(401);
|
||
});
|
||
|
||
it("kommt mit allem zurecht, was geworfen werden kann", () => {
|
||
expect(fehlerMeldung("nur Text", [])).toBe("nur Text");
|
||
expect(fehlerMeldung(undefined, [])).toBe("undefined");
|
||
expect(fehlerMeldung(new Error(" "), [])).toBe("Unbekannter Fehler beim Zugriff auf das Verzeichnis.");
|
||
});
|
||
});
|
||
|
||
describe("Attributzuordnung", () => {
|
||
it("benennt die AD-Vorgaben aus dem Auftrag", () => {
|
||
expect(AD_ZUORDNUNG).toEqual({
|
||
vorname: "givenName",
|
||
nachname: "sn",
|
||
anzeigename: "displayName",
|
||
mail: "mail",
|
||
upn: "userPrincipalName",
|
||
sam: "sAMAccountName",
|
||
abteilung: "department",
|
||
titel: "title",
|
||
vorgesetzter: "manager",
|
||
externeId: "objectGUID",
|
||
});
|
||
});
|
||
|
||
it("schliesst im Standardfilter die deaktivierten Konten aus", () => {
|
||
expect(STANDARD_FILTER).toBe(
|
||
"(&(objectCategory=person)(objectClass=user)(!(userAccountControl:1.2.840.113556.1.4.803:=2)))",
|
||
);
|
||
});
|
||
|
||
it("fuellt fehlende und leere Felder mit der Vorgabe", () => {
|
||
expect(zuordnungLesen({ anzeigename: "cn", mail: " " })).toEqual({
|
||
...AD_ZUORDNUNG,
|
||
anzeigename: "cn",
|
||
});
|
||
expect(zuordnungLesen(null)).toEqual(AD_ZUORDNUNG);
|
||
expect(zuordnungLesen("Unsinn")).toEqual(AD_ZUORDNUNG);
|
||
expect(zuordnungLesen({ vorname: 7 })).toEqual(AD_ZUORDNUNG);
|
||
});
|
||
|
||
it("fragt nur die zugeordneten Attribute an, und jedes nur einmal", () => {
|
||
const attribute = angeforderteAttribute({ ...AD_ZUORDNUNG, upn: "mail" });
|
||
expect(attribute).toContain("objectGUID");
|
||
expect(attribute).not.toContain("memberOf");
|
||
expect(attribute.filter((name) => name === "mail")).toHaveLength(1);
|
||
});
|
||
|
||
it("uebersetzt einen Eintrag und wandelt den GUID-Puffer", () => {
|
||
const ergebnis = eintragZuordnen(
|
||
{
|
||
dn: "CN=Maria Huber,OU=Buchhaltung,DC=firma,DC=test",
|
||
givenName: "Maria",
|
||
sn: "Huber",
|
||
displayName: "Huber, Maria",
|
||
mail: "maria.huber@firma.test",
|
||
userPrincipalName: "maria.huber@firma.test",
|
||
sAMAccountName: "mhuber",
|
||
department: "Buchhaltung",
|
||
title: "Leiterin",
|
||
manager: "CN=Klaus Berger,OU=GF,DC=firma,DC=test",
|
||
objectGUID: Buffer.from("EEMHXzU8HUqDb6UPUV56NQ==", "base64"),
|
||
} satisfies Entry,
|
||
AD_ZUORDNUNG,
|
||
);
|
||
expect(ergebnis).toEqual({
|
||
eintrag: {
|
||
externeId: GUID.huber,
|
||
vorname: "Maria",
|
||
nachname: "Huber",
|
||
anzeigename: "Huber, Maria",
|
||
mail: "maria.huber@firma.test",
|
||
upn: "maria.huber@firma.test",
|
||
sam: "mhuber",
|
||
dn: "CN=Maria Huber,OU=Buchhaltung,DC=firma,DC=test",
|
||
abteilung: "Buchhaltung",
|
||
titel: "Leiterin",
|
||
vorgesetzterDn: "CN=Klaus Berger,OU=GF,DC=firma,DC=test",
|
||
},
|
||
});
|
||
});
|
||
|
||
it("nimmt bei einem mehrwertigen Attribut den ersten Wert und macht aus leer null", () => {
|
||
const ergebnis = eintragZuordnen(
|
||
{
|
||
dn: "CN=Zwei,DC=firma,DC=test",
|
||
givenName: ["Anna", "Annemarie"],
|
||
sn: "Zwei",
|
||
displayName: "",
|
||
mail: " ",
|
||
objectGUID: Buffer.from("AAECAwQFBgcICQoLDA0ODw==", "base64"),
|
||
} satisfies Entry,
|
||
AD_ZUORDNUNG,
|
||
);
|
||
expect(ergebnis).toMatchObject({
|
||
eintrag: { vorname: "Anna", mail: null, upn: null, titel: null, vorgesetzterDn: null },
|
||
});
|
||
});
|
||
|
||
it("baut einen Anzeigenamen, wenn keiner im Verzeichnis steht", () => {
|
||
// `Mitarbeiter.anzeigename` ist nicht optional, und eine leere Zeile in der
|
||
// Auswahlliste waere fuer die Technikerin unbrauchbar.
|
||
const mitNamen = eintragZuordnen(
|
||
{ dn: "CN=X,DC=f,DC=t", givenName: "Maria", sn: "Huber", objectGUID: "abc" } satisfies Entry,
|
||
AD_ZUORDNUNG,
|
||
);
|
||
expect(mitNamen).toMatchObject({ eintrag: { anzeigename: "Huber, Maria" } });
|
||
|
||
const ohneNamen = eintragZuordnen(
|
||
{ dn: "CN=Nur der DN,OU=x,DC=f,DC=t", objectGUID: "abc" } satisfies Entry,
|
||
AD_ZUORDNUNG,
|
||
);
|
||
expect(ohneNamen).toMatchObject({ eintrag: { anzeigename: "Nur der DN", vorname: "", nachname: "" } });
|
||
});
|
||
|
||
it("uebersetzt eine Textkennung, ohne sie fuer eine GUID zu halten", () => {
|
||
// Wer `externeId` auf `entryUUID` eines OpenLDAP legt, bekommt 36 Textbytes.
|
||
const ergebnis = eintragZuordnen(
|
||
{
|
||
dn: "CN=Y,DC=f,DC=t",
|
||
objectGUID: Buffer.from("c0ffee00-1111-2222-3333-444455556666", "utf8"),
|
||
} satisfies Entry,
|
||
AD_ZUORDNUNG,
|
||
);
|
||
expect(ergebnis).toMatchObject({ eintrag: { externeId: "c0ffee00-1111-2222-3333-444455556666" } });
|
||
});
|
||
|
||
it("ueberspringt einen Eintrag ohne Kennung statt abzubrechen", () => {
|
||
// Ein einzelnes krummes Konto darf nicht den Abgleich aller anderen
|
||
// verhindern – ohne Kennung waere es aber bei jedem Lauf wieder neu.
|
||
const ohne = eintragZuordnen({ dn: "CN=Ohne,DC=f,DC=t", sn: "Ohne" } satisfies Entry, AD_ZUORDNUNG);
|
||
expect(ohne).toEqual({
|
||
uebersprungen: { dn: "CN=Ohne,DC=f,DC=t", grund: expect.stringContaining("objectGUID") },
|
||
});
|
||
|
||
// Sieben Bytes sind eine verstuemmelte GUID, keine Kennung. Sie als Text
|
||
// durchzulassen hiesse: eine Kennung aus Steuerzeichen, die zu keinem Konto
|
||
// im Verzeichnis passt und trotzdem kein Duplikat erzeugt – ein Fehler, der
|
||
// nie auffaellt.
|
||
const kaputt = eintragZuordnen(
|
||
{ dn: "CN=Kaputt,DC=f,DC=t", objectGUID: Buffer.alloc(7) } satisfies Entry,
|
||
AD_ZUORDNUNG,
|
||
);
|
||
expect(kaputt).toMatchObject({ uebersprungen: { dn: "CN=Kaputt,DC=f,DC=t" } });
|
||
});
|
||
|
||
it("loest den Vorgesetzten ueber den DN auf, auch bei anderer Schreibweise", () => {
|
||
const chef = {
|
||
externeId: GUID.berger,
|
||
vorname: "Klaus",
|
||
nachname: "Berger",
|
||
anzeigename: "Berger, Klaus",
|
||
mail: null,
|
||
upn: null,
|
||
sam: "kberger",
|
||
dn: "CN=Klaus Berger,OU=GF,DC=firma,DC=test",
|
||
abteilung: null,
|
||
titel: null,
|
||
vorgesetzterDn: null,
|
||
};
|
||
const person = {
|
||
...chef,
|
||
externeId: GUID.huber,
|
||
dn: "CN=Maria Huber,OU=BH,DC=firma,DC=test",
|
||
// Klein geschrieben und mit Leerzeichen hinter den Kommas.
|
||
vorgesetzterDn: "cn=klaus berger, ou=gf, dc=firma, dc=test",
|
||
};
|
||
const [aufgeloest] = vorgesetzteAufloesen([person, chef]);
|
||
expect(aufgeloest?.vorgesetzterExterneId).toBe(GUID.berger);
|
||
expect(dnSchluessel("CN=A, OU=B")).toBe("cn=a,ou=b");
|
||
});
|
||
|
||
it("laesst den Vorgesetzten leer, wenn er nicht mitgelesen wurde", () => {
|
||
// Lieber kein Vorgesetzter als ein falscher: der DN ist ausserhalb des
|
||
// Suchbereichs nicht aufloesbar, und geraten wird nicht.
|
||
const person = {
|
||
externeId: GUID.huber,
|
||
vorname: "Maria",
|
||
nachname: "Huber",
|
||
anzeigename: "Huber, Maria",
|
||
mail: null,
|
||
upn: null,
|
||
sam: null,
|
||
dn: "CN=Maria Huber,OU=BH,DC=firma,DC=test",
|
||
abteilung: null,
|
||
titel: null,
|
||
vorgesetzterDn: "CN=Unbekannt,OU=Extern,DC=firma,DC=test",
|
||
};
|
||
expect(vorgesetzteAufloesen([person])[0]?.vorgesetzterExterneId).toBeNull();
|
||
});
|
||
});
|
||
|
||
// ---- 2. Der Service gegen die Datenbank -----------------------------------
|
||
|
||
describe("Zuordnung und Zertifikat aus dem Formular", () => {
|
||
it("nimmt gefuellte Felder und laesst leere der Vorgabe", () => {
|
||
const ergebnis = zuordnungAusEingabe({ externeId: " entryUUID ", sam: "", titel: "title" });
|
||
expect(ergebnis).toEqual({ zuordnung: { externeId: "entryUUID", titel: "title" } });
|
||
});
|
||
|
||
it("weist ab, was kein Attributname ist", () => {
|
||
for (const krumm of ["(objectClass=*)", "cn;binary", "2fach", "-sn", "sn sn"]) {
|
||
const ergebnis = zuordnungAusEingabe({ nachname: krumm });
|
||
expect(ergebnis, krumm).toHaveProperty("fehler");
|
||
}
|
||
});
|
||
|
||
it("nennt in der Meldung das Feld, damit klar ist, welche Zeile gemeint ist", () => {
|
||
const ergebnis = zuordnungAusEingabe({ externeId: "(guid)" });
|
||
expect("fehler" in ergebnis && ergebnis.fehler).toContain("Kennung");
|
||
});
|
||
|
||
it("unterscheidet beim Zertifikat unveraendert, neu und entfernen", () => {
|
||
// Leeres Feld, kein Kaestchen: das hinterlegte bleibt – deshalb `undefined`.
|
||
expect(zertifikatWahl("", false)).toEqual({ wert: undefined });
|
||
expect(zertifikatWahl(" ", false)).toEqual({ wert: undefined });
|
||
expect(zertifikatWahl("-----BEGIN CERTIFICATE-----", false)).toEqual({
|
||
wert: "-----BEGIN CERTIFICATE-----",
|
||
});
|
||
// Kaestchen: leere Zeichenkette, und der Dienst macht daraus `null`.
|
||
expect(zertifikatWahl("", true)).toEqual({ wert: "" });
|
||
expect(zertifikatWahl("-----BEGIN CERTIFICATE-----", true)).toHaveProperty("fehler");
|
||
});
|
||
});
|
||
|
||
describe.runIf(datenbankVerfuegbar)("Verzeichnisquellen", () => {
|
||
beforeEach(async () => {
|
||
await datenbankLeeren();
|
||
});
|
||
|
||
it("legt eine Quelle mit den Vorgaben an", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe({ name: " Firmen-AD " }), admin);
|
||
|
||
expect(quelle.name).toBe("Firmen-AD");
|
||
expect(quelle.filter).toBe(STANDARD_FILTER);
|
||
expect(quelle.attributZuordnung).toEqual(AD_ZUORDNUNG);
|
||
expect(quelle.abgleichIntervallMinuten).toBe(60);
|
||
// Eine neue Quelle ist zunaechst abgeschaltet: erst Verbindung testen, dann
|
||
// den Zeitplan darauf loslassen.
|
||
expect(quelle.aktiv).toBe(false);
|
||
expect(quelle.caZertifikatVorhanden).toBe(false);
|
||
expect(quelle.letzterAbgleichAm).toBeNull();
|
||
});
|
||
|
||
it("uebernimmt einzelne abweichende Attributnamen", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(
|
||
quellenEingabe({ attributZuordnung: { anzeigename: "cn", externeId: "entryUUID" } }),
|
||
admin,
|
||
);
|
||
expect(quelle.attributZuordnung).toEqual({
|
||
...AD_ZUORDNUNG,
|
||
anzeigename: "cn",
|
||
externeId: "entryUUID",
|
||
});
|
||
});
|
||
|
||
it("verlangt Name, Adresse, Bind-DN, Passwort und Basis-DN", async () => {
|
||
const { admin } = await grundbestand();
|
||
await expect(quelleAnlegen(quellenEingabe({ name: " " }), admin)).rejects.toThrow(VerzeichnisFehler);
|
||
await expect(quelleAnlegen(quellenEingabe({ bindDn: "" }), admin)).rejects.toThrow(/Bind-DN/u);
|
||
await expect(quelleAnlegen(quellenEingabe({ bindPasswort: "" }), admin)).rejects.toThrow(
|
||
/Bind-Passwort/u,
|
||
);
|
||
await expect(quelleAnlegen(quellenEingabe({ basisDn: "" }), admin)).rejects.toThrow(/Basis-DN/u);
|
||
await expect(quelleAnlegen(quellenEingabe({ url: "ftp://dc1" }), admin)).rejects.toThrow(
|
||
VerbindungsFehler,
|
||
);
|
||
});
|
||
|
||
it("weist ein Intervall ausserhalb der Grenzen ab", async () => {
|
||
const { admin } = await grundbestand();
|
||
await expect(quelleAnlegen(quellenEingabe({ abgleichIntervallMinuten: 1 }), admin)).rejects.toThrow(
|
||
/Intervall/u,
|
||
);
|
||
await expect(quelleAnlegen(quellenEingabe({ abgleichIntervallMinuten: 99999 }), admin)).rejects.toThrow(
|
||
/Intervall/u,
|
||
);
|
||
await expect(quelleAnlegen(quellenEingabe({ abgleichIntervallMinuten: 10.5 }), admin)).rejects.toThrow(
|
||
/Intervall/u,
|
||
);
|
||
const quelle = await quelleAnlegen(quellenEingabe({ abgleichIntervallMinuten: 15 }), admin);
|
||
expect(quelle.abgleichIntervallMinuten).toBe(15);
|
||
});
|
||
|
||
it("verlangt beim CA-Zertifikat die PEM-Huelle", async () => {
|
||
const { admin } = await grundbestand();
|
||
await expect(quelleAnlegen(quellenEingabe({ caZertifikatPem: "MIIB…" }), admin)).rejects.toThrow(/PEM/u);
|
||
const quelle = await quelleAnlegen(
|
||
quellenEingabe({
|
||
caZertifikatPem: "-----BEGIN CERTIFICATE-----\nMIIB\n-----END CERTIFICATE-----",
|
||
}),
|
||
admin,
|
||
);
|
||
// Die Oberflaeche erfaehrt nur, **dass** eines hinterlegt ist.
|
||
expect(quelle.caZertifikatVorhanden).toBe(true);
|
||
expect(JSON.stringify(quelle)).not.toContain("BEGIN CERTIFICATE");
|
||
});
|
||
|
||
it("nimmt ein hinterlegtes CA-Zertifikat auf Wunsch wieder weg", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(
|
||
quellenEingabe({
|
||
caZertifikatPem: "-----BEGIN CERTIFICATE-----\nMIIB\n-----END CERTIFICATE-----",
|
||
}),
|
||
admin,
|
||
);
|
||
expect(quelle.caZertifikatVorhanden).toBe(true);
|
||
|
||
// Eine leere Zeichenkette heisst „entfernen“; `undefined` hiesse
|
||
// „unveraendert“ – daran haengt, dass das Formular beides ausdruecken kann.
|
||
const ohne = await quelleBearbeiten(quelle.id, { caZertifikatPem: "" }, admin);
|
||
expect(ohne.caZertifikatVorhanden).toBe(false);
|
||
const zeile = await testPrisma.verzeichnisquelle.findUniqueOrThrow({ where: { id: quelle.id } });
|
||
expect(zeile.caZertifikatPem).toBeNull();
|
||
|
||
// Und ein Speichern ohne Angabe laesst es, wie es ist.
|
||
await quelleBearbeiten(
|
||
quelle.id,
|
||
{ caZertifikatPem: "-----BEGIN CERTIFICATE-----\nMIIB\n-----END CERTIFICATE-----" },
|
||
admin,
|
||
);
|
||
const wieder = await quelleBearbeiten(quelle.id, { name: "Anderer Name" }, admin);
|
||
expect(wieder.caZertifikatVorhanden).toBe(true);
|
||
});
|
||
|
||
it("verlangt das Recht verwaltung", async () => {
|
||
const { technikerin } = await grundbestand();
|
||
// Die Aktion prueft es auch; hier steht das zweite Netz, an dem auch der
|
||
// Zeitplan und ein Skript nicht vorbeikommen.
|
||
await expect(quelleAnlegen(quellenEingabe(), technikerin)).rejects.toThrow(/verwaltung/u);
|
||
});
|
||
|
||
it("ist im Modus Dienstleistung abgeschaltet", async () => {
|
||
const { admin } = await grundbestand(Betriebsmodus.DIENSTLEISTUNG);
|
||
await expect(quelleAnlegen(quellenEingabe(), admin)).rejects.toThrow(/Dienstleistung/u);
|
||
// Auch die Lesemodelle zeigen dort nichts – nicht einmal eine Quelle aus
|
||
// einer frueheren Zeit im Modus INTERN.
|
||
expect(await quellenListe(admin)).toEqual([]);
|
||
});
|
||
|
||
it("bearbeitet einzelne Felder und protokolliert die Aenderung", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
const geaendert = await quelleBearbeiten(
|
||
quelle.id,
|
||
{ name: "AD Hauptstelle", aktiv: true, abgleichIntervallMinuten: 30 },
|
||
admin,
|
||
);
|
||
expect(geaendert.name).toBe("AD Hauptstelle");
|
||
expect(geaendert.aktiv).toBe(true);
|
||
expect(geaendert.abgleichIntervallMinuten).toBe(30);
|
||
|
||
const protokoll = await testPrisma.protokoll.findMany({
|
||
where: { entitaet: "Verzeichnisquelle", entitaetId: quelle.id },
|
||
});
|
||
expect(protokoll).toHaveLength(2);
|
||
expect(protokoll.map((zeile) => zeile.aktion)).toContain("Verzeichnisquelle angelegt");
|
||
});
|
||
|
||
it("laesst das Passwort stehen, wenn das Feld leer bleibt", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
const vorher = await testPrisma.verzeichnisquelle.findUniqueOrThrow({ where: { id: quelle.id } });
|
||
|
||
// Ein Formular kann das Passwort nicht anzeigen und schickt darum eine leere
|
||
// Zeichenkette. Waere das „loeschen“, waere die Quelle nach dem ersten
|
||
// Umbenennen kaputt.
|
||
await quelleBearbeiten(quelle.id, { bindPasswort: "", name: "Neu" }, admin);
|
||
const nachher = await testPrisma.verzeichnisquelle.findUniqueOrThrow({ where: { id: quelle.id } });
|
||
expect(entschluesseln(nachher.bindPasswortVerschluesselt)).toBe(LDAP_BIND_PASSWORT);
|
||
expect(nachher.bindPasswortVerschluesselt).toBe(vorher.bindPasswortVerschluesselt);
|
||
|
||
await quelleBearbeiten(quelle.id, { bindPasswort: "ein-neues-geheimnis" }, admin);
|
||
const dritte = await testPrisma.verzeichnisquelle.findUniqueOrThrow({ where: { id: quelle.id } });
|
||
expect(entschluesseln(dritte.bindPasswortVerschluesselt)).toBe("ein-neues-geheimnis");
|
||
});
|
||
|
||
it("gibt das Bind-Passwort in keiner Antwort und in keinem Protokoll heraus", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
await quelleBearbeiten(quelle.id, { aktiv: true }, admin);
|
||
|
||
const liste = await quellenListe(admin);
|
||
const einzeln = await quelleHolen(quelle.id, admin);
|
||
const protokoll = await testPrisma.protokoll.findMany({ where: { entitaetId: quelle.id } });
|
||
const alles = JSON.stringify({ quelle, liste, einzeln, protokoll });
|
||
|
||
expect(alles).not.toContain(LDAP_BIND_PASSWORT);
|
||
expect(alles).not.toContain("bindPasswort");
|
||
// Auch der verschluesselte Wert hat in einer Antwort nichts zu suchen.
|
||
expect(alles).not.toContain("bindPasswortVerschluesselt");
|
||
|
||
const zeile = await testPrisma.verzeichnisquelle.findUniqueOrThrow({ where: { id: quelle.id } });
|
||
expect(zeile.bindPasswortVerschluesselt).not.toContain(LDAP_BIND_PASSWORT);
|
||
expect(zeile.bindPasswortVerschluesselt).toMatch(/^v1\./u);
|
||
expect(entschluesseln(zeile.bindPasswortVerschluesselt)).toBe(LDAP_BIND_PASSWORT);
|
||
});
|
||
|
||
it("loescht eine Quelle ohne Mitarbeiter und verweigert es sonst", async () => {
|
||
const { admin, eigene } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
await testPrisma.mitarbeiter.create({
|
||
data: {
|
||
kundeId: eigene.id,
|
||
quelleId: quelle.id,
|
||
externeId: GUID.huber,
|
||
vorname: "Maria",
|
||
nachname: "Huber",
|
||
anzeigename: "Huber, Maria",
|
||
herkunft: "ABGLEICH",
|
||
},
|
||
});
|
||
|
||
await expect(quelleLoeschen(quelle.id, admin)).rejects.toThrow(/hängen 1 Mitarbeiter/u);
|
||
|
||
await testPrisma.mitarbeiter.deleteMany({ where: { quelleId: quelle.id } });
|
||
await quelleLoeschen(quelle.id, admin);
|
||
expect(await testPrisma.verzeichnisquelle.count()).toBe(0);
|
||
// Das Protokoll bleibt, auch ohne die Zeile, auf die es zeigt.
|
||
expect(await testPrisma.protokoll.count({ where: { aktion: "Verzeichnisquelle gelöscht" } })).toBe(1);
|
||
});
|
||
|
||
it("fasst eine Quelle eines fremden Kunden nicht an", async () => {
|
||
const { admin } = await grundbestand();
|
||
// Anlegen kann so eine Zeile niemand – `quelleAnlegen` laeuft nur im Modus
|
||
// INTERN und nimmt dort immer die eigene Organisation. Entstehen kann sie
|
||
// trotzdem: durch eine Migration, `psql` oder ein Skript. „Gilt nur fuer die
|
||
// eigene Organisation“ waere sonst eine Zusage, die nur fuer den Weg durch
|
||
// das Formular gilt.
|
||
const fremder = await testPrisma.kunde.create({ data: { name: "Fremd GmbH", kuerzel: "FREMD" } });
|
||
const fremde = await testPrisma.verzeichnisquelle.create({
|
||
data: {
|
||
kundeId: fremder.id,
|
||
name: "Fremdes AD",
|
||
url: "ldaps://dc1.fremd.local:636",
|
||
bindDn: "cn=dienst,dc=fremd,dc=local",
|
||
bindPasswortVerschluesselt: "v1.aaaa.bbbb.cccc",
|
||
basisDn: "dc=fremd,dc=local",
|
||
filter: STANDARD_FILTER,
|
||
attributZuordnung: { ...AD_ZUORDNUNG },
|
||
},
|
||
});
|
||
|
||
await expect(quelleBearbeiten(fremde.id, { name: "X" }, admin)).rejects.toThrow(/eigenen Organisation/u);
|
||
await expect(quelleLoeschen(fremde.id, admin)).rejects.toThrow(/eigenen Organisation/u);
|
||
await expect(verbindungTesten(fremde.id, admin)).rejects.toThrow(/eigenen Organisation/u);
|
||
});
|
||
|
||
it("liefert eine unbekannte Quelle als „nicht vorhanden“", async () => {
|
||
const { admin } = await grundbestand();
|
||
expect(await quelleHolen("gibtesnicht", admin)).toBeUndefined();
|
||
await expect(quelleBearbeiten("gibtesnicht", { name: "X" }, admin)).rejects.toThrow(VerzeichnisFehler);
|
||
});
|
||
});
|
||
|
||
// ---- 3. Gegen den echten Container ----------------------------------------
|
||
|
||
describe.runIf(datenbankVerfuegbar && ldapDa)("Verbindung testen gegen das Verzeichnis", () => {
|
||
const protokolliert: string[] = [];
|
||
|
||
beforeEach(async () => {
|
||
await datenbankLeeren();
|
||
protokolliert.length = 0;
|
||
// Die Zusage „kein Server-Log enthaelt das Bind-Passwort“ wird hier wirklich
|
||
// gemessen und nicht behauptet.
|
||
for (const kanal of ["log", "info", "warn", "error", "debug"] as const) {
|
||
vi.spyOn(console, kanal).mockImplementation((...teile: unknown[]) => {
|
||
protokolliert.push(teile.map((teil) => String(teil)).join(" "));
|
||
});
|
||
}
|
||
});
|
||
|
||
afterEach(() => {
|
||
vi.restoreAllMocks();
|
||
});
|
||
|
||
it("zeigt die gemappten Felder der Fixture-Personen", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
const { treffer, gesamtGelesen } = await verbindungTesten(quelle.id, admin);
|
||
|
||
// Vier Eintraege liefert der Filter, drei davon haben eine Kennung.
|
||
expect(gesamtGelesen).toBe(FIXTURE_GELESEN);
|
||
expect(treffer).toHaveLength(FIXTURE_PERSONEN);
|
||
|
||
const huber = treffer.find((eintrag) => eintrag.sam === "mhuber");
|
||
expect(huber).toMatchObject({
|
||
externeId: GUID.huber,
|
||
vorname: "Maria",
|
||
nachname: "Huber",
|
||
anzeigename: "Huber, Maria",
|
||
mail: "maria.huber@firma.test",
|
||
upn: "maria.huber@firma.test",
|
||
abteilung: "Buchhaltung",
|
||
// Umlaute kommen als UTF-8 durch, nicht als Fragezeichen.
|
||
titel: "Leiterin Rechnungsprüfung",
|
||
dn: "cn=Maria Huber,ou=Buchhaltung,ou=Benutzer,dc=firma,dc=test",
|
||
// Der Chef ist in derselben Probe, deshalb aufgeloest.
|
||
vorgesetzterExterneId: GUID.berger,
|
||
});
|
||
expect(treffer.find((eintrag) => eintrag.sam === "jweiss")).toMatchObject({
|
||
nachname: "Weiß",
|
||
vorname: "Jörg",
|
||
externeId: GUID.weiss,
|
||
});
|
||
});
|
||
|
||
it("laesst das per userAccountControl deaktivierte Konto aus", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
const { treffer } = await verbindungTesten(quelle.id, admin);
|
||
|
||
// „Alte Kraft“ steht mit userAccountControl 514 im Verzeichnis. Dass der
|
||
// Bit-UND-Filter greift, entscheidet sich am Server – hier ist es gemessen.
|
||
expect(treffer.map((eintrag) => eintrag.sam)).not.toContain("akraft");
|
||
expect(treffer.map((eintrag) => eintrag.externeId)).not.toContain(GUID.alteKraft);
|
||
});
|
||
|
||
it("haelt sich an die Grenze und schreibt nichts", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
const protokollVorher = await testPrisma.protokoll.count();
|
||
|
||
const { treffer } = await verbindungTesten(quelle.id, admin, 2);
|
||
expect(treffer).toHaveLength(2);
|
||
|
||
// Kein Mitarbeiter, kein Protokoll, kein Abgleichstand: der Test ist eine
|
||
// Probe und kein halber Abgleich.
|
||
expect(await testPrisma.mitarbeiter.count()).toBe(0);
|
||
expect(await testPrisma.protokoll.count()).toBe(protokollVorher);
|
||
const zeile = await testPrisma.verzeichnisquelle.findUniqueOrThrow({ where: { id: quelle.id } });
|
||
expect(zeile.letzterAbgleichAm).toBeNull();
|
||
expect(zeile.letzterAbgleichStatus).toBeNull();
|
||
});
|
||
|
||
it("findet mit einem eigenen Filter nur die gesuchte Abteilung", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(
|
||
quellenEingabe({ filter: "(&(objectClass=user)(department=Vertrieb)(sAMAccountName=*))" }),
|
||
admin,
|
||
);
|
||
const { treffer } = await verbindungTesten(quelle.id, admin);
|
||
expect(treffer.map((eintrag) => eintrag.sam).sort()).toEqual(["akraft", "jweiss"]);
|
||
});
|
||
|
||
it("liest den ganzen Baum ab dem Basis-DN", async () => {
|
||
const { admin } = await grundbestand();
|
||
// Die Personen liegen in Unter-OUs; mit scope „one“ waere die Liste leer.
|
||
const quelle = await quelleAnlegen(quellenEingabe({ basisDn: LDAP_BASIS_DN }), admin);
|
||
const { treffer } = await verbindungTesten(quelle.id, admin);
|
||
expect(treffer).toHaveLength(FIXTURE_PERSONEN);
|
||
});
|
||
|
||
it("nennt einen falschen Bind-DN, ohne das Passwort zu verraten", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe({ bindPasswort: "falsches-passwort-xyz" }), admin);
|
||
|
||
await expect(verbindungTesten(quelle.id, admin)).rejects.toThrow(VerbindungsFehler);
|
||
const fehler = await verbindungTesten(quelle.id, admin).catch((f: unknown) => f);
|
||
expect(String(fehler)).not.toContain("falsches-passwort-xyz");
|
||
// Und auch nichts, was die Bibliothek unterwegs auf die Konsole geschrieben
|
||
// haette.
|
||
expect(protokolliert.join("\n")).not.toContain("falsches-passwort-xyz");
|
||
});
|
||
|
||
it("meldet einen unerreichbaren Server als Fehler und nicht als leeres Ergebnis", async () => {
|
||
const { admin } = await grundbestand();
|
||
// Ein leeres Ergebnis waere die gefaehrlichste Antwort: der Abgleich wuerde
|
||
// daraus schliessen, dass alle gegangen sind.
|
||
const quelle = await quelleAnlegen(quellenEingabe({ url: "ldap://127.0.0.1:1" }), admin);
|
||
await expect(verbindungTesten(quelle.id, admin)).rejects.toThrow(VerbindungsFehler);
|
||
});
|
||
});
|
||
|
||
describe.runIf(datenbankVerfuegbar)("Abgleich-Log", () => {
|
||
beforeEach(datenbankLeeren);
|
||
|
||
/** Ein Protokolleintrag, wie ihn ein Abgleich schreibt. */
|
||
async function logEintrag(
|
||
quelleId: string,
|
||
nachher: Record<string, number | string>,
|
||
benutzerId: string | null,
|
||
gescheitert = false,
|
||
) {
|
||
return testPrisma.protokoll.create({
|
||
data: {
|
||
entitaet: "Verzeichnisquelle",
|
||
entitaetId: quelleId,
|
||
aktion: gescheitert ? "Verzeichnisabgleich fehlgeschlagen" : "Verzeichnis abgeglichen",
|
||
benutzerId,
|
||
nachher,
|
||
},
|
||
});
|
||
}
|
||
|
||
it("zeigt die Laeufe mit ihren Zahlen, der neueste zuerst", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
await logEintrag(
|
||
quelle.id,
|
||
{ gelesen: 4, angelegt: 3, uebernommen: 0, aktualisiert: 0, deaktiviert: 0, uebersprungen: 1 },
|
||
admin.id,
|
||
);
|
||
await logEintrag(quelle.id, { gelesen: 0, fehler: "Anmeldung abgelehnt" }, null, true);
|
||
|
||
const zeilen = await abgleichLog(quelle.id, admin);
|
||
expect(zeilen).toHaveLength(2);
|
||
expect(zeilen[0]).toMatchObject({ gescheitert: true, fehler: "Anmeldung abgelehnt", durch: null });
|
||
expect(zeilen[1]).toMatchObject({
|
||
gescheitert: false,
|
||
gelesen: 4,
|
||
angelegt: 3,
|
||
uebersprungen: 1,
|
||
durch: "Admin",
|
||
});
|
||
});
|
||
|
||
it("nimmt nur die Abgleich-Eintraege dieser Quelle", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
const andere = await quelleAnlegen(quellenEingabe({ name: "Zweites AD" }), admin);
|
||
await logEintrag(quelle.id, { gelesen: 1 }, admin.id);
|
||
await logEintrag(andere.id, { gelesen: 99 }, admin.id);
|
||
// Auch das Anlegen der Quelle steht im Protokoll – es ist kein Abgleich.
|
||
const zeilen = await abgleichLog(quelle.id, admin);
|
||
expect(zeilen).toHaveLength(1);
|
||
expect(zeilen[0]?.gelesen).toBe(1);
|
||
});
|
||
|
||
it("haelt sich an dieselbe Grenze wie die Quellenliste", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
for (let lauf = 0; lauf < 12; lauf += 1) {
|
||
await logEintrag(quelle.id, { gelesen: lauf }, admin.id);
|
||
}
|
||
expect(await abgleichLog(quelle.id, admin)).toHaveLength(LOG_ZEILEN);
|
||
expect(await abgleichLog(quelle.id, admin, 3)).toHaveLength(3);
|
||
});
|
||
|
||
it("ist im Modus Dienstleistung leer, auch wenn Eintraege stehen", async () => {
|
||
const { admin } = await grundbestand();
|
||
const quelle = await quelleAnlegen(quellenEingabe(), admin);
|
||
await logEintrag(quelle.id, { gelesen: 4 }, admin.id);
|
||
await testPrisma.einstellung.update({
|
||
where: { id: "global" },
|
||
data: { modus: Betriebsmodus.DIENSTLEISTUNG },
|
||
});
|
||
expect(await abgleichLog(quelle.id, admin)).toEqual([]);
|
||
});
|
||
|
||
it("gibt zu einer unbekannten Quelle nichts heraus", async () => {
|
||
const { admin } = await grundbestand();
|
||
expect(await abgleichLog("gibtsnicht", admin)).toEqual([]);
|
||
});
|
||
});
|