@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/tools/generate-tests/generateIntegrationRestTool.test.js

@@ -1,159 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-import { jest } from "@jest/globals";
-import * as fs from "fs/promises";
-import * as path from "path";
-import * as os from "os";
-// TestGenerationService transitively loads the @skyramp/skyramp native library
-// (blocks 180s waiting for the platform dylib) — stub the base class out.
-jest.unstable_mockModule("../../services/TestGenerationService.js", () => ({
-    TestGenerationService: class {
-        async generateTest() {
-            return { content: [{ type: "text", text: "generated" }] };
-        }
-        buildBaseGenerationOptions() {
-            return {};
-        }
-    },
-}));
-jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({
-    AnalyticsService: {
-        pushTestGenerationToolEvent: jest.fn().mockResolvedValue(undefined),
-    },
-}));
-jest.unstable_mockModule("../../utils/logger.js", () => ({
-    logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        warning: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-const { registerIntegrationTestTool, IntegrationTestService } = await import("./generateIntegrationRestTool.js");
-const { setActiveRunStatePath, clearActiveRunStatePath } = await import("../../utils/AnalysisStateManager.js");
-const { CandidateSource } = await import("../../types/Recommendation.js");
-/** Build a minimal mock McpServer, register the tool, and return the captured handler. */
-function captureHandler() {
-    let capturedHandler;
-    const mockServer = {
-        registerTool: jest.fn((_name, _meta, handler) => {
-            capturedHandler = handler;
-        }),
-    };
-    registerIntegrationTestTool(mockServer);
-    return capturedHandler;
-}
-const APPROVED_ITEM = {
-    candidateId: "orders-workflow-abcd1234",
-    scenarioName: "orders_workflow",
-    testType: "integration",
-    category: "business_rule",
-    source: CandidateSource.AGENT,
-    matchKeys: ["name:orders-workflow", "ep:integration:POST:/api/v1/orders"],
-};
-async function writeStateFile(dir, approvedPlan) {
-    const stateFile = path.join(dir, "analyze-changes-state.json");
-    await fs.writeFile(stateFile, JSON.stringify({
-        existingTests: [],
-        analysisScope: "current_branch_diff",
-        newEndpoints: [],
-        approvedPlan,
-        metadata: {
-            sessionId: "test-session",
-            stateType: "analysis",
-            createdAt: "2026-01-01T00:00:00.000Z",
-            updatedAt: "2026-01-01T00:00:00.000Z",
-        },
-    }), "utf-8");
-    return stateFile;
-}
-const PLAN = {
-    planId: "plan-int-1",
-    createdAt: "2026-01-01T00:00:00.000Z",
-    generate: [APPROVED_ITEM],
-    additional: [],
-    demotions: [],
-};
-describe("skyramp_integration_test_generation — plan guard on scenarioFile mode", () => {
-    let handler;
-    let generateSpy;
-    let tmpDirs = [];
-    const originalRunnerTemp = process.env.RUNNER_TEMP;
-    beforeEach(() => {
-        handler = captureHandler();
-        generateSpy = jest
-            .spyOn(IntegrationTestService.prototype, "generateTest")
-            .mockResolvedValue({ content: [{ type: "text", text: "generated" }] });
-    });
-    afterEach(async () => {
-        generateSpy.mockRestore();
-        clearActiveRunStatePath();
-        process.env.RUNNER_TEMP = originalRunnerTemp;
-        for (const dir of tmpDirs) {
-            await fs.rm(dir, { recursive: true, force: true });
-        }
-        tmpDirs = [];
-    });
-    async function mkTmpDir() {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "integration-guard-test-"));
-        tmpDirs.push(dir);
-        return dir;
-    }
-    it("allows a scenarioFile whose scenarioName matches an approved GENERATE item", async () => {
-        const dir = await mkTmpDir();
-        setActiveRunStatePath(await writeStateFile(dir, PLAN));
-        const scenarioFile = path.join(dir, "scenario_orders-workflow.json");
-        await fs.writeFile(scenarioFile, JSON.stringify([{ scenarioName: "orders_workflow", method: "POST" }]), "utf-8");
-        const result = await handler({ scenarioFile });
-        expect(result.isError).toBeUndefined();
-        expect(generateSpy).toHaveBeenCalled();
-    });
-    it("rejects (fail closed) when scenarioFile is unreadable and an approved plan is active — no gate bypass", async () => {
-        const dir = await mkTmpDir();
-        setActiveRunStatePath(await writeStateFile(dir, PLAN));
-        const result = await handler({
-            scenarioFile: path.join(dir, "does-not-exist.json"),
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("plan-int-1");
-        expect(generateSpy).not.toHaveBeenCalled();
-    });
-    it("rejects (fail closed) when scenarioFile parses but carries no scenarioName and an approved plan is active", async () => {
-        const dir = await mkTmpDir();
-        setActiveRunStatePath(await writeStateFile(dir, PLAN));
-        const scenarioFile = path.join(dir, "scenario_nameless.json");
-        await fs.writeFile(scenarioFile, JSON.stringify([{ method: "POST", path: "/api/v1/orders" }]), "utf-8");
-        const result = await handler({ scenarioFile });
-        expect(result.isError).toBe(true);
-        expect(generateSpy).not.toHaveBeenCalled();
-    });
-    it("still allows an unreadable scenarioFile when there is no active run state (standalone back-compat)", async () => {
-        clearActiveRunStatePath();
-        delete process.env.RUNNER_TEMP;
-        const result = await handler({
-            scenarioFile: "/nonexistent/scenario.json",
-        });
-        expect(result.isError).toBeUndefined();
-        expect(generateSpy).toHaveBeenCalled();
-    });
-    // SKYR-3884 — filename fallback for files with no embedded scenarioName.
-    it("allows a scenario file with no embedded scenarioName when its filename slug matches the plan (files written by MCP <= 0.3.1)", async () => {
-        const dir = await mkTmpDir();
-        setActiveRunStatePath(await writeStateFile(dir, PLAN));
-        // Bare TraceRequest array — exactly what ScenarioGenerationService wrote
-        // before scenarioName embedding. Identity must come from the file name.
-        const scenarioFile = path.join(dir, "scenario_orders-workflow.json");
-        await fs.writeFile(scenarioFile, JSON.stringify([{ Method: "POST", Path: "/api/v1/orders" }]), "utf-8");
-        const result = await handler({ scenarioFile });
-        expect(result.isError).toBeUndefined();
-        expect(generateSpy).toHaveBeenCalled();
-    });
-    it("still rejects when neither embedded name nor filename slug matches the plan", async () => {
-        const dir = await mkTmpDir();
-        setActiveRunStatePath(await writeStateFile(dir, PLAN));
-        const scenarioFile = path.join(dir, "scenario_unrelated-flow.json");
-        await fs.writeFile(scenarioFile, JSON.stringify([{ Method: "POST", Path: "/api/v1/orders" }]), "utf-8");
-        const result = await handler({ scenarioFile });
-        expect(result.isError).toBe(true);
-        expect(generateSpy).not.toHaveBeenCalled();
-    });
-});

package/build/tools/generate-tests/generateLoadRestTool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tools/generate-tests/generateLoadRestTool.test.js

@@ -1,169 +0,0 @@
-import { z } from "zod";
-import { loadTestSchema, numericString } from "./loadTestSchema.js";
-describe("generateLoadRestTool schema validation", () => {
-    describe("numericString helper", () => {
-        const testSchema = numericString("testParam");
-        it("should accept empty string", () => {
-            const result = testSchema.safeParse("");
-            expect(result.success).toBe(true);
-        });
-        it("should accept valid positive integers", () => {
-            expect(testSchema.safeParse("0").success).toBe(true);
-            expect(testSchema.safeParse("1").success).toBe(true);
-            expect(testSchema.safeParse("100").success).toBe(true);
-            expect(testSchema.safeParse("9999").success).toBe(true);
-        });
-        it("should reject decimal numbers", () => {
-            const result = testSchema.safeParse("1.5");
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues[0].message).toContain("non-negative integer");
-            }
-        });
-        it("should reject negative numbers", () => {
-            const result = testSchema.safeParse("-1");
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues[0].message).toContain("non-negative integer");
-            }
-        });
-        it("should reject non-numeric strings", () => {
-            const result = testSchema.safeParse("abc");
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues[0].message).toContain("non-negative integer");
-            }
-        });
-        it("should reject strings with mixed alphanumeric", () => {
-            const result = testSchema.safeParse("123abc");
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues[0].message).toContain("non-negative integer");
-            }
-        });
-        it("should reject strings with spaces", () => {
-            const result = testSchema.safeParse("1 0");
-            expect(result.success).toBe(false);
-        });
-        it("should reject floating point notation", () => {
-            expect(testSchema.safeParse("1e5").success).toBe(false);
-            expect(testSchema.safeParse("1.0").success).toBe(false);
-        });
-    });
-    describe("loadTestSchema validation", () => {
-        const schema = z.object(loadTestSchema);
-        it("should accept valid load parameters", () => {
-            const result = schema.safeParse({
-                endpointURL: "https://api.example.com/endpoint",
-                method: "GET",
-                language: "python",
-                framework: "pytest",
-                outputDir: "/tmp/tests",
-                prompt: "Generate load test",
-                loadCount: "1000",
-                loadDuration: "60",
-                loadNumThreads: "10",
-                loadRampupDuration: "30",
-                loadRampupInterval: "5",
-                loadTargetRPS: "100",
-            });
-            expect(result.success).toBe(true);
-        });
-        it("should accept empty load parameters", () => {
-            const result = schema.safeParse({
-                endpointURL: "https://api.example.com/endpoint",
-                method: "POST",
-                language: "python",
-                framework: "pytest",
-                outputDir: "/tmp/tests",
-                prompt: "Generate load test",
-                loadCount: "",
-                loadDuration: "",
-                loadNumThreads: "",
-            });
-            expect(result.success).toBe(true);
-        });
-        it("should reject invalid loadDuration (decimal)", () => {
-            const result = schema.safeParse({
-                endpointURL: "https://api.example.com/endpoint",
-                method: "GET",
-                language: "python",
-                framework: "pytest",
-                outputDir: "/tmp/tests",
-                prompt: "Generate load test",
-                loadDuration: "5.5",
-            });
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues[0].message).toContain("non-negative integer");
-                expect(result.error.issues[0].path).toContain("loadDuration");
-            }
-        });
-        it("should reject invalid loadNumThreads (negative)", () => {
-            const result = schema.safeParse({
-                endpointURL: "https://api.example.com/endpoint",
-                method: "GET",
-                language: "python",
-                framework: "pytest",
-                outputDir: "/tmp/tests",
-                prompt: "Generate load test",
-                loadNumThreads: "-5",
-            });
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues[0].path).toContain("loadNumThreads");
-            }
-        });
-        it("should reject invalid loadTargetRPS (non-numeric)", () => {
-            const result = schema.safeParse({
-                endpointURL: "https://api.example.com/endpoint",
-                method: "GET",
-                language: "python",
-                framework: "pytest",
-                outputDir: "/tmp/tests",
-                prompt: "Generate load test",
-                loadTargetRPS: "high",
-            });
-            expect(result.success).toBe(false);
-            if (!result.success) {
-                expect(result.error.issues[0].path).toContain("loadTargetRPS");
-            }
-        });
-        it("should reject invalid loadCount (alphanumeric)", () => {
-            const result = schema.safeParse({
-                endpointURL: "https://api.example.com/endpoint",
-                method: "GET",
-                language: "python",
-                framework: "pytest",
-                outputDir: "/tmp/tests",
-                prompt: "Generate load test",
-                loadCount: "100k",
-            });
-            expect(result.success).toBe(false);
-        });
-        it("should reject invalid loadRampupDuration (with spaces)", () => {
-            const result = schema.safeParse({
-                endpointURL: "https://api.example.com/endpoint",
-                method: "GET",
-                language: "python",
-                framework: "pytest",
-                outputDir: "/tmp/tests",
-                prompt: "Generate load test",
-                loadRampupDuration: "1 0",
-            });
-            expect(result.success).toBe(false);
-        });
-        it("should reject invalid loadRampupInterval (scientific notation)", () => {
-            const result = schema.safeParse({
-                endpointURL: "https://api.example.com/endpoint",
-                method: "GET",
-                language: "python",
-                framework: "pytest",
-                outputDir: "/tmp/tests",
-                prompt: "Generate load test",
-                loadRampupInterval: "1e3",
-            });
-            expect(result.success).toBe(false);
-        });
-    });
-});

