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

package/build/services/TestExecutionService.test.js

@@ -1,1032 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-import { jest } from "@jest/globals";
-import * as os from "os";
-import * as path from "path";
-import { buildContainerEnv, rewriteLocalhostForDocker } from "./containerEnv.js";
-// Mock dockerode before importing TestExecutionService
-const mockRun = jest.fn();
-const mockListImages = jest.fn();
-jest.unstable_mockModule("dockerode", () => ({
-    default: jest.fn().mockImplementation(() => ({
-        run: mockRun,
-        listImages: mockListImages,
-    })),
-}));
-// Get actual fs for spreading, then mock specific methods
-const actualFs = await import("fs");
-const mockAccessSync = jest.fn();
-const mockExistsSync = jest.fn().mockReturnValue(true);
-const mockReaddirSync = jest.fn().mockImplementation((_path, options) => {
-    if (options?.withFileTypes) {
-        return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
-    }
-    return ["test_file.py"];
-});
-const mockReadFileSync = jest.fn().mockReturnValue("");
-const mockWriteFileSync = jest.fn();
-const mockMkdirSync = jest.fn();
-const mockRmSync = jest.fn();
-jest.unstable_mockModule("fs", () => ({
-    ...actualFs,
-    default: {
-        ...actualFs.default,
-        accessSync: mockAccessSync,
-        existsSync: mockExistsSync,
-        readdirSync: mockReaddirSync,
-        readFileSync: mockReadFileSync,
-        writeFileSync: mockWriteFileSync,
-        mkdirSync: mockMkdirSync,
-        rmSync: mockRmSync,
-        constants: actualFs.default.constants,
-    },
-    accessSync: mockAccessSync,
-    existsSync: mockExistsSync,
-    readdirSync: mockReaddirSync,
-    readFileSync: mockReadFileSync,
-    writeFileSync: mockWriteFileSync,
-    mkdirSync: mockMkdirSync,
-    rmSync: mockRmSync,
-}));
-// Mock logger
-jest.unstable_mockModule("../utils/logger.js", () => ({
-    logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        error: jest.fn(),
-        warning: jest.fn(),
-    },
-}));
-// Real temp directory trees for tests that need actual directory traversal
-// (findNestedNodeModules / findExcludedPaths walk the real fs, delegated to
-// via mockReaddirSync — see each describe block's beforeEach). Every root
-// created here is tracked and removed after its test so these don't leak
-// into the OS temp dir across runs.
-const makeTreeRoots = [];
-function makeTree(files) {
-    const root = actualFs.mkdtempSync(path.join(os.tmpdir(), "nnm-"));
-    makeTreeRoots.push(root);
-    for (const [rel, content] of Object.entries(files)) {
-        const abs = path.join(root, rel);
-        if (content === null)
-            actualFs.mkdirSync(abs, { recursive: true });
-        else {
-            actualFs.mkdirSync(path.dirname(abs), { recursive: true });
-            actualFs.writeFileSync(abs, content);
-        }
-    }
-    return root;
-}
-afterEach(() => {
-    while (makeTreeRoots.length > 0) {
-        const root = makeTreeRoots.pop();
-        actualFs.rmSync(root, { recursive: true, force: true });
-    }
-});
-describe("rewriteLocalhostForDocker", () => {
-    it("rewrites http://localhost:port", () => {
-        expect(rewriteLocalhostForDocker("http://localhost:8000")).toBe("http://host.docker.internal:8000");
-    });
-    it("rewrites http://127.0.0.1:port", () => {
-        expect(rewriteLocalhostForDocker("http://127.0.0.1:4200")).toBe("http://host.docker.internal:4200");
-    });
-    it("rewrites https://localhost:port", () => {
-        expect(rewriteLocalhostForDocker("https://localhost:443")).toBe("https://host.docker.internal:443");
-    });
-    it("rewrites localhost without port", () => {
-        expect(rewriteLocalhostForDocker("http://localhost/api")).toBe("http://host.docker.internal/api");
-    });
-    it("rewrites localhost with no path or port", () => {
-        expect(rewriteLocalhostForDocker("http://localhost")).toBe("http://host.docker.internal");
-    });
-    it("does not rewrite non-localhost URLs", () => {
-        expect(rewriteLocalhostForDocker("http://api.example.com:8000")).toBe("http://api.example.com:8000");
-    });
-    it("does not rewrite localhost in path", () => {
-        expect(rewriteLocalhostForDocker("http://api.example.com/localhost")).toBe("http://api.example.com/localhost");
-    });
-    it("does not rewrite partial matches like localhost-extra", () => {
-        expect(rewriteLocalhostForDocker("http://localhost-extra:8000")).toBe("http://localhost-extra:8000");
-    });
-});
-describe("buildContainerEnv", () => {
-    const baseOptions = { token: "test-token", language: "python" };
-    const emptyHostEnv = {};
-    it("always includes SKYRAMP_TEST_TOKEN and SKYRAMP_IN_DOCKER", () => {
-        const env = buildContainerEnv(baseOptions, undefined, emptyHostEnv);
-        expect(env).toContain("SKYRAMP_TEST_TOKEN=test-token");
-        expect(env).toContain("SKYRAMP_IN_DOCKER=true");
-    });
-    it("defaults token to empty string when not provided", () => {
-        const env = buildContainerEnv({ language: "typescript" }, undefined, emptyHostEnv);
-        expect(env).toContain("SKYRAMP_TEST_TOKEN=");
-    });
-    it("adds PYTEST_ADDOPTS for python language", () => {
-        const env = buildContainerEnv(baseOptions, undefined, emptyHostEnv);
-        expect(env).toContain("PYTEST_ADDOPTS=--noconftest -c /dev/null");
-    });
-    it("does not add PYTEST_ADDOPTS for non-python language", () => {
-        const env = buildContainerEnv({ ...baseOptions, language: "typescript" }, undefined, emptyHostEnv);
-        expect(env.find((e) => e.startsWith("PYTEST_ADDOPTS="))).toBeUndefined();
-    });
-    it("adds PLAYWRIGHT_SAVE_STORAGE_PATH when saveStoragePath provided", () => {
-        const env = buildContainerEnv(baseOptions, "/tmp/storage", emptyHostEnv);
-        expect(env).toContain("PLAYWRIGHT_SAVE_STORAGE_PATH=/tmp/storage");
-    });
-    it("does not add PLAYWRIGHT_SAVE_STORAGE_PATH when not provided", () => {
-        const env = buildContainerEnv(baseOptions, undefined, emptyHostEnv);
-        expect(env.find((e) => e.startsWith("PLAYWRIGHT_SAVE_STORAGE_PATH="))).toBeUndefined();
-    });
-    describe("base URL env var forwarding", () => {
-        it("rewrites localhost to host.docker.internal in bridge mode (default)", () => {
-            const hostEnv = { SKYRAMP_TEST_BASE_URL: "http://localhost:8000" };
-            const env = buildContainerEnv(baseOptions, undefined, hostEnv);
-            expect(env).toContain("SKYRAMP_TEST_BASE_URL=http://host.docker.internal:8000");
-        });
-        it("rewrites 127.0.0.1 to host.docker.internal in bridge mode", () => {
-            const hostEnv = { SKYRAMP_TEST_BASE_URL: "http://127.0.0.1:4200" };
-            const env = buildContainerEnv(baseOptions, undefined, hostEnv);
-            expect(env).toContain("SKYRAMP_TEST_BASE_URL=http://host.docker.internal:4200");
-        });
-        it("preserves localhost when useHostNetwork is true", () => {
-            const hostEnv = { SKYRAMP_TEST_BASE_URL: "http://localhost:8000" };
-            const env = buildContainerEnv({ ...baseOptions, useHostNetwork: true }, undefined, hostEnv);
-            expect(env).toContain("SKYRAMP_TEST_BASE_URL=http://localhost:8000");
-        });
-        it("does not rewrite non-localhost URLs", () => {
-            const hostEnv = { SKYRAMP_TEST_BASE_URL: "http://api.example.com:8000" };
-            const env = buildContainerEnv(baseOptions, undefined, hostEnv);
-            expect(env).toContain("SKYRAMP_TEST_BASE_URL=http://api.example.com:8000");
-        });
-        it("rewrites SKYRAMP_TEST_SERVICE_URL_* vars in bridge mode", () => {
-            const hostEnv = {
-                SKYRAMP_TEST_SERVICE_URL_BACKEND: "http://localhost:8000",
-                SKYRAMP_TEST_SERVICE_URL_FRONTEND: "http://localhost:5173",
-            };
-            const env = buildContainerEnv(baseOptions, undefined, hostEnv);
-            expect(env).toContain("SKYRAMP_TEST_SERVICE_URL_BACKEND=http://host.docker.internal:8000");
-            expect(env).toContain("SKYRAMP_TEST_SERVICE_URL_FRONTEND=http://host.docker.internal:5173");
-        });
-        it("skips SKYRAMP_TEST_BASE_URL when value is empty", () => {
-            const hostEnv = { SKYRAMP_TEST_BASE_URL: "" };
-            const env = buildContainerEnv(baseOptions, undefined, hostEnv);
-            expect(env.find((e) => e.startsWith("SKYRAMP_TEST_BASE_URL="))).toBeUndefined();
-        });
-        it("does not forward unrelated SKYRAMP_ vars", () => {
-            const hostEnv = {
-                SKYRAMP_TEST_BASE_URL: "http://localhost:8000",
-                SKYRAMP_OTHER_VAR: "should-not-appear",
-                SKYRAMP_TEST_SERVICE_NOT_URL: "also-no",
-            };
-            const env = buildContainerEnv(baseOptions, undefined, hostEnv);
-            expect(env).toContain("SKYRAMP_TEST_BASE_URL=http://host.docker.internal:8000");
-            expect(env.find((e) => e.includes("SKYRAMP_OTHER_VAR"))).toBeUndefined();
-            expect(env.find((e) => e.includes("SKYRAMP_TEST_SERVICE_NOT_URL"))).toBeUndefined();
-        });
-    });
-    it("forwards SKYRAMP_DEBUG from host env", () => {
-        const hostEnv = { SKYRAMP_DEBUG: "true" };
-        const env = buildContainerEnv(baseOptions, undefined, hostEnv);
-        expect(env).toContain("SKYRAMP_DEBUG=true");
-    });
-    it("forwards API_KEY from host env", () => {
-        const hostEnv = { API_KEY: "my-key" };
-        const env = buildContainerEnv(baseOptions, undefined, hostEnv);
-        expect(env).toContain("API_KEY=my-key");
-    });
-});
-describe("detectSessionFiles", () => {
-    // Import after mocks are set up so the fs mock applies
-    let detectSessionFiles;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        detectSessionFiles = mod.detectSessionFiles;
-    });
-    it("detects string-literal storageState (TS/JS)", () => {
-        mockReadFileSync.mockReturnValueOnce(`test.use({ storageState: '/abs/path/session.json' });`);
-        expect(detectSessionFiles("/ws/test.spec.ts")).toEqual([
-            "/abs/path/session.json",
-        ]);
-    });
-    it("detects skyramp codegen path.join(__dirname, '<file>') pattern and resolves to host-absolute path", () => {
-        // Reproduces SKYR-3321 generated test shape — must resolve to the host
-        // absolute path so the executor's absolute-path mount branch makes the
-        // file visible at that same path inside the container.
-        mockReadFileSync.mockReturnValueOnce(`
-import path from 'path';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SESSION_STORAGE = path.join(__dirname, 'skyramp_session_storage.json');
-test.use({ storageState: SESSION_STORAGE });
-`);
-        expect(detectSessionFiles("/Users/pedro/projects/cisco-xdr-tests/xdr_dashboard.spec.ts")).toEqual([
-            "/Users/pedro/projects/cisco-xdr-tests/skyramp_session_storage.json",
-        ]);
-    });
-    it("detects inline storageState: path.join(__dirname, '<file>')", () => {
-        mockReadFileSync.mockReturnValueOnce(`test.use({ storageState: path.join(__dirname, 'session.json') });`);
-        expect(detectSessionFiles("/ws/spec.ts")).toEqual(["/ws/session.json"]);
-    });
-    it("ignores storageState references inside comments", () => {
-        mockReadFileSync.mockReturnValueOnce(`
-// storageState: '/should/not/match.json'
-// path.join(__dirname, 'also-not.json')
-test('x', () => {});
-`);
-        expect(detectSessionFiles("/ws/spec.ts")).toEqual([]);
-    });
-});
-describe("isBrowserTest", () => {
-    let isBrowserTest;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        isBrowserTest = mod.isBrowserTest;
-    });
-    it("returns true for UI test type", () => {
-        expect(isBrowserTest("ui")).toBe(true);
-    });
-    it("returns true for E2E test type", () => {
-        expect(isBrowserTest("e2e")).toBe(true);
-    });
-    it("returns false for contract test type", () => {
-        expect(isBrowserTest("contract")).toBe(false);
-    });
-    it("returns false for integration test type", () => {
-        expect(isBrowserTest("integration")).toBe(false);
-    });
-    it("returns false for fuzz test type", () => {
-        expect(isBrowserTest("fuzz")).toBe(false);
-    });
-    it("returns false for smoke test type", () => {
-        expect(isBrowserTest("smoke")).toBe(false);
-    });
-    it("returns false for load test type", () => {
-        expect(isBrowserTest("load")).toBe(false);
-    });
-    it("returns false for mock test type", () => {
-        expect(isBrowserTest("mock")).toBe(false);
-    });
-});
-describe("getVideoSubdir", () => {
-    let getVideoSubdir;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        getVideoSubdir = mod.getVideoSubdir;
-    });
-    it("generates deterministic subdirectory name with basename and hash", () => {
-        const testFile = "/workspace/tests/login.spec.ts";
-        const result = getVideoSubdir(testFile);
-        // Should be "basename-8hexchars" format
-        // Note: path.extname only strips the final extension (.ts), so .spec remains in basename
-        expect(result).toMatch(/^login\.spec-[0-9a-f]{8}$/);
-    });
-    it("strips file extension from basename", () => {
-        const result = getVideoSubdir("/workspace/checkout.spec.ts");
-        // path.extname('.spec.ts') returns '.ts', so 'checkout.spec' is the basename
-        expect(result).toMatch(/^checkout\.spec-[0-9a-f]{8}$/);
-        expect(result).toContain(".spec");
-    });
-    it("produces different hashes for different paths", () => {
-        const path1 = "/workspace/tests/login.spec.ts";
-        const path2 = "/workspace/tests/checkout.spec.ts";
-        const result1 = getVideoSubdir(path1);
-        const result2 = getVideoSubdir(path2);
-        expect(result1).not.toBe(result2);
-        // Different hashes
-        expect(result1.split("-")[1]).not.toBe(result2.split("-")[1]);
-    });
-    it("produces same hash for the same path (deterministic)", () => {
-        const testFile = "/workspace/tests/products.spec.ts";
-        const result1 = getVideoSubdir(testFile);
-        const result2 = getVideoSubdir(testFile);
-        expect(result1).toBe(result2);
-    });
-    it("handles paths with no extension", () => {
-        const result = getVideoSubdir("/workspace/test_file");
-        expect(result).toMatch(/^test_file-[0-9a-f]{8}$/);
-    });
-    it("handles paths with multiple dots", () => {
-        const result = getVideoSubdir("/workspace/test.spec.e2e.ts");
-        // Should strip only the last extension (.ts)
-        expect(result).toMatch(/^test\.spec\.e2e-[0-9a-f]{8}$/);
-    });
-});
-describe("TestExecutionService.executeTest - Docker env forwarding", () => {
-    // Import after mocks are set up
-    let TestExecutionService;
-    let EXECUTOR_DOCKER_IMAGE;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        TestExecutionService = mod.TestExecutionService;
-        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        // Simulate image already cached
-        mockListImages.mockResolvedValue([
-            { RepoTags: [EXECUTOR_DOCKER_IMAGE] },
-        ]);
-    });
-    afterEach(() => {
-        // Clean up env vars we set during tests
-        delete process.env.SKYRAMP_TEST_BASE_URL;
-        delete process.env.SKYRAMP_TEST_SERVICE_URL_BACKEND;
-        delete process.env.SKYRAMP_TEST_SERVICE_URL_FRONTEND;
-    });
-    it("passes SKYRAMP_TEST_BASE_URL to Docker container Env", async () => {
-        process.env.SKYRAMP_TEST_BASE_URL = "http://external-host:8000";
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/test_file.py",
-            workspacePath: "/workspace",
-            language: "python",
-            testType: "smoke",
-        });
-        expect(mockRun).toHaveBeenCalledTimes(1);
-        const dockerOptions = mockRun.mock.calls[0][3];
-        expect(dockerOptions.Env).toContain("SKYRAMP_TEST_BASE_URL=http://external-host:8000");
-    });
-    it("passes multiple SKYRAMP_TEST_SERVICE_URL_* to Docker container Env", async () => {
-        process.env.SKYRAMP_TEST_SERVICE_URL_BACKEND = "http://host1:8000";
-        process.env.SKYRAMP_TEST_SERVICE_URL_FRONTEND = "http://host2:5173";
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/test_file.py",
-            workspacePath: "/workspace",
-            language: "python",
-            testType: "smoke",
-        });
-        const dockerOptions = mockRun.mock.calls[0][3];
-        expect(dockerOptions.Env).toContain("SKYRAMP_TEST_SERVICE_URL_BACKEND=http://host1:8000");
-        expect(dockerOptions.Env).toContain("SKYRAMP_TEST_SERVICE_URL_FRONTEND=http://host2:5173");
-    });
-    it("does not include base URL vars when not set in host env", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/test_file.py",
-            workspacePath: "/workspace",
-            language: "python",
-            testType: "smoke",
-        });
-        const dockerOptions = mockRun.mock.calls[0][3];
-        const envWithBaseUrl = dockerOptions.Env.filter((e) => e.startsWith("SKYRAMP_TEST_BASE_URL=") ||
-            e.startsWith("SKYRAMP_TEST_SERVICE_URL_"));
-        expect(envWithBaseUrl).toHaveLength(0);
-    });
-    // Approach B: every workspace mount is mirrored at the host-absolute path so
-    // tests that embed absolute references (storageState, fixtures, snapshots)
-    // resolve correctly inside the executor regardless of which path-shape the
-    // codegen happens to emit.
-    it("mirrors each workspace file mount at both /home/user/<f> and the host-absolute path", async () => {
-        mockReaddirSync.mockImplementation((_path, options) => {
-            if (options?.withFileTypes) {
-                return [
-                    { name: "xdr_dashboard.spec.ts", isFile: () => true, isDirectory: () => false },
-                    { name: "skyramp_session_storage.json", isFile: () => true, isDirectory: () => false },
-                ];
-            }
-            return ["xdr_dashboard.spec.ts", "skyramp_session_storage.json"];
-        });
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/Users/pedro/projects/cisco-xdr-tests/xdr_dashboard.spec.ts",
-            workspacePath: "/Users/pedro/projects/cisco-xdr-tests",
-            language: "typescript",
-            testType: "ui",
-        });
-        const dockerOptions = mockRun.mock.calls[0][3];
-        const targets = dockerOptions.HostConfig.Mounts.map((m) => m.Target);
-        // Canonical /home/user mount
-        expect(targets).toContain("/home/user/xdr_dashboard.spec.ts");
-        expect(targets).toContain("/home/user/skyramp_session_storage.json");
-        // Host-absolute mirror — the fix for absolute paths leaking out of `__dirname`
-        expect(targets).toContain("/Users/pedro/projects/cisco-xdr-tests/xdr_dashboard.spec.ts");
-        expect(targets).toContain("/Users/pedro/projects/cisco-xdr-tests/skyramp_session_storage.json");
-    });
-    it("does not double-mount when workspacePath equals /home/user", async () => {
-        mockReaddirSync.mockImplementation((_path, options) => {
-            if (options?.withFileTypes) {
-                return [{ name: "test_file.py", isFile: () => true, isDirectory: () => false }];
-            }
-            return ["test_file.py"];
-        });
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/home/user/test_file.py",
-            workspacePath: "/home/user",
-            language: "python",
-            testType: "smoke",
-        });
-        const dockerOptions = mockRun.mock.calls[0][3];
-        const targetCounts = {};
-        for (const m of dockerOptions.HostConfig.Mounts) {
-            targetCounts[m.Target] = (targetCounts[m.Target] ?? 0) + 1;
-        }
-        // No mount target should appear twice (no host-absolute mirror when workspace == /home/user)
-        for (const [t, n] of Object.entries(targetCounts)) {
-            expect({ target: t, count: n }).toEqual({ target: t, count: 1 });
-        }
-    });
-});
-describe("TestExecutionService.executeTest - Video capture for browser tests", () => {
-    let TestExecutionService;
-    let getVideoSubdir;
-    let EXECUTOR_DOCKER_IMAGE;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        TestExecutionService = mod.TestExecutionService;
-        getVideoSubdir = mod.getVideoSubdir;
-        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
-        mockExistsSync.mockReturnValue(true);
-        mockReaddirSync.mockImplementation((_path, options) => {
-            if (options?.withFileTypes) {
-                return [
-                    { name: "test.spec.ts", isFile: () => true, isDirectory: () => false },
-                    { name: "test.py", isFile: () => true, isDirectory: () => false },
-                ];
-            }
-            return ["test.spec.ts", "test.py"];
-        });
-        // Reset writeFileSync mock to default behavior
-        mockWriteFileSync.mockImplementation(() => { });
-    });
-    it("mounts generated Playwright config at /home/user/playwright.config.ts for TypeScript UI test", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/login.spec.ts",
-            workspacePath: "/workspace",
-            language: "typescript",
-            testType: "ui",
-        });
-        const dockerOptions = mockRun.mock.calls[0][3];
-        const playwrightConfigMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target === "/home/user/playwright.config.ts");
-        expect(playwrightConfigMount).toBeDefined();
-        expect(playwrightConfigMount.Type).toBe("bind");
-        // Source should be a temp file containing the generated config
-        expect(playwrightConfigMount.Source).toContain("skyramp-playwright-");
-        expect(playwrightConfigMount.Source).toContain(".config.ts");
-    });
-    it("generated Playwright config for TypeScript contains video:on and outputDir", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        let capturedConfigContent = "";
-        mockWriteFileSync.mockImplementation((filePath, content) => {
-            if (filePath.includes("skyramp-playwright-") && filePath.endsWith(".config.ts")) {
-                capturedConfigContent = content;
-            }
-        });
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/checkout.spec.ts",
-            workspacePath: "/workspace",
-            language: "typescript",
-            testType: "e2e",
-        });
-        expect(capturedConfigContent).toContain('video: "on"');
-        expect(capturedConfigContent).toContain("outputDir:");
-        expect(capturedConfigContent).toContain(".skyramp/videos/");
-    });
-    it("mounts generated pytest.ini at /home/user/pytest.ini for Python UI test", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/test_login.py",
-            workspacePath: "/workspace",
-            language: "python",
-            testType: "ui",
-        });
-        const dockerOptions = mockRun.mock.calls[0][3];
-        const pytestConfigMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target === "/home/user/pytest.ini");
-        expect(pytestConfigMount).toBeDefined();
-        expect(pytestConfigMount.Type).toBe("bind");
-        expect(pytestConfigMount.Source).toContain("skyramp-pytest-");
-        expect(pytestConfigMount.Source).toContain(".ini");
-    });
-    it("generated pytest.ini for Python contains --video on and --output", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        let capturedPytestContent = "";
-        mockWriteFileSync.mockImplementation((filePath, content) => {
-            if (filePath.includes("skyramp-pytest-") && filePath.endsWith(".ini")) {
-                capturedPytestContent = content;
-            }
-        });
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/test_checkout.py",
-            workspacePath: "/workspace",
-            language: "python",
-            testType: "e2e",
-        });
-        expect(capturedPytestContent).toContain("--video on");
-        expect(capturedPytestContent).toContain("--output");
-        expect(capturedPytestContent).toContain(".skyramp/videos/");
-    });
-    it("mounts video output directory as writable for UI test", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/tests/login.spec.ts",
-            workspacePath: "/workspace",
-            language: "typescript",
-            testType: "ui",
-        });
-        const dockerOptions = mockRun.mock.calls[0][3];
-        const videoSubdir = getVideoSubdir("/workspace/tests/login.spec.ts");
-        // Each execution gets a unique per-run dir: `${videoSubdir}-<timestamp>`,
-        // so match by prefix rather than exact equality.
-        const videoMountPrefix = `/home/user/.skyramp/videos/${videoSubdir}`;
-        const videoMount = dockerOptions.HostConfig.Mounts.find((m) => m.Target.startsWith(videoMountPrefix));
-        expect(videoMount).toBeDefined();
-        expect(videoMount.Type).toBe("bind");
-        expect(videoMount.ReadOnly).toBe(false);
-        expect(videoMount.Source).toContain(".skyramp/videos/");
-        expect(videoMount.Source).toContain(videoSubdir);
-    });
-    it("does not mount video directory for non-browser tests", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/contract_test.py",
-            workspacePath: "/workspace",
-            language: "python",
-            testType: "contract",
-        });
-        const dockerOptions = mockRun.mock.calls[0][3];
-        const videoMounts = dockerOptions.HostConfig.Mounts.filter((m) => m.Target.includes(".skyramp/videos"));
-        expect(videoMounts).toHaveLength(0);
-    });
-    it("uses minimal static Playwright config for non-browser TypeScript tests", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        let usedGeneratedConfig = false;
-        mockWriteFileSync.mockImplementation((filePath, content) => {
-            if (filePath.includes("skyramp-playwright-") && content.includes('video: "on"')) {
-                usedGeneratedConfig = true;
-            }
-        });
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/contract_test.spec.ts",
-            workspacePath: "/workspace",
-            language: "typescript",
-            testType: "contract",
-        });
-        // Should NOT generate a video-enabled config for contract test
-        expect(usedGeneratedConfig).toBe(false);
-    });
-    it("populates videoPath when video.webm exists after execution", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const videoSubdir = getVideoSubdir("/workspace/test.spec.ts");
-        mockReaddirSync.mockImplementation((dir, options) => {
-            // Mock video directory scan
-            if (dir.includes(".skyramp/videos") && dir.includes(videoSubdir)) {
-                if (options?.withFileTypes) {
-                    return [{ name: "video.webm", isFile: () => true, isDirectory: () => false }];
-                }
-                return ["video.webm"];
-            }
-            // Default workspace files
-            if (options?.withFileTypes) {
-                return [{ name: "test.spec.ts", isFile: () => true, isDirectory: () => false }];
-            }
-            return ["test.spec.ts"];
-        });
-        const service = new TestExecutionService();
-        const result = await service.executeTest({
-            testFile: "/workspace/test.spec.ts",
-            workspacePath: "/workspace",
-            language: "typescript",
-            testType: "ui",
-        });
-        expect(result.videoPath).toBeDefined();
-        expect(result.videoPath).toContain(".skyramp/videos/");
-        expect(result.videoPath).toContain("video.webm");
-    });
-    it("leaves videoPath undefined when no video.webm found", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const videoSubdir = getVideoSubdir("/workspace/test.spec.ts");
-        mockReaddirSync.mockImplementation((dir, options) => {
-            // Mock empty video directory
-            if (dir.includes(".skyramp/videos") && dir.includes(videoSubdir)) {
-                if (options?.withFileTypes) {
-                    return [];
-                }
-                return [];
-            }
-            // Default workspace files
-            if (options?.withFileTypes) {
-                return [{ name: "test.spec.ts", isFile: () => true, isDirectory: () => false }];
-            }
-            return ["test.spec.ts"];
-        });
-        const service = new TestExecutionService();
-        const result = await service.executeTest({
-            testFile: "/workspace/test.spec.ts",
-            workspacePath: "/workspace",
-            language: "typescript",
-            testType: "ui",
-        });
-        expect(result.videoPath).toBeUndefined();
-    });
-    it("leaves videoPath undefined for non-browser tests", async () => {
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        const service = new TestExecutionService();
-        const result = await service.executeTest({
-            testFile: "/workspace/integration_test.py",
-            workspacePath: "/workspace",
-            language: "python",
-            testType: "integration",
-        });
-        expect(result.videoPath).toBeUndefined();
-    });
-});
-// SKYR-3819: tests delivered to a cross-repo test repository (testsRepoDir) live
-// outside workspacePath. The executor must mount the test repo under a reserved
-// /home/user subdir — inside the generated Playwright config's testDir — and
-// anchor the container test path there, or the runner reports "No tests found" /
-// "file or directory not found".
-describe("TestExecutionService.executeTest - cross-repo test repo mounts", () => {
-    let TestExecutionService;
-    let TEST_REPO_CONTAINER_SUBDIR;
-    let EXECUTOR_DOCKER_IMAGE;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        TestExecutionService = mod.TestExecutionService;
-        TEST_REPO_CONTAINER_SUBDIR = mod.TEST_REPO_CONTAINER_SUBDIR;
-        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
-    });
-    const dirent = (name, dir = false) => ({
-        name,
-        isFile: () => !dir,
-        isDirectory: () => dir,
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        // Path-aware directory layout:
-        //   /workspace            → SUT repo (src/)
-        //   /test-repo            → cross-repo test repo (tests/, node_modules/, package.json)
-        mockReaddirSync.mockImplementation((dir, options) => {
-            const listing = {
-                "/workspace": [dirent("src", true)],
-                "/workspace/src": [],
-                "/test-repo": [dirent("tests", true), dirent("node_modules", true), dirent("package.json")],
-                "/test-repo/tests": [dirent("orders_test.py")],
-            };
-            const entries = listing[dir] ?? [];
-            return options?.withFileTypes ? entries : entries.map((e) => e.name);
-        });
-    });
-    it("mounts test repo entries under the reserved /home/user subdir with host mirrors", async () => {
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/test-repo/tests/orders_test.py",
-            workspacePath: "/workspace",
-            testRepoPath: "/test-repo",
-            language: "python",
-            testType: "integration",
-        });
-        expect(mockRun).toHaveBeenCalledTimes(1);
-        const mounts = mockRun.mock.calls[0][3].HostConfig.Mounts;
-        expect(mounts).toContainEqual(expect.objectContaining({
-            Source: "/test-repo/tests",
-            Target: `/home/user/${TEST_REPO_CONTAINER_SUBDIR}/tests`,
-        }));
-        // Host-absolute mirror so absolute references embedded in tests resolve
-        expect(mounts).toContainEqual(expect.objectContaining({ Source: "/test-repo/tests", Target: "/test-repo/tests" }));
-    });
-    it("anchors the container test path inside the reserved subdir", async () => {
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/test-repo/tests/orders_test.py",
-            workspacePath: "/workspace",
-            testRepoPath: "/test-repo",
-            language: "python",
-            testType: "integration",
-        });
-        const command = mockRun.mock.calls[0][1];
-        expect(command).toContain(`/home/user/${TEST_REPO_CONTAINER_SUBDIR}/tests/orders_test.py`);
-    });
-    it("applies mount exclusions and null shadows to the test repo", async () => {
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/test-repo/tests/orders_test.py",
-            workspacePath: "/workspace",
-            testRepoPath: "/test-repo",
-            language: "python",
-            testType: "integration",
-        });
-        const mounts = mockRun.mock.calls[0][3].HostConfig.Mounts;
-        // node_modules is never mounted
-        expect(mounts.filter((m) => m.Source === "/test-repo/node_modules")).toHaveLength(0);
-        // package.json is shadowed with the empty-JSON file at both targets
-        const pkgShadows = mounts.filter((m) => m.Target === `/home/user/${TEST_REPO_CONTAINER_SUBDIR}/package.json` ||
-            m.Target === "/test-repo/package.json");
-        expect(pkgShadows).toHaveLength(2);
-        for (const m of pkgShadows) {
-            expect(m.Source).toMatch(/skyramp-empty\.json$/);
-        }
-    });
-    it("throws an actionable error when testFile is outside the workspace and no testRepoPath is known", async () => {
-        const service = new TestExecutionService();
-        await expect(service.executeTest({
-            testFile: "/test-repo/tests/orders_test.py",
-            workspacePath: "/workspace",
-            language: "python",
-            testType: "integration",
-        })).rejects.toThrow(/outside the workspace/);
-    });
-    it("does not add test repo mounts when testFile is inside the workspace", async () => {
-        mockReaddirSync.mockImplementation((dir, options) => {
-            const listing = {
-                "/workspace": [dirent("tests", true)],
-                "/workspace/tests": [dirent("orders_test.py")],
-            };
-            const entries = listing[dir] ?? [];
-            return options?.withFileTypes ? entries : entries.map((e) => e.name);
-        });
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: "/workspace/tests/orders_test.py",
-            workspacePath: "/workspace",
-            testRepoPath: "/test-repo",
-            language: "python",
-            testType: "integration",
-        });
-        const command = mockRun.mock.calls[0][1];
-        expect(command).toContain("/home/user/tests/orders_test.py");
-        const mounts = mockRun.mock.calls[0][3].HostConfig.Mounts;
-        expect(mounts.filter((m) => m.Target.includes(TEST_REPO_CONTAINER_SUBDIR))).toHaveLength(0);
-    });
-});
-// Copilot review on PR #623: guard hazardous or stale cross-repo roots.
-describe("TestExecutionService.executeTest - cross-repo root guards", () => {
-    let TestExecutionService;
-    let EXECUTOR_DOCKER_IMAGE;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        TestExecutionService = mod.TestExecutionService;
-        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-    });
-    afterEach(() => {
-        mockAccessSync.mockReset();
-    });
-    it("rejects a filesystem-root testRepoPath instead of mounting the host root", async () => {
-        const service = new TestExecutionService();
-        await expect(service.executeTest({
-            testFile: "/outside/tests/orders_test.py",
-            workspacePath: "/workspace",
-            testRepoPath: "/",
-            language: "python",
-            testType: "integration",
-        })).rejects.toThrow(/filesystem root/);
-        expect(mockRun).not.toHaveBeenCalled();
-    });
-    it("throws an actionable error when the cross-repo test repository is missing or unreadable", async () => {
-        mockAccessSync.mockImplementation((p) => {
-            if (String(p).startsWith("/test-repo")) {
-                throw new Error("EACCES");
-            }
-        });
-        const service = new TestExecutionService();
-        await expect(service.executeTest({
-            testFile: "/test-repo/tests/orders_test.py",
-            workspacePath: "/workspace",
-            testRepoPath: "/test-repo",
-            language: "python",
-            testType: "integration",
-        })).rejects.toThrow(/test repository path does not exist or is not readable/);
-        expect(mockRun).not.toHaveBeenCalled();
-    });
-});
-describe("findNestedNodeModules", () => {
-    let findNestedNodeModules;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        findNestedNodeModules = mod.findNestedNodeModules;
-    });
-    beforeEach(() => {
-        // These tests need real directory traversal — delegate the readdirSync
-        // mock (used by TestExecutionService.ts's `fs` binding) back to the real
-        // fs so it reflects the on-disk tree built by makeTree() below.
-        mockReaddirSync.mockImplementation((...args) => actualFs.readdirSync(...args));
-    });
-    const relSorted = (root, abs) => abs.map((p) => path.relative(root, p).replace(/\\/g, "/")).sort();
-    it("returns nested node_modules but not the top-level one", () => {
-        const root = makeTree({
-            "node_modules/playwright/index.js": "x",
-            "tests/ui-testing/node_modules/@playwright/test/index.js": "x",
-            "tests/ui-testing/pages/dashboard-list.js": "x",
-            "packages/web/node_modules/react/index.js": "x",
-        });
-        expect(relSorted(root, findNestedNodeModules(root))).toEqual([
-            "packages/web/node_modules",
-            "tests/ui-testing/node_modules",
-        ]);
-    });
-    it("never descends into a node_modules (no nested-inside-node_modules hits)", () => {
-        const root = makeTree({
-            "tests/node_modules/foo/node_modules/bar/index.js": "x",
-        });
-        expect(relSorted(root, findNestedNodeModules(root))).toEqual([
-            "tests/node_modules",
-        ]);
-    });
-    it("returns empty when there are no nested node_modules", () => {
-        const root = makeTree({ "node_modules/a/index.js": "x", "src/app.js": "x" });
-        expect(findNestedNodeModules(root)).toEqual([]);
-    });
-});
-describe("TestExecutionService.executeTest - nested node_modules shadow + NODE_PATH wrap", () => {
-    let TestExecutionService;
-    let EXECUTOR_DOCKER_IMAGE;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        TestExecutionService = mod.TestExecutionService;
-        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        // Real directory traversal so findNestedNodeModules / the workspace-mount
-        // scan see the on-disk tree built by makeTree() below (same delegation as
-        // the findNestedNodeModules describe block above).
-        mockReaddirSync.mockImplementation((...args) => actualFs.readdirSync(...args));
-        // Real existsSync too, so the production `if (!fs.existsSync(pkgPath))
-        // continue` package-existence gate is genuinely exercised against the
-        // on-disk tree instead of the file-level always-true default.
-        mockExistsSync.mockImplementation((...args) => actualFs.existsSync(...args));
-    });
-    afterEach(() => {
-        // Restore the file-level always-true default for describes that follow.
-        mockExistsSync.mockReturnValue(true);
-    });
-    it("shadows a leaked nested @playwright/test and wraps the run command with NODE_PATH", async () => {
-        const root = makeTree({
-            "tests/node_modules/@playwright/test/index.js": "module.exports = {};",
-            "tests/sample.spec.ts": "test('noop', () => {});",
-        });
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: path.join(root, "tests/sample.spec.ts"),
-            workspacePath: root,
-            language: "typescript",
-            testType: "smoke",
-        });
-        expect(mockRun).toHaveBeenCalledTimes(1);
-        const dockerOptions = mockRun.mock.calls[0][3];
-        const mounts = dockerOptions.HostConfig.Mounts;
-        const shadowMount = mounts.find((m) => m.ReadOnly && m.Target.endsWith("tests/node_modules/@playwright/test"));
-        expect(shadowMount).toBeDefined();
-        // The fixture only creates a nested @playwright/test — no
-        // @skyramp/skyramp package exists on disk, so the existence gate
-        // (`if (!fs.existsSync(pkgPath)) continue`) must skip it. Asserting its
-        // absence here only proves the gate is live because existsSync is now
-        // delegated to the real fs above (it would false-pass against the
-        // always-true mock default).
-        const nonexistentPkgShadow = mounts.find((m) => m.Target.endsWith("tests/node_modules/@skyramp/skyramp"));
-        expect(nonexistentPkgShadow).toBeUndefined();
-        const command = mockRun.mock.calls[0][1];
-        expect(command.slice(0, 2)).toEqual(["bash", "-c"]);
-        expect(command[2]).toContain("NODE_PATH");
-        expect(command[2]).toContain("/root/runner.sh");
-    });
-});
-describe("TestExecutionService.executeTest - cross-repo context nested node_modules shadow", () => {
-    let TestExecutionService;
-    let TEST_REPO_CONTAINER_SUBDIR;
-    let EXECUTOR_DOCKER_IMAGE;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        TestExecutionService = mod.TestExecutionService;
-        TEST_REPO_CONTAINER_SUBDIR = mod.TEST_REPO_CONTAINER_SUBDIR;
-        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        // Real directory traversal so findNestedNodeModules sees the on-disk tree
-        // built by makeTree() below (same delegation as the sibling
-        // workspace-context describe block above).
-        mockReaddirSync.mockImplementation((...args) => actualFs.readdirSync(...args));
-        // Real existsSync too, so the production `if (!fs.existsSync(pkgPath))
-        // continue` package-existence gate is genuinely exercised against the
-        // on-disk tree instead of the file-level always-true default.
-        mockExistsSync.mockImplementation((...args) => actualFs.existsSync(...args));
-    });
-    afterEach(() => {
-        // Restore the file-level always-true default for describes that follow.
-        mockExistsSync.mockReturnValue(true);
-    });
-    it("shadows a leaked nested @playwright/test in the cross-repo test root, mirroring at the host path unconditionally", async () => {
-        const workspaceRoot = makeTree({});
-        const testRepoRoot = makeTree({
-            "e2e/node_modules/@playwright/test/index.js": "module.exports = {};",
-            "e2e/sample.spec.ts": "test('noop', () => {});",
-        });
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: path.join(testRepoRoot, "e2e/sample.spec.ts"),
-            workspacePath: workspaceRoot,
-            testRepoPath: testRepoRoot,
-            language: "typescript",
-            testType: "smoke",
-        });
-        expect(mockRun).toHaveBeenCalledTimes(1);
-        const mounts = mockRun.mock.calls[0][3].HostConfig.Mounts;
-        // Container-side shadow lives under the reserved test-repo subdir.
-        const containerShadow = mounts.find((m) => m.ReadOnly &&
-            m.Target.includes(TEST_REPO_CONTAINER_SUBDIR) &&
-            m.Target.endsWith("e2e/node_modules/@playwright/test"));
-        expect(containerShadow).toBeDefined();
-        // Cross-repo mounts always mirror at the host-absolute path too (unlike
-        // the workspace context, where mirroring is conditional on
-        // workspacePath !== containerMountPath) — assert that unconditional
-        // mirror explicitly, since it's what distinguishes this context.
-        const hostPkgPath = path.join(testRepoRoot, "e2e/node_modules/@playwright/test");
-        const hostMirrorShadow = mounts.find((m) => m.ReadOnly && m.Target === hostPkgPath);
-        expect(hostMirrorShadow).toBeDefined();
-        expect(hostMirrorShadow.Source).toBe(containerShadow.Source);
-    });
-});
-describe("TestExecutionService.executeTest - root-level Playwright config shadow", () => {
-    let TestExecutionService;
-    let EXECUTOR_DOCKER_IMAGE;
-    beforeAll(async () => {
-        const mod = await import("./TestExecutionService.js");
-        TestExecutionService = mod.TestExecutionService;
-        EXECUTOR_DOCKER_IMAGE = mod.EXECUTOR_DOCKER_IMAGE;
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockListImages.mockResolvedValue([{ RepoTags: [EXECUTOR_DOCKER_IMAGE] }]);
-        const mockContainer = { remove: jest.fn().mockResolvedValue(undefined) };
-        mockRun.mockResolvedValue([{ StatusCode: 0 }, mockContainer]);
-        // Real directory traversal so the entry-mount filter and the
-        // PLAYWRIGHT_CONFIG_FILES shadow scan see the on-disk tree built by
-        // makeTree() below (same delegation as the sibling shadow describes above).
-        mockReaddirSync.mockImplementation((...args) => actualFs.readdirSync(...args));
-        mockExistsSync.mockImplementation((...args) => actualFs.existsSync(...args));
-    });
-    afterEach(() => {
-        // Restore the file-level always-true default for describes that follow.
-        mockExistsSync.mockReturnValue(true);
-    });
-    // Regression test: a root-level playwright.config.js used to win the
-    // pushMount target-dedup race over its minimal-config shadow, because the
-    // entry-mount filter excluded EXCLUDED_MOUNT_ITEMS/MOUNT_NULL_ITEMS but not
-    // PLAYWRIGHT_CONFIG_FILES — so the repo's own root config (which may import
-    // dotenv, or simply isn't the video-enabled config the executor expects)
-    // leaked into the container instead of being shadowed.
-    it("shadows a root-level playwright.config.js with the minimal/generated config instead of the workspace's own file", async () => {
-        const root = makeTree({
-            "playwright.config.js": "module.exports = { testDir: './tests' };",
-            "tests/sample.spec.ts": "test('noop', () => {});",
-        });
-        const service = new TestExecutionService();
-        await service.executeTest({
-            testFile: path.join(root, "tests/sample.spec.ts"),
-            workspacePath: root,
-            language: "typescript",
-            testType: "smoke",
-        });
-        expect(mockRun).toHaveBeenCalledTimes(1);
-        const mounts = mockRun.mock.calls[0][3].HostConfig.Mounts;
-        const configMount = mounts.find((m) => m.Target === path.join("/home/user", "playwright.config.js"));
-        expect(configMount).toBeDefined();
-        expect(configMount.Source).not.toBe(path.join(root, "playwright.config.js"));
-    });
-});