@nathapp/nax 0.19.0 → 0.21.0

package/test/unit/execution/lifecycle/run-regression.test.ts

@@ -0,0 +1,418 @@
+/**
+ * Smart Runner Reverse Mapping Tests + Deferred Regression Gate Tests
+ *
+ * Covers:
+ * - reverseMapTestToSource: maps test files back to source files
+ * - runDeferredRegression: deferred regression gate behavior
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import type { NaxConfig } from "../../../../src/config";
+import type { PRD, UserStory } from "../../../../src/prd";
+import { DEFAULT_CONFIG } from "../../../../src/config/defaults";
+import {
+  _regressionDeps,
+  runDeferredRegression,
+} from "../../../../src/execution/lifecycle/run-regression";
+import type { VerificationResult } from "../../../../src/verification";
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+function makeStory(id: string, status: UserStory["status"]): UserStory {
+  return {
+    id,
+    title: `Story ${id}`,
+    description: "Test story",
+    acceptanceCriteria: [],
+    tags: [],
+    dependencies: [],
+    status,
+    passes: status === "passed",
+    escalations: [],
+    attempts: 1,
+  };
+}
+
+function makePRD(stories: Array<{ id: string; status: UserStory["status"] }>): PRD {
+  return {
+    project: "test-project",
+    feature: "test-feature",
+    branchName: "test-branch",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    userStories: stories.map(({ id, status }) => makeStory(id, status)),
+  };
+}
+
+function makeConfig(
+  regressionMode?: "deferred" | "per-story" | "disabled",
+  testCommand?: string,
+): NaxConfig {
+  return {
+    ...DEFAULT_CONFIG,
+    execution: {
+      ...DEFAULT_CONFIG.execution,
+      regressionGate: {
+        enabled: true,
+        timeoutSeconds: 30,
+        acceptOnTimeout: true,
+        ...(regressionMode !== undefined ? { mode: regressionMode } : {}),
+        maxRectificationAttempts: 2,
+      },
+    },
+    quality: {
+      ...DEFAULT_CONFIG.quality,
+      commands: {
+        ...(testCommand ? { test: testCommand } : {}),
+      },
+    },
+  };
+}
+
+describe("reverseMapTestToSource", () => {
+  test("should map test/unit files to source files", async () => {
+    const { reverseMapTestToSource } = await import("../../../../src/verification/smart-runner");
+
+    const testFiles = ["/repo/test/unit/foo/bar.test.ts"];
+    const result = reverseMapTestToSource(testFiles, "/repo");
+
+    expect(result).toEqual(["src/foo/bar.ts"]);
+  });
+
+  test("should map test/integration files to source files", async () => {
+    const { reverseMapTestToSource } = await import("../../../../src/verification/smart-runner");
+
+    const testFiles = ["/repo/test/integration/foo/bar.test.ts"];
+    const result = reverseMapTestToSource(testFiles, "/repo");
+
+    expect(result).toEqual(["src/foo/bar.ts"]);
+  });
+
+  test("should ignore non-test files", async () => {
+    const { reverseMapTestToSource } = await import("../../../../src/verification/smart-runner");
+
+    const testFiles = ["/repo/src/foo/bar.ts"];
+    const result = reverseMapTestToSource(testFiles, "/repo");
+
+    expect(result).toEqual([]);
+  });
+
+  test("should deduplicate results", async () => {
+    const { reverseMapTestToSource } = await import("../../../../src/verification/smart-runner");
+
+    const testFiles = ["/repo/test/unit/foo/bar.test.ts", "/repo/test/integration/foo/bar.test.ts"];
+    const result = reverseMapTestToSource(testFiles, "/repo");
+
+    expect(result).toEqual(["src/foo/bar.ts"]);
+  });
+
+  test("should handle paths without leading workdir", async () => {
+    const { reverseMapTestToSource } = await import("../../../../src/verification/smart-runner");
+
+    const testFiles = ["test/unit/foo/bar.test.ts"];
+    const result = reverseMapTestToSource(testFiles, "/repo");
+
+    expect(result).toEqual(["src/foo/bar.ts"]);
+  });
+
+  test("should preserve order when mapping multiple files", async () => {
+    const { reverseMapTestToSource } = await import("../../../../src/verification/smart-runner");
+
+    const testFiles = [
+      "/repo/test/unit/aaa.test.ts",
+      "/repo/test/unit/bbb.test.ts",
+      "/repo/test/unit/ccc.test.ts",
+    ];
+    const result = reverseMapTestToSource(testFiles, "/repo");
+
+    expect(result).toEqual(["src/aaa.ts", "src/bbb.ts", "src/ccc.ts"]);
+  });
+
+  test("should handle empty input", async () => {
+    const { reverseMapTestToSource } = await import("../../../../src/verification/smart-runner");
+
+    const testFiles: string[] = [];
+    const result = reverseMapTestToSource(testFiles, "/repo");
+
+    expect(result).toEqual([]);
+  });
+
+  test("should filter out files with .test.js extension", async () => {
+    const { reverseMapTestToSource } = await import("../../../../src/verification/smart-runner");
+
+    // Only .test.ts files should be mapped (not .test.js)
+    const testFiles = ["/repo/test/unit/foo.js"];
+    const result = reverseMapTestToSource(testFiles, "/repo");
+
+    expect(result).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runDeferredRegression
+// ---------------------------------------------------------------------------
+
+describe("runDeferredRegression", () => {
+  test("returns success immediately when mode is 'disabled'", async () => {
+    const { runDeferredRegression } = await import(
+      "../../../../src/execution/lifecycle/run-regression"
+    );
+
+    const result = await runDeferredRegression({
+      config: makeConfig("disabled", "bun test"),
+      prd: makePRD([{ id: "US-001", status: "passed" }]),
+      workdir: "/tmp/nax-test-disabled",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.failedTests).toBe(0);
+    expect(result.rectificationAttempts).toBe(0);
+    expect(result.affectedStories).toEqual([]);
+  });
+
+  test("returns success immediately when mode is 'per-story' (deferred not applicable)", async () => {
+    const { runDeferredRegression } = await import(
+      "../../../../src/execution/lifecycle/run-regression"
+    );
+
+    const result = await runDeferredRegression({
+      config: makeConfig("per-story", "bun test"),
+      prd: makePRD([{ id: "US-001", status: "passed" }]),
+      workdir: "/tmp/nax-test-per-story",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.rectificationAttempts).toBe(0);
+    expect(result.affectedStories).toEqual([]);
+  });
+
+  test("returns success when no passed stories exist (partial completion)", async () => {
+    const { runDeferredRegression } = await import(
+      "../../../../src/execution/lifecycle/run-regression"
+    );
+
+    const result = await runDeferredRegression({
+      config: makeConfig("deferred", "bun test"),
+      prd: makePRD([
+        { id: "US-001", status: "pending" },
+        { id: "US-002", status: "failed" },
+      ]),
+      workdir: "/tmp/nax-test-no-passed",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.passedTests).toBe(0);
+    expect(result.failedTests).toBe(0);
+    expect(result.affectedStories).toEqual([]);
+  });
+
+  test("result shape has all required fields", async () => {
+    const { runDeferredRegression } = await import(
+      "../../../../src/execution/lifecycle/run-regression"
+    );
+
+    const result = await runDeferredRegression({
+      config: makeConfig("disabled", "bun test"),
+      prd: makePRD([]),
+      workdir: "/tmp/nax-test-shape",
+    });
+
+    expect(typeof result.success).toBe("boolean");
+    expect(typeof result.failedTests).toBe("number");
+    expect(typeof result.passedTests).toBe("number");
+    expect(typeof result.rectificationAttempts).toBe("number");
+    expect(Array.isArray(result.affectedStories)).toBe(true);
+  });
+
+  test("affectedStories contains only string values", async () => {
+    const { runDeferredRegression } = await import(
+      "../../../../src/execution/lifecycle/run-regression"
+    );
+
+    const result = await runDeferredRegression({
+      config: makeConfig("disabled", "bun test"),
+      prd: makePRD([{ id: "US-001", status: "passed" }]),
+      workdir: "/tmp/nax-test-story-ids",
+    });
+
+    for (const storyId of result.affectedStories) {
+      expect(typeof storyId).toBe("string");
+    }
+  });
+
+  test("passedTests is non-negative integer", async () => {
+    const { runDeferredRegression } = await import(
+      "../../../../src/execution/lifecycle/run-regression"
+    );
+
+    const result = await runDeferredRegression({
+      config: makeConfig("disabled", "bun test"),
+      prd: makePRD([{ id: "US-001", status: "passed" }]),
+      workdir: "/tmp/nax-test-counts",
+    });
+
+    expect(result.passedTests).toBeGreaterThanOrEqual(0);
+    expect(Number.isInteger(result.passedTests)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runDeferredRegression — behavioral tests with mocked _regressionDeps
+// ---------------------------------------------------------------------------
+
+const origRegressionDeps = {
+  runVerification: _regressionDeps.runVerification,
+  runRectificationLoop: _regressionDeps.runRectificationLoop,
+  parseBunTestOutput: _regressionDeps.parseBunTestOutput,
+  reverseMapTestToSource: _regressionDeps.reverseMapTestToSource,
+};
+
+beforeEach(() => {
+  // Reset mocks to identity (no-op) before each behavioral test
+  // Specific tests override as needed
+  _regressionDeps.runRectificationLoop = mock(async () => false);
+  _regressionDeps.reverseMapTestToSource = mock(() => []);
+});
+
+afterEach(() => {
+  Object.assign(_regressionDeps, origRegressionDeps);
+  mock.restore();
+});
+
+describe("runDeferredRegression - behavioral tests (with mocked deps)", () => {
+  test("full suite passes → success with 0 rectification attempts", async () => {
+    _regressionDeps.runVerification = mock(async (): Promise<VerificationResult> => ({
+      status: "SUCCESS",
+      success: true,
+      countsTowardEscalation: true,
+      passCount: 42,
+    }));
+
+    const result = await runDeferredRegression({
+      config: makeConfig("deferred", "bun test"),
+      prd: makePRD([{ id: "US-001", status: "passed" }]),
+      workdir: "/tmp/nax-test-behavioral",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.passedTests).toBe(42);
+    expect(result.rectificationAttempts).toBe(0);
+    expect(result.affectedStories).toEqual([]);
+  });
+
+  test("TIMEOUT + acceptOnTimeout=true → success", async () => {
+    _regressionDeps.runVerification = mock(async (): Promise<VerificationResult> => ({
+      status: "TIMEOUT",
+      success: false,
+      countsTowardEscalation: false,
+    }));
+
+    const config = makeConfig("deferred", "bun test");
+    // acceptOnTimeout=true is already default in makeConfig
+    const result = await runDeferredRegression({
+      config,
+      prd: makePRD([{ id: "US-001", status: "passed" }]),
+      workdir: "/tmp/nax-test-timeout-accept",
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.rectificationAttempts).toBe(0);
+  });
+
+  test("TIMEOUT + acceptOnTimeout=false → failure", async () => {
+    _regressionDeps.runVerification = mock(async (): Promise<VerificationResult> => ({
+      status: "TIMEOUT",
+      success: false,
+      countsTowardEscalation: false,
+    }));
+
+    const config: NaxConfig = {
+      ...makeConfig("deferred", "bun test"),
+      execution: {
+        ...makeConfig("deferred", "bun test").execution,
+        regressionGate: {
+          enabled: true,
+          timeoutSeconds: 30,
+          acceptOnTimeout: false,
+          mode: "deferred",
+          maxRectificationAttempts: 2,
+        },
+      },
+    };
+
+    const result = await runDeferredRegression({
+      config,
+      prd: makePRD([{ id: "US-001", status: "passed" }]),
+      workdir: "/tmp/nax-test-timeout-reject",
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  test("full suite fails with no output → failure immediately (no rectification)", async () => {
+    _regressionDeps.runVerification = mock(async (): Promise<VerificationResult> => ({
+      status: "TEST_FAILURE",
+      success: false,
+      countsTowardEscalation: true,
+      failCount: 3,
+      // no output field
+    }));
+
+    const result = await runDeferredRegression({
+      config: makeConfig("deferred", "bun test"),
+      prd: makePRD([{ id: "US-001", status: "passed" }]),
+      workdir: "/tmp/nax-test-no-output",
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.rectificationAttempts).toBe(0);
+  });
+
+  test("unmapped failures (no file field) → all passed stories in affectedStories", async () => {
+    let verCallCount = 0;
+    _regressionDeps.runVerification = mock(async (): Promise<VerificationResult> => {
+      verCallCount++;
+      if (verCallCount === 1) {
+        return {
+          status: "TEST_FAILURE",
+          success: false,
+          countsTowardEscalation: true,
+          output: "FAIL: some test\nerror: boom",
+          failCount: 1,
+        };
+      }
+      // second call (after rectification) still fails
+      return {
+        status: "TEST_FAILURE",
+        success: false,
+        countsTowardEscalation: true,
+        failCount: 1,
+      };
+    });
+
+    // parseBunTestOutput returns failures WITHOUT file property (unmapped)
+    // Cast via unknown to satisfy TestFailure type while testing the undefined case
+    _regressionDeps.parseBunTestOutput = mock(() => ({
+      failed: 1,
+      passed: 5,
+      failures: [{ testName: "some test", error: "boom" }],
+    })) as unknown as typeof _regressionDeps.parseBunTestOutput;
+
+    _regressionDeps.runRectificationLoop = mock(async () => false);
+
+    const result = await runDeferredRegression({
+      config: makeConfig("deferred", "bun test"),
+      prd: makePRD([
+        { id: "US-001", status: "passed" },
+        { id: "US-002", status: "passed" },
+      ]),
+      workdir: "/tmp/nax-test-unmapped",
+    });
+
+    // Both passed stories should be marked as affected (unmapped case)
+    expect(result.affectedStories).toContain("US-001");
+    expect(result.affectedStories).toContain("US-002");
+  });
+});