package/build/tools/generate-tests/generateUIRestTool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tools/generate-tests/generateUIRestTool.test.js

@@ -1,32 +0,0 @@
-import { z } from "zod";
-const { uiTestSchema, UITestService } = await import("./generateUIRestTool.js");
-// SKYR-4012: skyramp_ui_test_generation accepts an optional uniqueUIFormInputs list —
-// the create-form inputs the agent identified as unique-constrained — so Skyramp
-// codegen types a per-run-unique value into them and generated UI tests stay
-// re-runnable (the UI analogue of the REST uniqueFields mechanism).
-describe("uiTestSchema uniqueUIFormInputs (SKYR-4012)", () => {
-    const field = z.object({
-        uniqueUIFormInputs: uiTestSchema.uniqueUIFormInputs,
-    });
-    it("accepts an array of non-empty input identifiers", () => {
-        expect(field.safeParse({ uniqueUIFormInputs: ["Name", "#slug"] }).success).toBe(true);
-    });
-    it("is optional (may be omitted)", () => {
-        expect(field.safeParse({}).success).toBe(true);
-    });
-    it("rejects empty-string identifiers", () => {
-        expect(field.safeParse({ uniqueUIFormInputs: [""] }).success).toBe(false);
-    });
-});
-describe("UITestService threads uniqueUIFormInputs to generation options (SKYR-4012)", () => {
-    it("forwards uniqueUIFormInputs alongside playwrightInput", () => {
-        const service = new UITestService();
-        const opts = service.buildGenerationOptions({
-            playwrightInput: "/tmp/trace.zip",
-            language: "typescript",
-            uniqueUIFormInputs: ["Name"],
-        });
-        expect(opts.uniqueUIFormInputs).toEqual(["Name"]);
-        expect(opts.playwrightInput).toBe("/tmp/trace.zip");
-    });
-});

