> ## Documentation Index > Fetch the complete documentation index at: https://exosphere-auto-translate-docs-20260623-1106.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Tests > Unit-Tests, E2E-Tests und Test-Hilfsmittel failproofai verfügt über zwei Test-Suites: **Unit-Tests** (schnell, gemockt) und **End-to-End-Tests** (echte Subprozessaufrufe). *** ## Tests ausführen ```bash theme={null} # Alle Unit-Tests einmalig ausführen bun run test:run # Unit-Tests im Watch-Modus ausführen bun run test # E2E-Tests ausführen (erfordert Einrichtung – siehe unten) bun run test:e2e # Typprüfung ohne Build bunx tsc --noEmit # Linting bun run lint ``` *** ## Unit-Tests Unit-Tests befinden sich in `__tests__/` und verwenden [Vitest](https://vitest.dev) mit `jsdom`. ```text theme={null} __tests__/ hooks/ builtin-policies.test.ts # Policy-Logik für jede eingebaute Policy hooks-config.test.ts # Konfigurationsladen und Scope-Zusammenführung policy-evaluator.test.ts # Parameter-Injektion und Auswertungsreihenfolge custom-hooks-registry.test.ts # globalThis registry add/get/clear custom-hooks-loader.test.ts # ESM loader, transitive imports, error handling manager.test.ts # install/remove/list operations components/ sessions-list.test.tsx # Session-Listen-Komponente project-list.test.tsx # Projektlisten-Komponente ... lib/ logger.test.ts paths.test.ts date-filters.test.ts telemetry.test.ts ... actions/ get-hooks-config.test.ts get-hook-activity.test.ts ... contexts/ ThemeContext.test.tsx AutoRefreshContext.test.tsx ``` ### Einen Policy-Unit-Test schreiben ```typescript theme={null} import { describe, it, expect, beforeEach } from "vitest"; import { getBuiltinPolicies } from "../../src/hooks/builtin-policies"; import { allow, deny } from "../../src/hooks/policy-types"; describe("block-sudo", () => { const policy = getBuiltinPolicies().find((p) => p.name === "block-sudo")!; it("denies sudo commands", () => { const ctx = { eventType: "PreToolUse" as const, payload: {}, toolName: "Bash", toolInput: { command: "sudo apt install nodejs" }, params: { allowPatterns: [] }, }; expect(policy.fn(ctx)).toEqual(deny("sudo command blocked by failproofai")); }); it("allows non-sudo commands", () => { const ctx = { eventType: "PreToolUse" as const, payload: {}, toolName: "Bash", toolInput: { command: "ls -la" }, params: { allowPatterns: [] }, }; expect(policy.fn(ctx)).toEqual(allow()); }); it("allows patterns in allowPatterns", () => { const ctx = { eventType: "PreToolUse" as const, payload: {}, toolName: "Bash", toolInput: { command: "sudo systemctl status nginx" }, params: { allowPatterns: ["sudo systemctl status"] }, }; expect(policy.fn(ctx)).toEqual(allow()); }); }); ``` *** ## End-to-End-Tests E2E-Tests rufen das echte `failproofai`-Binary als Subprozess auf, leiten eine JSON-Nutzlast an stdin weiter und prüfen die stdout-Ausgabe sowie den Exit-Code. Damit wird der vollständige Integrationspfad getestet, den Claude Code verwendet. ### Einrichtung E2E-Tests führen das Binary direkt aus dem Repository-Quellcode aus. Vor dem ersten Durchlauf muss das CJS-Bundle erstellt werden, das benutzerdefinierte Hook-Dateien verwenden, wenn sie aus `'failproofai'` importieren: ```bash theme={null} bun build src/index.ts --outdir dist --target node --format cjs ``` Anschließend die Tests ausführen: ```bash theme={null} bun run test:e2e ``` `dist/` muss neu gebaut werden, wenn die öffentliche Hook-API geändert wird (`src/hooks/custom-hooks-registry.ts`, `src/hooks/policy-helpers.ts` oder `src/hooks/policy-types.ts`). ### E2E-Teststruktur ```text theme={null} __tests__/e2e/ helpers/ hook-runner.ts # Binary starten, Nutzlast-JSON weiterleiten, Exit-Code + stdout + stderr erfassen fixture-env.ts # Pro Test isolierte temporäre Verzeichnisse mit Konfigurationsdateien payloads.ts # Claude-konforme Nutzlast-Factories für jeden Event-Typ hooks/ builtin-policies.e2e.test.ts # Jede eingebaute Policy mit echtem Subprozess custom-hooks.e2e.test.ts # Laden und Auswerten benutzerdefinierter Hooks config-scopes.e2e.test.ts # Konfigurationszusammenführung über project/local/global policy-params.e2e.test.ts # Parameter-Injektion für jede parametrisierte Policy ``` ### Die E2E-Hilfsmittel verwenden **`FixtureEnv`** – isolierte Umgebung pro Test: ```typescript theme={null} import { createFixtureEnv } from "../helpers/fixture-env"; const env = createFixtureEnv(); // env.cwd - temporäres Verzeichnis; als payload.cwd übergeben, um .failproofai/policies-config.json zu laden // env.home - isoliertes Home-Verzeichnis; kein echtes ~/.failproofai wird eingelesen env.writeConfig({ enabledPolicies: ["block-sudo"], policyParams: { "block-sudo": { allowPatterns: ["sudo systemctl status"] }, }, }); ``` `createFixtureEnv()` registriert die `afterEach`-Bereinigung automatisch. **`runHook`** – das Binary aufrufen: ```typescript theme={null} import { runHook } from "../helpers/hook-runner"; import { Payloads } from "../helpers/payloads"; const result = await runHook( "PreToolUse", Payloads.preToolUse.bash("sudo apt install nodejs", env.cwd), { homeDir: env.home } ); expect(result.exitCode).toBe(0); expect(result.parsed?.hookSpecificOutput?.permissionDecision).toBe("deny"); ``` **`Payloads`** – vorgefertigte Nutzlast-Factories: ```typescript theme={null} Payloads.preToolUse.bash(command, cwd) Payloads.preToolUse.write(filePath, content, cwd) Payloads.preToolUse.read(filePath, cwd) Payloads.postToolUse.bash(command, output, cwd) Payloads.postToolUse.read(filePath, content, cwd) Payloads.notification(message, cwd) Payloads.stop(cwd) ``` ### Einen E2E-Test schreiben ```typescript theme={null} import { describe, it, expect } from "vitest"; import { createFixtureEnv } from "../helpers/fixture-env"; import { runHook } from "../helpers/hook-runner"; import { Payloads } from "../helpers/payloads"; describe("block-rm-rf (E2E)", () => { it("denies rm -rf", async () => { const env = createFixtureEnv(); env.writeConfig({ enabledPolicies: ["block-rm-rf"] }); const result = await runHook( "PreToolUse", Payloads.preToolUse.bash("rm -rf /", env.cwd), { homeDir: env.home } ); expect(result.exitCode).toBe(0); expect(result.parsed?.hookSpecificOutput?.permissionDecision).toBe("deny"); }); it("allows non-recursive rm", async () => { const env = createFixtureEnv(); env.writeConfig({ enabledPolicies: ["block-rm-rf"] }); const result = await runHook( "PreToolUse", Payloads.preToolUse.bash("rm /tmp/file.txt", env.cwd), { homeDir: env.home } ); expect(result.exitCode).toBe(0); expect(result.stdout).toBe(""); // allow → leerer stdout }); }); ``` ### E2E-Antwortformate | Entscheidung | Exit-Code | stdout | | -------------------- | --------- | --------------------------------------------------------------------------------------- | | `PreToolUse` deny | `0` | `{"hookSpecificOutput":{"permissionDecision":"deny","permissionDecisionReason":"..."}}` | | `PostToolUse` deny | `0` | `{"hookSpecificOutput":{"additionalContext":"Blocked ... because: ..."}}` | | Instruct (kein Stop) | `0` | `{"hookSpecificOutput":{"additionalContext":"Instruction from failproofai: ..."}}` | | Stop instruct | `2` | leerer stdout; Begründung in stderr | | Allow | `0` | leere Zeichenkette | ### Vitest-Konfiguration E2E-Tests verwenden `vitest.config.e2e.mts` mit: * `environment: "node"` – keine Browser-Globals erforderlich * `pool: "forks"` – echte Prozessisolierung (Tests starten Subprozesse) * `testTimeout: 20_000` – 20 Sekunden pro Test (Binary-Start + Hook-Auswertung) Der `forks`-Pool ist wichtig: Thread-basierte Worker teilen sich `globalThis`, was Konflikte mit Tests verursachen kann, die Subprozesse starten. Prozessbasierte Forks vermeiden dieses Problem. *** ## CI Der vollständige CI-Durchlauf (`bun run lint && bunx tsc --noEmit && bun run test:run && bun run build`) muss vor dem Mergen erfolgreich abgeschlossen werden. Die E2E-Suite läuft als separater CI-Job parallel dazu. Siehe [Contributing](../CONTRIBUTING.md) für die vollständige Checkliste vor dem Mergen.