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

package/build/tools/runExistingTestsTool.test.js

@@ -1,379 +0,0 @@
-import path from "path";
-import os from "os";
-import { promises as fs } from "fs";
-import { StateManager, } from "../utils/AnalysisStateManager.js";
-import { resolveRunConfig, aggregateRuns, runExternalTests, runExternalSuite, frameworkHasReader, extractLastJsonObject } from "./runExistingTestsTool.js";
-function playwrightConfig(runtimeOverrides) {
-    return {
-        services: [
-            {
-                serviceName: "web",
-                framework: "playwright",
-                runtimeDetails: {
-                    runtime: "local",
-                    testSuites: [
-                        {
-                            testRunCommand: "bash e2e/scripts/run-playwright-host.sh npx playwright test",
-                            testEnv: { TEST_WORKERS_COUNT: "1" },
-                        },
-                    ],
-                    ...runtimeOverrides,
-                },
-            },
-        ],
-    };
-}
-describe("frameworkHasReader", () => {
-    it.each(["playwright", "pytest", "jest", "vitest"])("returns true for %s", (fw) => {
-        expect(frameworkHasReader(fw)).toBe(true);
-    });
-    it.each(["go", undefined])("returns false for %s", (fw) => {
-        expect(frameworkHasReader(fw)).toBe(false);
-    });
-});
-describe("resolveRunConfig", () => {
-    it("returns the Playwright service's run command and env", () => {
-        const r = resolveRunConfig(playwrightConfig(), { service: "web" });
-        expect(r.runs).toHaveLength(1);
-        expect(r.runs[0].testRunCommand).toContain("playwright");
-        expect(r.runs[0].testEnv).toMatchObject({ TEST_WORKERS_COUNT: "1" });
-    });
-    it("selects the sole Playwright service when serviceName is omitted", () => {
-        const r = resolveRunConfig(playwrightConfig());
-        expect(r.runs).toHaveLength(1);
-        expect(r.runs[0].testRunCommand).toContain("playwright");
-    });
-    it("skips (no error), rather than throwing, an explicitly-named framework with no reader", () => {
-        const cfg = playwrightConfig();
-        cfg.services[0].framework = "go";
-        const r = resolveRunConfig(cfg, { service: "web" });
-        expect(r.runs).toHaveLength(0);
-        expect(r.skips).toEqual([
-            { service: "web", reason: expect.stringMatching(/reader/i) },
-        ]);
-    });
-    it("skips (no error) when no service has a reader-supported framework", () => {
-        const cfg = playwrightConfig();
-        cfg.services[0].framework = "go";
-        const r = resolveRunConfig(cfg);
-        expect(r.runs).toHaveLength(0);
-        expect(r.skips.map((s) => s.service)).toContain("web");
-        expect(r.skips[0].reason).toMatch(/pytest/i);
-    });
-    it("carries the resolved framework on each run config", () => {
-        const r = resolveRunConfig(playwrightConfig(), { service: "web" });
-        expect(r.runs).toHaveLength(1);
-        expect(r.runs[0].framework).toBe("playwright");
-    });
-    it("skips (no error, no reason to report) when testSuites is missing", () => {
-        const cfg = playwrightConfig();
-        delete cfg.services[0].runtimeDetails
-            .testSuites;
-        const r = resolveRunConfig(cfg, { service: "web" });
-        // resolveSuites() drops a service with no testSuites entirely (SKYR-4002
-        // Task 2), so there is no suite left to report a skip reason on — runs and
-        // skips are both empty, and (critically) resolveRunConfig does not throw.
-        expect(r.runs).toHaveLength(0);
-        expect(r.skips).toHaveLength(0);
-    });
-});
-describe("runExternalTests", () => {
-    let stateFile;
-    const fakeParsed = {
-        results: [
-            {
-                testId: "a.test.ts › x",
-                file: "a.test.ts",
-                status: "fail",
-                message: "boom",
-                durationMs: 5,
-            },
-        ],
-        summary: { ran: 1, failed: 1, errored: 0, skipped: 0, truncated: false },
-        environmentHealthy: true,
-    };
-    beforeEach(async () => {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), "external-exec-"));
-        stateFile = path.join(dir, "analyze-changes-state.json");
-        const sm = StateManager.fromStatePath(stateFile);
-        await sm.writeRepoData({
-            existingTests: [],
-            analysisScope: {},
-            newEndpoints: [],
-        }, {});
-    });
-    function deps(parsed = fakeParsed) {
-        return {
-            readConfig: async () => playwrightConfig(),
-            runner: async () => parsed,
-            now: () => "2026-07-16T00:00:00.000Z",
-        };
-    }
-    it("returns the parsed results, summary and health", async () => {
-        const out = await runExternalTests({
-            workspacePath: "/repo",
-            service: "web",
-            stateFile,
-            testSelectors: ["a.test.ts"],
-        }, deps());
-        expect(out.summary.failed).toBe(1);
-        expect(out.environmentHealthy).toBe(true);
-        expect(out.results[0].status).toBe("fail");
-    });
-    it("returns a skipped run (never calls the runner) when no suite is runnable", async () => {
-        const out = await runExternalTests({
-            workspacePath: "/repo",
-            service: "web",
-            stateFile,
-        }, {
-            readConfig: async () => {
-                const cfg = playwrightConfig();
-                delete cfg.services[0].runtimeDetails
-                    .testSuites;
-                return cfg;
-            },
-            runner: async () => {
-                throw new Error("runner must not be called on a skipped run");
-            },
-            now: () => "2026-07-16T00:00:00.000Z",
-        });
-        expect(out.skipped).toBe(true);
-        expect(out.summary.ran).toBe(0);
-        expect(out.environmentHealthy).toBe(true);
-        expect(out.results).toHaveLength(0);
-    });
-    it("loops over multiple reader-backed suites, dispatching each by framework, and aggregates", async () => {
-        const config = {
-            services: [
-                { serviceName: "api", framework: "jest", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "jest" }] } },
-                { serviceName: "ui", framework: "playwright", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "pw" }] } },
-            ],
-        };
-        const seenFrameworks = [];
-        const out = await runExternalTests({ workspacePath: "/repo", stateFile }, {
-            readConfig: async () => config,
-            runner: async (c) => {
-                seenFrameworks.push(c.framework);
-                return {
-                    results: [{ testId: `${c.serviceName}:t`, file: "f", status: "pass", durationMs: 1 }],
-                    summary: { ran: 1, failed: 0, errored: 0, skipped: 0, truncated: false },
-                    environmentHealthy: true,
-                };
-            },
-            now: () => "t",
-        });
-        expect(seenFrameworks.sort()).toEqual(["jest", "playwright"]);
-        expect(out.summary.ran).toBe(2);
-        expect(out.results).toHaveLength(2);
-        expect(out.environmentHealthy).toBe(true);
-    });
-    it("persists an externalTestResults record to the state file", async () => {
-        await runExternalTests({
-            workspacePath: "/repo",
-            service: "web",
-            stateFile,
-            testSelectors: ["a.test.ts"],
-            mode: "confirm",
-        }, deps());
-        const sm = StateManager.fromStatePath(stateFile);
-        const state = await sm.readRepoData();
-        expect(state.externalTestResults).toHaveLength(1);
-        expect(state.externalTestResults[0]).toMatchObject({
-            mode: "confirm",
-            ranAt: "2026-07-16T00:00:00.000Z",
-        });
-        expect(state.externalTestResults[0].summary.failed).toBe(1);
-    });
-    it("trims selectors and marks truncated when maxTests is exceeded", async () => {
-        let received = [];
-        const out = await runExternalTests({
-            workspacePath: "/repo",
-            service: "web",
-            stateFile,
-            testSelectors: ["a", "b", "c"],
-            maxTests: 2,
-        }, {
-            readConfig: async () => playwrightConfig(),
-            runner: async (_cfg, opts) => {
-                received = opts.selectors;
-                return {
-                    ...fakeParsed,
-                    summary: { ...fakeParsed.summary, truncated: opts.truncated },
-                };
-            },
-            now: () => "t",
-        });
-        expect(received).toHaveLength(2);
-        expect(out.summary.truncated).toBe(true);
-    });
-});
-const cfg = (services) => ({ services });
-describe("resolveRunConfig (multi-suite)", () => {
-    it("returns one run for a single Playwright service (no service arg)", () => {
-        const r = resolveRunConfig(cfg([{ serviceName: "ui", framework: "playwright", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "pw" }] } }]));
-        expect(r.runs.map((x) => x.serviceName)).toEqual(["ui"]);
-        expect(r.skips).toEqual([]);
-    });
-    it("runs every runnable Playwright suite across services", () => {
-        const r = resolveRunConfig(cfg([
-            { serviceName: "server", framework: "playwright", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "a" }] } },
-            { serviceName: "webapp", framework: "playwright", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "b" }] } },
-        ]));
-        expect(r.runs.map((x) => x.serviceName).sort()).toEqual(["server", "webapp"]);
-    });
-    it("runs a jest suite (reader exists) — routed to a run, not a skip", () => {
-        const r = resolveRunConfig(cfg([
-            { serviceName: "api", framework: "jest", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "jest" }] } },
-        ]));
-        expect(r.runs.map((x) => x.serviceName)).toEqual(["api"]);
-        expect(r.runs[0].framework).toBe("jest");
-        expect(r.skips).toEqual([]);
-    });
-    it("runs a pytest suite (reader exists) — routed to a run, not a skip", () => {
-        const r = resolveRunConfig(cfg([
-            { serviceName: "svc", framework: "pytest", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "pytest" }] } },
-        ]));
-        expect(r.runs.map((x) => x.serviceName)).toEqual(["svc"]);
-        expect(r.runs[0].framework).toBe("pytest");
-        expect(r.skips).toEqual([]);
-    });
-    it("runs mixed reader-backed suites (jest + playwright) and skips only a no-reader framework", () => {
-        const r = resolveRunConfig(cfg([
-            { serviceName: "api", framework: "jest", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "jest" }] } },
-            { serviceName: "gosvc", framework: "go", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "go test" }] } },
-            { serviceName: "ui", framework: "playwright", runtimeDetails: { runtime: "local", testSuites: [{ testRunCommand: "pw" }] } },
-        ]));
-        expect(r.runs.map((x) => x.serviceName).sort()).toEqual(["api", "ui"]);
-        expect(r.skips.map((s) => s.service)).toEqual(["gosvc"]);
-        expect(r.skips[0].reason).toMatch(/reader/i);
-    });
-    it("throws only for an explicitly-named unknown service", () => {
-        expect(() => resolveRunConfig(cfg([]), { service: "nope" })).toThrow(/No service named/);
-    });
-});
-describe("aggregateRuns", () => {
-    it("sums summaries, concatenates results, and ANDs environmentHealthy", () => {
-        const agg = aggregateRuns([
-            { results: [{ testId: "a", file: "a", status: "pass", durationMs: 1 }], summary: { ran: 1, failed: 0, errored: 0, skipped: 0, truncated: false }, environmentHealthy: true },
-            { results: [{ testId: "b", file: "b", status: "fail", durationMs: 1 }], summary: { ran: 1, failed: 1, errored: 0, skipped: 0, truncated: false }, environmentHealthy: false, healthDetail: "boom" },
-        ]);
-        expect(agg.summary).toEqual({ ran: 2, failed: 1, errored: 0, skipped: 0, truncated: false });
-        expect(agg.results).toHaveLength(2);
-        expect(agg.environmentHealthy).toBe(false);
-        expect(agg.healthDetail).toContain("boom");
-    });
-    it("preserves the single suite's diagnostics unchanged", () => {
-        const diagnostics = {
-            runLevelErrors: ["some run-level error"],
-            infraSpecFailed: false,
-            maxFailuresBail: false,
-        };
-        const run = {
-            results: [{ testId: "a", file: "a", status: "pass", durationMs: 1 }],
-            summary: { ran: 1, failed: 0, errored: 0, skipped: 0, truncated: false },
-            environmentHealthy: true,
-            diagnostics,
-        };
-        const agg = aggregateRuns([run]);
-        expect(agg.diagnostics).toEqual(diagnostics);
-    });
-    it("picks the first unhealthy suite's diagnostics across multiple suites", () => {
-        const healthyDiagnostics = {
-            runLevelErrors: [],
-            infraSpecFailed: false,
-            maxFailuresBail: false,
-        };
-        const unhealthyDiagnostics = {
-            runLevelErrors: ["global setup failed"],
-            infraSpecFailed: true,
-            maxFailuresBail: false,
-        };
-        const agg = aggregateRuns([
-            {
-                results: [{ testId: "a", file: "a", status: "pass", durationMs: 1 }],
-                summary: { ran: 1, failed: 0, errored: 0, skipped: 0, truncated: false },
-                environmentHealthy: true,
-                diagnostics: healthyDiagnostics,
-            },
-            {
-                results: [{ testId: "b", file: "b", status: "error", durationMs: 1 }],
-                summary: { ran: 0, failed: 0, errored: 1, skipped: 0, truncated: false },
-                environmentHealthy: false,
-                healthDetail: "boom",
-                diagnostics: unhealthyDiagnostics,
-            },
-        ]);
-        expect(agg.diagnostics).toEqual(unhealthyDiagnostics);
-    });
-});
-describe("extractLastJsonObject", () => {
-    it("returns a lone JSON object unchanged", () => {
-        const parsed = JSON.parse(extractLastJsonObject('{"a":1}'));
-        expect(parsed).toEqual({ a: 1 });
-    });
-    it("extracts the LAST top-level object when an earlier object + noise precede it", () => {
-        const out = extractLastJsonObject('{"stale":1}\nnoise line\n{"stats":{"tests":2}}');
-        const parsed = JSON.parse(out);
-        expect(parsed.stats?.tests).toBe(2);
-        expect(parsed.stale).toBeUndefined();
-    });
-    it("is not fooled by braces inside strings", () => {
-        const parsed = JSON.parse(extractLastJsonObject('{"msg":"a } b { c","ok":true}'));
-        expect(parsed).toEqual({ msg: "a } b { c", ok: true });
-    });
-    it("throws when there is no JSON object", () => {
-        expect(() => extractLastJsonObject("no json here")).toThrow();
-    });
-});
-describe("runExternalSuite — surfaces stderr on an unhealthy but parseable report", () => {
-    // A stdout-reporting spec so the test needs no temp file: the report is the
-    // JSON the command prints; `parse` decides health. The command also writes a
-    // diagnostic to stderr, standing in for a Playwright global-setup stack trace.
-    const specWith = (parse) => ({
-        framework: "playwright",
-        outputVia: "stdout",
-        buildArgs: () => [],
-        parse,
-    });
-    const runCfg = (cmd) => ({
-        serviceName: "web",
-        framework: "playwright",
-        testRunCommand: cmd,
-    });
-    const runOpts = {
-        workspacePath: os.tmpdir(),
-        selectors: [],
-        mode: "confirm",
-        truncated: false,
-    };
-    it("appends the stderr tail to the parser's healthDetail when env is unhealthy", async () => {
-        const out = await runExternalSuite(specWith(() => ({
-            results: [],
-            summary: { ran: 0, failed: 0, errored: 0, skipped: 6, truncated: false },
-            environmentHealthy: false,
-            healthDetail: 'Environment setup failed: "global environment setup" (tests/global.setup.ts) reported fail.',
-        })), runCfg("printf '%s\\n' 'Error: no such container: ghost-dev-mysql' 1>&2; printf '%s' '{\"ok\":true}'"), runOpts);
-        expect(out.environmentHealthy).toBe(false);
-        expect(out.healthDetail).toContain("Environment setup failed");
-        expect(out.healthDetail).toContain("stderr:");
-        expect(out.healthDetail).toContain("no such container: ghost-dev-mysql");
-    });
-    it("synthesizes a healthDetail from the stderr tail when the parser left it empty", async () => {
-        const out = await runExternalSuite(specWith(() => ({
-            results: [],
-            summary: { ran: 0, failed: 0, errored: 0, skipped: 0, truncated: false },
-            environmentHealthy: false,
-        })), runCfg("printf '%s' 'boom on the runner' 1>&2; printf '%s' '{\"ok\":true}'"), runOpts);
-        expect(out.healthDetail).toMatch(/playwright environment unhealthy/);
-        expect(out.healthDetail).toContain("boom on the runner");
-    });
-    it("leaves a healthy run's healthDetail untouched (no stderr noise leaks in)", async () => {
-        const out = await runExternalSuite(specWith(() => ({
-            results: [{ testId: "a", file: "a", status: "pass", durationMs: 1 }],
-            summary: { ran: 1, failed: 0, errored: 0, skipped: 0, truncated: false },
-            environmentHealthy: true,
-        })), runCfg("printf '%s' 'harmless deprecation warning' 1>&2; printf '%s' '{\"ok\":true}'"), runOpts);
-        expect(out.environmentHealthy).toBe(true);
-        expect(out.healthDetail).toBeUndefined();
-    });
-});

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

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