package/build/tools/generate-tests/planGuard.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tools/generate-tests/planGuard.test.js

@@ -1,185 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import * as os from "os";
-const { guardScenarioApproved, pathFromEndpointURL } = await import("./planGuard.js");
-const { setActiveRunStatePath, clearActiveRunStatePath } = await import("../../utils/AnalysisStateManager.js");
-const { CandidateSource } = await import("../../types/Recommendation.js");
-async function writeStateFile(dir, data) {
-    const stateFile = path.join(dir, "analyze-changes-state.json");
-    await fs.writeFile(stateFile, JSON.stringify({
-        existingTests: [],
-        analysisScope: "current_branch_diff",
-        newEndpoints: [],
-        ...data,
-        metadata: {
-            sessionId: "test-session",
-            stateType: "analysis",
-            createdAt: "2026-01-01T00:00:00.000Z",
-            updatedAt: "2026-01-01T00:00:00.000Z",
-        },
-    }), "utf-8");
-    return stateFile;
-}
-const APPROVED_ITEM = {
-    candidateId: "orders-workflow-abcd1234",
-    scenarioName: "orders_workflow",
-    testType: "integration",
-    category: "business_rule",
-    source: CandidateSource.AGENT,
-    matchKeys: ["name:orders-workflow", "ep:integration:POST:/api/v1/orders"],
-};
-describe("guardScenarioApproved — SKYR-3879 Path B hard gate", () => {
-    let tmpDirs = [];
-    const originalRunnerTemp = process.env.RUNNER_TEMP;
-    afterEach(async () => {
-        clearActiveRunStatePath();
-        process.env.RUNNER_TEMP = originalRunnerTemp;
-        for (const dir of tmpDirs) {
-            await fs.rm(dir, { recursive: true, force: true });
-        }
-        tmpDirs = [];
-    });
-    async function mkTmpDir() {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "plan-guard-test-"));
-        tmpDirs.push(dir);
-        return dir;
-    }
-    it("allows (returns null) when there is no active run state at all", async () => {
-        clearActiveRunStatePath();
-        delete process.env.RUNNER_TEMP;
-        const result = await guardScenarioApproved({ scenarioName: "anything" });
-        expect(result).toBeNull();
-    });
-    it("allows when the active run's state has no approvedPlan (standalone / pre-registration back-compat)", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, {});
-        setActiveRunStatePath(stateFile);
-        const result = await guardScenarioApproved({ scenarioName: "orders_workflow", testType: "integration" });
-        expect(result).toBeNull();
-    });
-    it("allows a scenarioName match against an approved GENERATE item", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, {
-            approvedPlan: {
-                planId: "plan-1",
-                createdAt: "2026-01-01T00:00:00.000Z",
-                generate: [APPROVED_ITEM],
-                additional: [],
-                demotions: [],
-            },
-        });
-        setActiveRunStatePath(stateFile);
-        const result = await guardScenarioApproved({ scenarioName: "orders_workflow", testType: "integration" });
-        expect(result).toBeNull();
-    });
-    it("allows a testType+method+path match against an approved GENERATE item (contract fallback key)", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, {
-            approvedPlan: {
-                planId: "plan-1",
-                createdAt: "2026-01-01T00:00:00.000Z",
-                generate: [APPROVED_ITEM],
-                additional: [],
-                demotions: [],
-            },
-        });
-        setActiveRunStatePath(stateFile);
-        const result = await guardScenarioApproved({ testType: "integration", method: "POST", path: "/api/v1/orders" });
-        expect(result).toBeNull();
-    });
-    it("allows a match against an approved ADDITIONAL item (documented backfill path)", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, {
-            approvedPlan: {
-                planId: "plan-1",
-                createdAt: "2026-01-01T00:00:00.000Z",
-                generate: [APPROVED_ITEM],
-                additional: [
-                    {
-                        ...APPROVED_ITEM,
-                        candidateId: "backfill-efgh5678",
-                        scenarioName: "orders_backfill",
-                        matchKeys: ["name:orders-backfill", "ep:integration:GET:/api/v1/orders"],
-                    },
-                ],
-                demotions: [],
-            },
-        });
-        setActiveRunStatePath(stateFile);
-        const result = await guardScenarioApproved({ scenarioName: "orders_backfill", testType: "integration" });
-        expect(result).toBeNull();
-    });
-    it("rejects an ADDITIONAL match when the GENERATE list is empty — zero-budget plans have nothing to backfill", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, {
-            approvedPlan: {
-                planId: "plan-zero-budget",
-                createdAt: "2026-01-01T00:00:00.000Z",
-                generate: [],
-                additional: [APPROVED_ITEM],
-                demotions: [],
-            },
-        });
-        setActiveRunStatePath(stateFile);
-        const result = await guardScenarioApproved({ scenarioName: "orders_workflow", testType: "integration" });
-        expect(result).not.toBeNull();
-        expect(result).toContain("plan-zero-budget");
-    });
-    it("rejects with the outstanding GENERATE list when nothing matches", async () => {
-        const dir = await mkTmpDir();
-        const stateFile = await writeStateFile(dir, {
-            approvedPlan: {
-                planId: "plan-1",
-                createdAt: "2026-01-01T00:00:00.000Z",
-                generate: [APPROVED_ITEM],
-                additional: [],
-                demotions: [],
-            },
-        });
-        setActiveRunStatePath(stateFile);
-        const result = await guardScenarioApproved({ scenarioName: "unregistered_scenario", testType: "contract" });
-        expect(result).not.toBeNull();
-        expect(result).toContain("plan-1");
-        expect(result).toContain("orders_workflow");
-        expect(result).toContain("skyramp_register_test_plan");
-    });
-    it("falls back to the deterministic RUNNER_TEMP state path for single-repo Testbot runs (no active-run anchor set)", async () => {
-        const dir = await mkTmpDir();
-        process.env.RUNNER_TEMP = dir;
-        const skyrampDir = path.join(dir, "skyramp");
-        await fs.mkdir(skyrampDir, { recursive: true });
-        await fs.writeFile(path.join(skyrampDir, "analyze-changes-state.json"), JSON.stringify({
-            existingTests: [],
-            analysisScope: "current_branch_diff",
-            newEndpoints: [],
-            approvedPlan: {
-                planId: "ci-plan",
-                createdAt: "2026-01-01T00:00:00.000Z",
-                generate: [APPROVED_ITEM],
-                additional: [],
-                demotions: [],
-            },
-            metadata: {
-                sessionId: "ci-session",
-                stateType: "analysis",
-                createdAt: "2026-01-01T00:00:00.000Z",
-                updatedAt: "2026-01-01T00:00:00.000Z",
-            },
-        }), "utf-8");
-        clearActiveRunStatePath(); // simulate a single-repo run: never set
-        const matched = await guardScenarioApproved({ scenarioName: "orders_workflow" });
-        expect(matched).toBeNull();
-        const rejected = await guardScenarioApproved({ scenarioName: "something_else" });
-        expect(rejected).toContain("ci-plan");
-    });
-});
-describe("pathFromEndpointURL", () => {
-    it("preserves {param} placeholders that new URL() percent-encodes (seed-1 gate false-reject regression)", () => {
-        expect(pathFromEndpointURL("http://localhost:8092/api/circuits/providers/{id}/summary/")).toBe("/api/circuits/providers/{id}/summary/");
-    });
-    it("passes through bare paths and rejects non-URL garbage", () => {
-        expect(pathFromEndpointURL("/api/v1/products/{product_id}")).toBe("/api/v1/products/{product_id}");
-        expect(pathFromEndpointURL("not a url")).toBeUndefined();
-        expect(pathFromEndpointURL(undefined)).toBeUndefined();
-    });
-});

