@gotgenes/pi-permission-system 10.4.0 → 10.5.1

package/test/helpers/handler-fixtures.ts

@@ -1,15 +1,16 @@
 /**
  * Shared handler-level test fixtures for PermissionGateHandler tests.
  *
- * All factories use override bags so callers can specialize any field
- * without constructing the full object from scratch.
+ * `makeHandler` builds a real PermissionSession + PermissionResolver and wires
+ * them into the handler and pipelines exactly as `index.ts` does.
+ * Call-site overrides for permission results flow through
+ * `permissionManager.checkPermission`; session state overrides are applied
+ * via vi.spyOn on the real session instance.
  */
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { vi } from "vitest";
 
 import { GateDecisionReporter } from "#src/decision-reporter";
-import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
-import type { GateHandlerSession } from "#src/gate-handler-session";
 import type { GatePrompter } from "#src/gate-prompter";
 import { GateRunner } from "#src/handlers/gates/runner";
 import {
@@ -24,32 +25,33 @@ import { PermissionGateHandler } from "#src/handlers/permission-gate-handler";
 import type { PermissionDecisionEvent } from "#src/permission-events";
 import { PERMISSIONS_DECISION_CHANNEL } from "#src/permission-events";
 import type { Rule } from "#src/rule";
-import type { SessionApprovalRecorder } from "#src/session-approval-recorder";
 import type { SessionLogger } from "#src/session-logger";
-import { resolveToolPreviewLimits } from "#src/tool-preview-formatter";
+import { SessionRules } from "#src/session-rules";
 import type { ToolRegistry } from "#src/tool-registry";
 import type { PermissionCheckResult, PermissionState } from "#src/types";
+import {
+  makeRealResolver,
+  makeRealSession,
+} from "#test/helpers/session-fixtures";
+
+// ── MockGateHandlerSession ────────────────────────────────────────────────
 
 /**
- * Precise mock boundary for PermissionGateHandler integration tests.
+ * Mock type for gate-pipeline inputs (ToolCallGateInputs + SkillInputGateInputs).
  *
- * Intersection of every role the handler and its collaborators require.
- * Prompting is not included here — it moved to `PromptingGateway` (#339).
- * Pass a `prompter` override to `makeHandler` to steer GateRunner's prompting
- * role; `makeHandler` creates a clean default prompter when none is supplied.
+ * Used by `makeSurfaceCheck`, `makeBashCommandCheck`, and the `session`
+ * override bag in `makeHandler`.  The `GateHandlerSession` role (activate +
+ * resolveAgentName) is now satisfied by the real `PermissionSession`; this
+ * type covers only the pipeline input surface.
  *
- * The 4-arg `checkPermission` overrides the 3-arg version from
- * GateHandlerSession so the `resolve` delegation can forward session rules.
+ * The 4-arg `checkPermission` is a superset of `SkillInputGateInputs` —
+ * it routes through `permissionManager.checkPermission` in production.
  */
 export type MockGateHandlerSession = ToolCallGateInputs &
-  SkillInputGateInputs &
-  SessionApprovalRecorder &
-  GateHandlerSession & {
-    /** Logger source for the reporter the fixture builds. */
+  SkillInputGateInputs & {
+    /** Logger shape expected by GateDecisionReporter. */
     logger: SessionLogger;
-    /** Session-rule accessor — used by the resolve delegation. */
-    getSessionRuleset(): Rule[];
-    /** 4-arg form so the resolve delegation can pass rules. */
+    /** 4-arg form so surface-check mocks can receive optional rules. */
     checkPermission(
       surface: string,
       input: unknown,
@@ -58,6 +60,8 @@ export type MockGateHandlerSession = ToolCallGateInputs &
     ): PermissionCheckResult;
   };
 
+// ── Small utility factories ───────────────────────────────────────────────
+
 export function makeEvents() {
   return {
     emit: vi.fn(),
@@ -117,73 +121,6 @@ export function makeCheckResult(
   };
 }
 
-/**
- * Full-intersection session stub.
- *
- * Uses per-field `??` selection (no spread) so TypeScript verifies every
- * field against `MockGateHandlerSession` individually — a missing field fails
- * `pnpm run check` instead of failing silently at runtime.
- *
- * The `resolve` delegation is inlined as a closure that reads `session` at
- * call time, so overriding `checkPermission` or `getSessionRuleset`
- * automatically steers it without extra guards.
- *
- * Prompting is not part of this mock — pass `prompter` to `makeHandler`.
- */
-export function makeSession(
-  overrides: Partial<MockGateHandlerSession> = {},
-): MockGateHandlerSession {
-  const session: MockGateHandlerSession = {
-    logger: overrides.logger ?? {
-      debug: vi.fn(),
-      review: vi.fn(),
-      warn: vi.fn(),
-    },
-    activate: overrides.activate ?? vi.fn<MockGateHandlerSession["activate"]>(),
-    resolveAgentName:
-      overrides.resolveAgentName ??
-      vi.fn<MockGateHandlerSession["resolveAgentName"]>().mockReturnValue(null),
-    checkPermission:
-      overrides.checkPermission ??
-      vi
-        .fn<MockGateHandlerSession["checkPermission"]>()
-        .mockReturnValue(makeCheckResult()),
-    getSessionRuleset:
-      overrides.getSessionRuleset ??
-      vi.fn<MockGateHandlerSession["getSessionRuleset"]>().mockReturnValue([]),
-    recordSessionApproval:
-      overrides.recordSessionApproval ??
-      vi.fn<MockGateHandlerSession["recordSessionApproval"]>(),
-    getActiveSkillEntries:
-      overrides.getActiveSkillEntries ??
-      vi
-        .fn<MockGateHandlerSession["getActiveSkillEntries"]>()
-        .mockReturnValue([]),
-    getInfrastructureReadDirs:
-      overrides.getInfrastructureReadDirs ??
-      vi
-        .fn<MockGateHandlerSession["getInfrastructureReadDirs"]>()
-        .mockReturnValue(["/test/agent", "/test/agent/git"]),
-    getToolPreviewLimits:
-      overrides.getToolPreviewLimits ??
-      vi
-        .fn<MockGateHandlerSession["getToolPreviewLimits"]>()
-        .mockReturnValue(resolveToolPreviewLimits(DEFAULT_EXTENSION_CONFIG)),
-    // Resolve delegation — closure reads `session` at call time so overrides win.
-    resolve:
-      overrides.resolve ??
-      vi.fn<MockGateHandlerSession["resolve"]>((surface, input, agentName) =>
-        session.checkPermission(
-          surface,
-          input,
-          agentName,
-          session.getSessionRuleset(),
-        ),
-      ),
-  };
-  return session;
-}
-
 export function makeToolRegistry(
   overrides: Partial<ToolRegistry> = {},
 ): ToolRegistry {
@@ -194,14 +131,14 @@ export function makeToolRegistry(
   };
 }
 
+// ── Surface-check factories ────────────────────────────────────────────────
+
 /**
  * Surface-dispatching `checkPermission` mock.
  *
- * Builds a `vi.fn()` that returns a `PermissionCheckResult` for each surface,
- * using `bySurface[surface]` when matched and `defaultResult` otherwise.
- * Default fields: `toolName` = the surface string, `source: "tool"`,
- * `origin: "builtin"` — callers override by including the field in the
- * per-surface or default partial (e.g. `{ path: { state: "allow", source: "special" } }`).
+ * Returns the matching per-surface result or `defaultResult`.
+ * Pass the returned function as `session.checkPermission` in a `makeHandler`
+ * override bag — it is applied to `permissionManager.checkPermission`.
  *
  * Return type is intentionally unannotated so callers retain full `vi.fn()`
  * mock access (`mock.calls`, `toHaveBeenCalledWith`, etc.).
@@ -231,9 +168,8 @@ export function makeSurfaceCheck(
 /**
  * Bash-surface `checkPermission` mock that dispatches on a command regex.
  *
- * For the `bash` surface: returns a deny result when `opts.deny` matches the
- * command, and an allow result otherwise.  For all other surfaces, returns a
- * plain allow result.
+ * Pass the returned function as `session.checkPermission` in a `makeHandler`
+ * override bag — it is applied to `permissionManager.checkPermission`.
  *
  * Return type is intentionally unannotated so callers retain full `vi.fn()`
  * mock access.
@@ -266,24 +202,68 @@ export function makeBashCommandCheck(opts: {
     });
 }
 
+// ── makeHandler ────────────────────────────────────────────────────────────
+
 /**
- * Constructs a PermissionGateHandler with mocked collaborators.
+ * Constructs a PermissionGateHandler wired with real collaborators.
  *
- * Returns all collaborators so each test file can destructure only what
- * it needs — handler, events, session, toolRegistry, and prompter are all available.
+ * The `session` override bag maps to the real collaborators:
+ * - `checkPermission` → applied to `permissionManager.checkPermission`
+ * - `getActiveSkillEntries`, `getInfrastructureReadDirs`, `getToolPreviewLimits`
+ *   → applied as vi.spyOn overrides on the real session
+ * - `resolveAgentName` → applied as a vi.spyOn override on the real session
  *
- * The default prompter approves all requests. Pass `prompter` explicitly to
- * steer canConfirm/prompt behavior for the test.
+ * Returns `{ handler, events, session, toolRegistry, prompter, recorder,
+ * permissionManager, forwarding }` so each test file can destructure only
+ * what it needs.
+ * `session.activate` is not a mock — use `forwarding.start` to assert it
+ * was called.
  */
 export function makeHandler(overrides?: {
-  session?: Partial<MockGateHandlerSession>;
+  session?: Partial<MockGateHandlerSession> & {
+    resolveAgentName?: (
+      ctx: ExtensionContext,
+      systemPrompt?: string,
+    ) => string | null;
+  };
   /** Override the GatePrompter passed to GateRunner. Defaults to an allow-all stub. */
   prompter?: GatePrompter;
   toolRegistry?: Partial<ToolRegistry>;
   /** Sugar: builds the `getAll` mock from a list of tool names. */
   tools?: string[];
 }) {
-  const session = makeSession(overrides?.session);
+  const { session, permissionManager, sessionRules, forwarding, logger } =
+    makeRealSession();
+  const { resolver } = makeRealResolver(permissionManager, sessionRules);
+
+  // Apply session override bag to the real collaborators.
+  const so = overrides?.session;
+  if (so?.checkPermission) {
+    vi.mocked(permissionManager.checkPermission).mockImplementation(
+      so.checkPermission,
+    );
+  }
+  if (so?.getActiveSkillEntries) {
+    vi.spyOn(session, "getActiveSkillEntries").mockImplementation(
+      so.getActiveSkillEntries,
+    );
+  }
+  if (so?.getInfrastructureReadDirs) {
+    vi.spyOn(session, "getInfrastructureReadDirs").mockImplementation(
+      so.getInfrastructureReadDirs,
+    );
+  }
+  if (so?.getToolPreviewLimits) {
+    vi.spyOn(session, "getToolPreviewLimits").mockImplementation(
+      so.getToolPreviewLimits,
+    );
+  }
+  if (so?.resolveAgentName) {
+    vi.spyOn(session, "resolveAgentName").mockImplementation(
+      so.resolveAgentName,
+    );
+  }
+
   const events = makeEvents();
   const toolRegistry =
     overrides?.tools !== undefined
@@ -293,16 +273,18 @@ export function makeHandler(overrides?: {
             .mockReturnValue(overrides.tools.map((name) => ({ name }))),
         })
       : makeToolRegistry(overrides?.toolRegistry);
-  const pipeline = new ToolCallGatePipeline(session);
-  const skillInputPipeline = new SkillInputGatePipeline(session);
-  const reporter = new GateDecisionReporter(session.logger, events);
+
+  const recorder = new SessionRules();
+  const pipeline = new ToolCallGatePipeline(resolver, session);
+  const skillInputPipeline = new SkillInputGatePipeline(resolver);
+  const reporter = new GateDecisionReporter(logger, events);
   const prompter: GatePrompter = overrides?.prompter ?? {
     canConfirm: vi.fn().mockReturnValue(true),
     prompt: vi
       .fn<GatePrompter["prompt"]>()
       .mockResolvedValue({ approved: true, state: "approved" }),
   };
-  const runner = new GateRunner(session, session, prompter, reporter);
+  const runner = new GateRunner(resolver, recorder, prompter, reporter);
   const handler = new PermissionGateHandler(
     session,
     toolRegistry,
@@ -310,9 +292,20 @@ export function makeHandler(overrides?: {
     skillInputPipeline,
     runner,
   );
-  return { handler, events, session, toolRegistry, prompter };
+  return {
+    handler,
+    events,
+    session,
+    toolRegistry,
+    prompter,
+    recorder,
+    permissionManager,
+    forwarding,
+  };
 }
 
+// ── Decision-event helper ─────────────────────────────────────────────────
+
 /** Extract all permissions:decision payloads from the events.emit mock. */
 export function getDecisionEvents(
   events: ReturnType<typeof makeEvents>,

package/test/helpers/session-fixtures.ts

@@ -0,0 +1,192 @@
+/**
+ * Shared real-instance test fixtures for PermissionSession and
+ * PermissionResolver.
+ *
+ * Use these instead of hand-rolling per-file mock intersection types.
+ * Build a real PermissionSession from small per-collaborator fakes so tests
+ * assert against actual behavior rather than mock contracts.
+ *
+ * Note: tests that exercise `resolveAgentName` must mock `active-agent` in
+ * their own file (the vi.hoisted / vi.mock pattern from permission-session.test.ts)
+ * since that mock is module-scoped.
+ */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { vi } from "vitest";
+
+import type { SessionConfigStore } from "#src/config-store";
+import { DEFAULT_EXTENSION_CONFIG } from "#src/extension-config";
+import type { ExtensionPaths } from "#src/extension-paths";
+import type { ForwardingController } from "#src/forwarding-manager";
+import type { ScopedPermissionManager } from "#src/permission-manager";
+import { PermissionResolver } from "#src/permission-resolver";
+import { PermissionSession } from "#src/permission-session";
+import type { PromptingGatewayLifecycle } from "#src/prompting-gateway";
+import type { Ruleset } from "#src/rule";
+import type { SessionLogger } from "#src/session-logger";
+import { SessionRules } from "#src/session-rules";
+import type { PermissionCheckResult, PermissionState } from "#src/types";
+
+// ── Per-collaborator fake factories ────────────────────────────────────────
+
+export function makePaths(
+  overrides: Partial<ExtensionPaths> = {},
+): ExtensionPaths {
+  return {
+    agentDir: "/test/agent",
+    sessionsDir: "/test/agent/sessions",
+    subagentSessionsDir: "/test/agent/subagent-sessions",
+    forwardingDir: "/test/agent/sessions/permission-forwarding",
+    globalLogsDir: "/test/agent/logs",
+    piInfrastructureDirs: ["/test/agent", "/test/agent/git"],
+    ...overrides,
+  };
+}
+
+export function makeLogger(): SessionLogger {
+  return {
+    debug: vi.fn(),
+    review: vi.fn(),
+    warn: vi.fn(),
+  };
+}
+
+export function makeConfigStore(
+  overrides: Partial<SessionConfigStore> = {},
+): SessionConfigStore {
+  return {
+    current:
+      overrides.current ??
+      vi
+        .fn<() => typeof DEFAULT_EXTENSION_CONFIG>()
+        .mockReturnValue({ ...DEFAULT_EXTENSION_CONFIG }),
+    refresh: overrides.refresh ?? vi.fn<(ctx?: ExtensionContext) => void>(),
+    logResolvedPaths: overrides.logResolvedPaths ?? vi.fn<() => void>(),
+  };
+}
+
+export function makeGateway(): PromptingGatewayLifecycle {
+  return {
+    activate: vi.fn<PromptingGatewayLifecycle["activate"]>(),
+    deactivate: vi.fn<PromptingGatewayLifecycle["deactivate"]>(),
+  };
+}
+
+export function makeForwarding(): ForwardingController {
+  return {
+    start: vi.fn(),
+    stop: vi.fn(),
+  };
+}
+
+/**
+ * Fake `ScopedPermissionManager` with vi.fn() stubs.
+ *
+ * Return type is intentionally unannotated so callers retain full `vi.fn()`
+ * mock access (`mock.calls`, `toHaveBeenCalledWith`, `mockReturnValue`, etc.).
+ */
+export function makeFakePermissionManager() {
+  return {
+    configureForCwd: vi.fn<(cwd: string | undefined | null) => void>(),
+    checkPermission: vi
+      .fn<
+        (
+          toolName: string,
+          input: unknown,
+          agentName?: string,
+          sessionRules?: Ruleset,
+        ) => PermissionCheckResult
+      >()
+      .mockReturnValue({
+        state: "allow",
+        toolName: "read",
+        source: "tool",
+        origin: "builtin",
+      }),
+    getToolPermission: vi
+      .fn<(toolName: string, agentName?: string) => PermissionState>()
+      .mockReturnValue("allow"),
+    getConfigIssues: vi.fn((): string[] => []),
+    getPolicyCacheStamp: vi.fn((): string => "stamp-1"),
+  };
+}
+
+// ── Real-instance factories ────────────────────────────────────────────────
+
+/**
+ * Build a real PermissionSession from per-collaborator fakes.
+ *
+ * Returns the session and every collaborator so callers can destructure only
+ * what they need and assert against collaborator spies directly.
+ * The `permissionManager` is a `makeFakePermissionManager()` result unless
+ * the caller passes an explicit `ScopedPermissionManager`.
+ */
+export function makeRealSession(overrides?: {
+  paths?: Partial<ExtensionPaths>;
+  logger?: SessionLogger;
+  forwarding?: ForwardingController;
+  permissionManager?: ScopedPermissionManager;
+  sessionRules?: SessionRules;
+  configStore?: SessionConfigStore;
+  gateway?: PromptingGatewayLifecycle;
+}): {
+  session: PermissionSession;
+  paths: ExtensionPaths;
+  logger: SessionLogger;
+  forwarding: ForwardingController;
+  permissionManager: ReturnType<typeof makeFakePermissionManager>;
+  sessionRules: SessionRules;
+  configStore: SessionConfigStore;
+  gateway: PromptingGatewayLifecycle;
+} {
+  const paths = makePaths(overrides?.paths);
+  const logger = overrides?.logger ?? makeLogger();
+  const forwarding = overrides?.forwarding ?? makeForwarding();
+  const permissionManager =
+    (overrides?.permissionManager as
+      | ReturnType<typeof makeFakePermissionManager>
+      | undefined) ?? makeFakePermissionManager();
+  const sessionRules = overrides?.sessionRules ?? new SessionRules();
+  const configStore = overrides?.configStore ?? makeConfigStore();
+  const gateway = overrides?.gateway ?? makeGateway();
+  const session = new PermissionSession(
+    paths,
+    logger,
+    forwarding,
+    permissionManager,
+    sessionRules,
+    configStore,
+    gateway,
+  );
+  return {
+    session,
+    paths,
+    logger,
+    forwarding,
+    permissionManager,
+    sessionRules,
+    configStore,
+    gateway,
+  };
+}
+
+/**
+ * Build a real PermissionResolver from a fake manager and a SessionRules
+ * instance.
+ *
+ * When called with no arguments, creates a fresh fake manager and fresh
+ * SessionRules.  Pass shared instances to connect the resolver to the same
+ * manager/rules used by a real session.
+ */
+export function makeRealResolver(
+  manager?: ReturnType<typeof makeFakePermissionManager>,
+  sessionRules?: SessionRules,
+): {
+  resolver: PermissionResolver;
+  manager: ReturnType<typeof makeFakePermissionManager>;
+  sessionRules: SessionRules;
+} {
+  const resolvedManager = manager ?? makeFakePermissionManager();
+  const resolvedRules = sessionRules ?? new SessionRules();
+  const resolver = new PermissionResolver(resolvedManager, resolvedRules);
+  return { resolver, manager: resolvedManager, sessionRules: resolvedRules };
+}