package/build/tools/generate-tests/scenarioLint.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tools/generate-tests/scenarioLint.test.js

@@ -1,100 +0,0 @@
-import { lintScenarioChaining } from "./scenarioLint.js";
-/**
- * Write-side chaining lint (SKYR-3884 follow-through): the Go codegen chains
- * FKs/path params by value-matching against PRIOR steps' response bodies.
- * These tests pin the lint that catches unchainable or mis-ordered "bait"
- * values at scenario-write time instead of letting the generated test silently
- * hardcode them.
- */
-describe("lintScenarioChaining", () => {
-    const providerCreate = {
-        method: "POST",
-        path: "/api/circuits/providers/",
-        requestBody: JSON.stringify({ name: "Test Provider", slug: "test-provider" }),
-        responseBody: JSON.stringify({ id: 1, name: "Test Provider", slug: "test-provider" }),
-    };
-    const accountCreate = {
-        method: "POST",
-        path: "/api/circuits/provider-accounts/",
-        requestBody: JSON.stringify({ provider: 1, name: "Account-1" }),
-        responseBody: JSON.stringify({ id: 7, name: "Account-1" }),
-    };
-    const summaryGet = {
-        method: "GET",
-        path: "/api/circuits/providers/1/summary/",
-        responseBody: JSON.stringify({ circuit_count: 0 }),
-    };
-    it("passes a well-ordered scenario (create → reference by body FK and path param)", () => {
-        const result = lintScenarioChaining([providerCreate, accountCreate, summaryGet]);
-        expect(result.errors).toEqual([]);
-        expect(result.warnings).toEqual([]);
-    });
-    it("errors when a step references a value only produced by a LATER step", () => {
-        const result = lintScenarioChaining([accountCreate, providerCreate, summaryGet]);
-        expect(result.errors.length).toBeGreaterThan(0);
-        expect(result.errors.join("\n")).toContain("later step");
-        expect(result.errors.join("\n")).toContain("provider");
-    });
-    it("warns when a path segment value appears in no response at all", () => {
-        const result = lintScenarioChaining([
-            providerCreate,
-            { method: "GET", path: "/api/circuits/providers/999/summary/", responseBody: "{}" },
-        ]);
-        expect(result.errors).toEqual([]);
-        expect(result.warnings.join("\n")).toContain("999");
-        expect(result.warnings.join("\n")).toContain("hardcode");
-    });
-    it("warns when an id-like body field value appears in no response", () => {
-        const result = lintScenarioChaining([
-            providerCreate,
-            {
-                method: "POST",
-                path: "/api/circuits/circuits/",
-                requestBody: JSON.stringify({ provider_id: 555, cid: "CIR-1" }),
-                responseBody: JSON.stringify({ id: 2 }),
-            },
-        ]);
-        expect(result.errors).toEqual([]);
-        expect(result.warnings.join("\n")).toContain("provider_id");
-        expect(result.warnings.join("\n")).toContain("555");
-    });
-    it("warns on ambiguous chaining when the same id value is produced by multiple prior steps", () => {
-        const otherCreateSameId = {
-            method: "POST",
-            path: "/api/circuits/circuit-types/",
-            requestBody: JSON.stringify({ name: "Type-1" }),
-            responseBody: JSON.stringify({ id: 1, name: "Type-1" }),
-        };
-        const result = lintScenarioChaining([providerCreate, otherCreateSameId, accountCreate]);
-        expect(result.errors).toEqual([]);
-        expect(result.warnings.join("\n")).toContain("multiple prior steps");
-    });
-    it("does not flag ordinary non-FK body values that coincide with response ids", () => {
-        const result = lintScenarioChaining([
-            providerCreate,
-            {
-                method: "POST",
-                path: "/api/circuits/circuits/",
-                requestBody: JSON.stringify({ commit_rate: 1, description: "x" }),
-                responseBody: JSON.stringify({ id: 3 }),
-            },
-        ]);
-        // "commit_rate" is neither id-like nor resource-affine to /providers/ — ignore.
-        expect(result.errors).toEqual([]);
-        expect(result.warnings).toEqual([]);
-    });
-    it("treats a value produced only by the SAME step as unchainable (Go requires strictly-prior)", () => {
-        const result = lintScenarioChaining([
-            { method: "GET", path: "/api/things/7/", responseBody: JSON.stringify({ id: 7 }) },
-        ]);
-        expect(result.errors).toEqual([]);
-        expect(result.warnings.join("\n")).toContain("7");
-    });
-    it("is defensive about malformed steps (non-string path, unparseable bodies)", () => {
-        const result = lintScenarioChaining([
-            { method: "GET", path: undefined },
-            { method: "POST", path: "/x/", requestBody: "not-json", responseBody: "also-not-json" },
-        ]);
-        expect(result.errors).toEqual([]);
-    });
-});

package/build/tools/runExistingTestsTool.test.d.ts

@@ -1 +0,0 @@
-export {};