testblocks-agent 1.0.0

package/dist/__tests__/unit/executor.test.js

@@ -0,0 +1,1017 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const path_1 = __importDefault(require("path"));
+const executor_1 = require("../../executor");
+(0, vitest_1.describe)('browserToDevice', () => {
+    (0, vitest_1.it)('maps "chrome" to "Desktop Chrome"', () => {
+        (0, vitest_1.expect)((0, executor_1.browserToDevice)('chrome')).toBe('Desktop Chrome');
+    });
+    (0, vitest_1.it)('maps "firefox" to "Desktop Firefox"', () => {
+        (0, vitest_1.expect)((0, executor_1.browserToDevice)('firefox')).toBe('Desktop Firefox');
+    });
+    (0, vitest_1.it)('maps "webkit" to "Desktop Safari"', () => {
+        (0, vitest_1.expect)((0, executor_1.browserToDevice)('webkit')).toBe('Desktop Safari');
+    });
+    (0, vitest_1.it)('maps unknown browser to "Desktop Chrome" (default)', () => {
+        (0, vitest_1.expect)((0, executor_1.browserToDevice)('edge')).toBe('Desktop Chrome');
+        (0, vitest_1.expect)((0, executor_1.browserToDevice)('')).toBe('Desktop Chrome');
+        (0, vitest_1.expect)((0, executor_1.browserToDevice)('safari')).toBe('Desktop Chrome');
+    });
+});
+(0, vitest_1.describe)('generateRunnerConfig', () => {
+    const baseConfig = {
+        browser: 'chrome',
+        headless: true,
+        viewportWidth: 1280,
+        viewportHeight: 720,
+        timeout: 30000,
+        retries: 0,
+        screenshots: 'off',
+        video: 'off',
+        trace: 'off',
+    };
+    (0, vitest_1.it)('generates valid Playwright config string', () => {
+        const result = (0, executor_1.generateRunnerConfig)(baseConfig);
+        (0, vitest_1.expect)(result).toContain("import { defineConfig, devices } from '@playwright/test'");
+        (0, vitest_1.expect)(result).toContain("import dotenv from 'dotenv'");
+        (0, vitest_1.expect)(result).toContain('dotenv.config()');
+        (0, vitest_1.expect)(result).toContain('export default defineConfig({');
+        (0, vitest_1.expect)(result).toContain("testDir: './'");
+        (0, vitest_1.expect)(result).toContain('timeout: 30000');
+        (0, vitest_1.expect)(result).toContain('retries: 0');
+        (0, vitest_1.expect)(result).toContain('fullyParallel: false');
+        (0, vitest_1.expect)(result).toContain('workers: 1');
+        (0, vitest_1.expect)(result).toContain('headless: true');
+        (0, vitest_1.expect)(result).toContain('viewport: { width: 1280, height: 720 }');
+        (0, vitest_1.expect)(result).toContain("screenshot: 'off'");
+        (0, vitest_1.expect)(result).toContain("video: 'off'");
+        (0, vitest_1.expect)(result).toContain("trace: 'off'");
+        (0, vitest_1.expect)(result).toContain("baseURL: process.env.BASE_URL || undefined");
+    });
+    (0, vitest_1.it)('includes correct browser project name', () => {
+        const result = (0, executor_1.generateRunnerConfig)(baseConfig);
+        (0, vitest_1.expect)(result).toContain("name: 'chrome'");
+        (0, vitest_1.expect)(result).toContain("...devices['Desktop Chrome']");
+    });
+    (0, vitest_1.it)('uses Desktop Firefox device for firefox browser', () => {
+        const config = { ...baseConfig, browser: 'firefox' };
+        const result = (0, executor_1.generateRunnerConfig)(config);
+        (0, vitest_1.expect)(result).toContain("name: 'firefox'");
+        (0, vitest_1.expect)(result).toContain("...devices['Desktop Firefox']");
+    });
+    (0, vitest_1.it)('uses Desktop Safari device for webkit browser', () => {
+        const config = { ...baseConfig, browser: 'webkit' };
+        const result = (0, executor_1.generateRunnerConfig)(config);
+        (0, vitest_1.expect)(result).toContain("name: 'webkit'");
+        (0, vitest_1.expect)(result).toContain("...devices['Desktop Safari']");
+    });
+    (0, vitest_1.it)('respects headless false', () => {
+        const config = { ...baseConfig, headless: false };
+        const result = (0, executor_1.generateRunnerConfig)(config);
+        (0, vitest_1.expect)(result).toContain('headless: false');
+    });
+    (0, vitest_1.it)('includes JSON reporter config', () => {
+        const result = (0, executor_1.generateRunnerConfig)(baseConfig);
+        (0, vitest_1.expect)(result).toContain("reporter: [['json', { outputFile: 'report.json' }], ['line']]");
+    });
+    (0, vitest_1.it)('uses custom timeout and retries', () => {
+        const config = { ...baseConfig, timeout: 60000, retries: 2 };
+        const result = (0, executor_1.generateRunnerConfig)(config);
+        (0, vitest_1.expect)(result).toContain('timeout: 60000');
+        (0, vitest_1.expect)(result).toContain('retries: 2');
+    });
+    (0, vitest_1.it)('uses custom viewport dimensions', () => {
+        const config = { ...baseConfig, viewportWidth: 1920, viewportHeight: 1080 };
+        const result = (0, executor_1.generateRunnerConfig)(config);
+        (0, vitest_1.expect)(result).toContain('viewport: { width: 1920, height: 1080 }');
+    });
+    (0, vitest_1.it)('configures screenshot, video, and trace modes', () => {
+        const config = {
+            ...baseConfig,
+            screenshots: 'on',
+            video: 'retain-on-failure',
+            trace: 'on-first-retry',
+        };
+        const result = (0, executor_1.generateRunnerConfig)(config);
+        (0, vitest_1.expect)(result).toContain("screenshot: 'on'");
+        (0, vitest_1.expect)(result).toContain("video: 'retain-on-failure'");
+        (0, vitest_1.expect)(result).toContain("trace: 'on-first-retry'");
+    });
+});
+(0, vitest_1.describe)('sanitizeError', () => {
+    (0, vitest_1.it)('returns plain text unchanged (when under limit)', () => {
+        const msg = 'Something went wrong';
+        (0, vitest_1.expect)((0, executor_1.sanitizeError)(msg)).toBe('Something went wrong');
+    });
+    (0, vitest_1.it)('strips ANSI escape codes', () => {
+        const msg = '\x1b[31mError:\x1b[0m test failed \x1b[1m(critical)\x1b[0m';
+        (0, vitest_1.expect)((0, executor_1.sanitizeError)(msg)).toBe('Error: test failed (critical)');
+    });
+    (0, vitest_1.it)('truncates messages longer than 300 characters', () => {
+        const msg = 'A'.repeat(400);
+        const result = (0, executor_1.sanitizeError)(msg);
+        (0, vitest_1.expect)(result).toHaveLength(303); // 300 + '...'
+        (0, vitest_1.expect)(result.endsWith('...')).toBe(true);
+        (0, vitest_1.expect)(result).toBe('A'.repeat(300) + '...');
+    });
+    (0, vitest_1.it)('does not truncate messages at exactly 300 characters', () => {
+        const msg = 'B'.repeat(300);
+        const result = (0, executor_1.sanitizeError)(msg);
+        (0, vitest_1.expect)(result).toBe('B'.repeat(300));
+        (0, vitest_1.expect)(result).not.toContain('...');
+    });
+    (0, vitest_1.it)('strips ANSI codes before truncating', () => {
+        // ANSI codes take up space in the original string but not after stripping
+        const ansiPrefix = '\x1b[31m'; // 5 chars
+        const msg = ansiPrefix + 'X'.repeat(250);
+        const result = (0, executor_1.sanitizeError)(msg);
+        // After stripping ANSI, the clean string is 250 chars -- under limit
+        (0, vitest_1.expect)(result).toBe('X'.repeat(250));
+    });
+    (0, vitest_1.it)('handles empty string', () => {
+        (0, vitest_1.expect)((0, executor_1.sanitizeError)('')).toBe('');
+    });
+    (0, vitest_1.it)('handles multiple ANSI sequences', () => {
+        const msg = '\x1b[1m\x1b[31mBold Red\x1b[0m normal \x1b[32mgreen\x1b[0m';
+        (0, vitest_1.expect)((0, executor_1.sanitizeError)(msg)).toBe('Bold Red normal green');
+    });
+    (0, vitest_1.it)('strips complex ANSI codes with multiple parameters', () => {
+        const msg = '\x1b[38;5;196mcolored text\x1b[0m';
+        (0, vitest_1.expect)((0, executor_1.sanitizeError)(msg)).toBe('colored text');
+    });
+});
+(0, vitest_1.describe)('flattenSpecs', () => {
+    (0, vitest_1.it)('returns specs from a flat suite array', () => {
+        const suites = [
+            { specs: [{ title: 'test1' }, { title: 'test2' }] },
+            { specs: [{ title: 'test3' }] },
+        ];
+        const result = (0, executor_1.flattenSpecs)(suites);
+        (0, vitest_1.expect)(result).toEqual([
+            { title: 'test1' },
+            { title: 'test2' },
+            { title: 'test3' },
+        ]);
+    });
+    (0, vitest_1.it)('flattens nested suites recursively', () => {
+        const suites = [
+            {
+                specs: [{ title: 'top-level' }],
+                suites: [
+                    {
+                        specs: [{ title: 'nested' }],
+                        suites: [
+                            { specs: [{ title: 'deeply-nested' }] },
+                        ],
+                    },
+                ],
+            },
+        ];
+        const result = (0, executor_1.flattenSpecs)(suites);
+        (0, vitest_1.expect)(result).toEqual([
+            { title: 'top-level' },
+            { title: 'nested' },
+            { title: 'deeply-nested' },
+        ]);
+    });
+    (0, vitest_1.it)('returns empty array for empty suites', () => {
+        (0, vitest_1.expect)((0, executor_1.flattenSpecs)([])).toEqual([]);
+    });
+    (0, vitest_1.it)('handles suites with no specs property', () => {
+        const suites = [
+            { suites: [{ specs: [{ title: 'inner' }] }] },
+        ];
+        const result = (0, executor_1.flattenSpecs)(suites);
+        (0, vitest_1.expect)(result).toEqual([{ title: 'inner' }]);
+    });
+    (0, vitest_1.it)('handles suites with no nested suites', () => {
+        const suites = [
+            { specs: [{ title: 'only-specs' }] },
+        ];
+        const result = (0, executor_1.flattenSpecs)(suites);
+        (0, vitest_1.expect)(result).toEqual([{ title: 'only-specs' }]);
+    });
+    (0, vitest_1.it)('handles mix of suites with and without specs', () => {
+        const suites = [
+            { specs: [{ title: 'a' }] },
+            { suites: [{ specs: [{ title: 'b' }] }] },
+            { specs: [{ title: 'c' }], suites: [{ specs: [{ title: 'd' }] }] },
+        ];
+        const result = (0, executor_1.flattenSpecs)(suites);
+        (0, vitest_1.expect)(result).toEqual([
+            { title: 'a' },
+            { title: 'b' },
+            { title: 'c' },
+            { title: 'd' },
+        ]);
+    });
+});
+(0, vitest_1.describe)('mapPlaywrightStatus', () => {
+    (0, vitest_1.it)('maps "passed" to "passed"', () => {
+        (0, vitest_1.expect)((0, executor_1.mapPlaywrightStatus)('passed')).toBe('passed');
+    });
+    (0, vitest_1.it)('maps "failed" to "failed"', () => {
+        (0, vitest_1.expect)((0, executor_1.mapPlaywrightStatus)('failed')).toBe('failed');
+    });
+    (0, vitest_1.it)('maps "timedOut" to "failed"', () => {
+        (0, vitest_1.expect)((0, executor_1.mapPlaywrightStatus)('timedOut')).toBe('failed');
+    });
+    (0, vitest_1.it)('maps "skipped" to "skipped"', () => {
+        (0, vitest_1.expect)((0, executor_1.mapPlaywrightStatus)('skipped')).toBe('skipped');
+    });
+    (0, vitest_1.it)('maps "interrupted" to "error" (default)', () => {
+        (0, vitest_1.expect)((0, executor_1.mapPlaywrightStatus)('interrupted')).toBe('error');
+    });
+    (0, vitest_1.it)('maps unknown status to "error"', () => {
+        (0, vitest_1.expect)((0, executor_1.mapPlaywrightStatus)('unknown')).toBe('error');
+        (0, vitest_1.expect)((0, executor_1.mapPlaywrightStatus)('')).toBe('error');
+        (0, vitest_1.expect)((0, executor_1.mapPlaywrightStatus)('cancelled')).toBe('error');
+    });
+});
+(0, vitest_1.describe)('collectArtifacts', () => {
+    const workDir = '/tmp/testblocks-agent/run-123';
+    (0, vitest_1.it)('returns empty result for empty attachments', () => {
+        const result = (0, executor_1.collectArtifacts)([], workDir);
+        (0, vitest_1.expect)(result).toEqual({
+            screenshots: [],
+            video: null,
+            trace: null,
+        });
+    });
+    (0, vitest_1.it)('collects image attachments as screenshots', () => {
+        const attachments = [
+            { path: path_1.default.join(workDir, 'screenshots', 'test-1.png'), contentType: 'image/png' },
+            { path: path_1.default.join(workDir, 'screenshots', 'test-2.jpg'), contentType: 'image/jpeg' },
+        ];
+        const result = (0, executor_1.collectArtifacts)(attachments, workDir);
+        (0, vitest_1.expect)(result.screenshots).toEqual([
+            'screenshots/test-1.png',
+            'screenshots/test-2.jpg',
+        ]);
+    });
+    (0, vitest_1.it)('collects video attachment', () => {
+        const attachments = [
+            { path: path_1.default.join(workDir, 'videos', 'test.webm'), contentType: 'video/webm' },
+        ];
+        const result = (0, executor_1.collectArtifacts)(attachments, workDir);
+        (0, vitest_1.expect)(result.video).toBe('videos/test.webm');
+    });
+    (0, vitest_1.it)('collects trace attachment by name', () => {
+        const attachments = [
+            { path: path_1.default.join(workDir, 'trace.zip'), contentType: 'application/zip', name: 'trace' },
+        ];
+        const result = (0, executor_1.collectArtifacts)(attachments, workDir);
+        (0, vitest_1.expect)(result.trace).toBe('trace.zip');
+    });
+    (0, vitest_1.it)('collects trace attachment by .zip extension', () => {
+        const attachments = [
+            { path: path_1.default.join(workDir, 'data', 'trace-abc.zip'), contentType: 'application/octet-stream' },
+        ];
+        const result = (0, executor_1.collectArtifacts)(attachments, workDir);
+        (0, vitest_1.expect)(result.trace).toBe('data/trace-abc.zip');
+    });
+    (0, vitest_1.it)('skips attachments without path', () => {
+        const attachments = [
+            { contentType: 'image/png' },
+            { path: null, contentType: 'image/png' },
+            { path: path_1.default.join(workDir, 'real.png'), contentType: 'image/png' },
+        ];
+        const result = (0, executor_1.collectArtifacts)(attachments, workDir);
+        (0, vitest_1.expect)(result.screenshots).toEqual(['real.png']);
+    });
+    (0, vitest_1.it)('handles mixed attachment types', () => {
+        const attachments = [
+            { path: path_1.default.join(workDir, 'shot1.png'), contentType: 'image/png' },
+            { path: path_1.default.join(workDir, 'video.webm'), contentType: 'video/webm' },
+            { path: path_1.default.join(workDir, 'trace.zip'), contentType: 'application/zip', name: 'trace' },
+            { path: path_1.default.join(workDir, 'shot2.png'), contentType: 'image/png' },
+        ];
+        const result = (0, executor_1.collectArtifacts)(attachments, workDir);
+        (0, vitest_1.expect)(result.screenshots).toEqual(['shot1.png', 'shot2.png']);
+        (0, vitest_1.expect)(result.video).toBe('video.webm');
+        (0, vitest_1.expect)(result.trace).toBe('trace.zip');
+    });
+    (0, vitest_1.it)('uses forward slashes in relative paths', () => {
+        // Even on Windows, the function normalizes to forward slashes
+        const attachments = [
+            { path: path_1.default.join(workDir, 'nested', 'dir', 'screenshot.png'), contentType: 'image/png' },
+        ];
+        const result = (0, executor_1.collectArtifacts)(attachments, workDir);
+        (0, vitest_1.expect)(result.screenshots[0]).toBe('nested/dir/screenshot.png');
+        (0, vitest_1.expect)(result.screenshots[0]).not.toContain('\\');
+    });
+    (0, vitest_1.it)('last video wins when multiple videos present', () => {
+        const attachments = [
+            { path: path_1.default.join(workDir, 'v1.webm'), contentType: 'video/webm' },
+            { path: path_1.default.join(workDir, 'v2.webm'), contentType: 'video/mp4' },
+        ];
+        const result = (0, executor_1.collectArtifacts)(attachments, workDir);
+        (0, vitest_1.expect)(result.video).toBe('v2.webm');
+    });
+});
+// ============================================================
+// Integration tests for executeJob and uploadFile
+// ============================================================
+// We need dynamic imports since executeJob uses fs, child_process, etc. at module level
+// We mock fs, child_process, and os at the module level for the integration tests
+const events_1 = require("events");
+// Helper to build a mock ChildProcess (EventEmitter with stdout/stderr)
+function createMockChildProcess() {
+    const cp = new events_1.EventEmitter();
+    cp._stdout = new events_1.EventEmitter();
+    cp._stderr = new events_1.EventEmitter();
+    cp.stdout = cp._stdout;
+    cp.stderr = cp._stderr;
+    cp.stdin = null;
+    cp.stdio = [null, cp._stdout, cp._stderr];
+    cp.pid = 12345;
+    cp.killed = false;
+    cp.kill = vitest_1.vi.fn(() => {
+        cp.killed = true;
+        return true;
+    });
+    cp.ref = vitest_1.vi.fn();
+    cp.unref = vitest_1.vi.fn();
+    cp.disconnect = vitest_1.vi.fn();
+    cp.connected = false;
+    cp.exitCode = null;
+    cp.signalCode = null;
+    cp.spawnargs = [];
+    cp.spawnfile = '';
+    cp[Symbol.dispose] = vitest_1.vi.fn();
+    return cp;
+}
+// Helper job payload
+function createTestJob(overrides) {
+    return {
+        jobId: 'job-test-1',
+        testRunId: 'run-test-1',
+        specs: [
+            {
+                testCaseId: 'tc-1',
+                filename: 'login-test',
+                specCode: 'test("login", async () => { /* ... */ });',
+                fixturesCode: null,
+            },
+        ],
+        config: {
+            browser: 'chrome',
+            timeout: 30000,
+            retries: 0,
+            headless: true,
+            screenshots: 'off',
+            video: 'off',
+            trace: 'off',
+            viewportWidth: 1280,
+            viewportHeight: 720,
+        },
+        envVars: [],
+        ...overrides,
+    };
+}
+// Helper to create a mock AgentClient
+function createMockClient() {
+    return {
+        reportProgress: vitest_1.vi.fn().mockResolvedValue({ cancelled: false }),
+        reportResults: vitest_1.vi.fn().mockResolvedValue(undefined),
+        uploadArtifact: vitest_1.vi.fn().mockResolvedValue(undefined),
+    };
+}
+(0, vitest_1.describe)('executeJob (integration)', () => {
+    let mockFs;
+    let mockSpawn;
+    let mockClient;
+    let executeJobFn;
+    (0, vitest_1.beforeEach)(async () => {
+        vitest_1.vi.resetModules();
+        // Mock fs module
+        vitest_1.vi.doMock('fs', () => ({
+            default: {
+                mkdirSync: vitest_1.vi.fn(),
+                writeFileSync: vitest_1.vi.fn(),
+                existsSync: vitest_1.vi.fn().mockReturnValue(false),
+                readFileSync: vitest_1.vi.fn().mockReturnValue(''),
+                rmSync: vitest_1.vi.fn(),
+                symlinkSync: vitest_1.vi.fn(),
+            },
+            mkdirSync: vitest_1.vi.fn(),
+            writeFileSync: vitest_1.vi.fn(),
+            existsSync: vitest_1.vi.fn().mockReturnValue(false),
+            readFileSync: vitest_1.vi.fn().mockReturnValue(''),
+            rmSync: vitest_1.vi.fn(),
+            symlinkSync: vitest_1.vi.fn(),
+        }));
+        // Mock child_process.spawn
+        mockSpawn = vitest_1.vi.fn();
+        vitest_1.vi.doMock('child_process', () => ({
+            spawn: mockSpawn,
+        }));
+        // Mock os.tmpdir
+        vitest_1.vi.doMock('os', () => ({
+            default: { tmpdir: () => '/tmp' },
+            tmpdir: () => '/tmp',
+        }));
+        // Silence console output during tests
+        vitest_1.vi.spyOn(console, 'log').mockImplementation(() => { });
+        vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+        vitest_1.vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        vitest_1.vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        // Load mocked fs reference
+        mockFs = (await Promise.resolve().then(() => __importStar(require('fs')))).default;
+        // Load the module with mocks applied
+        const executorModule = await Promise.resolve().then(() => __importStar(require('../../executor')));
+        executeJobFn = executorModule.executeJob;
+        mockClient = createMockClient();
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+        vitest_1.vi.resetModules();
+    });
+    (0, vitest_1.it)('creates work directory with recursive flag', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        // existsSync returns false for report.json check and node_modules
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        // Simulate process exit immediately
+        const promise = executeJobFn(job, mockClient);
+        // Let the spawn callback attach, then emit close
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        (0, vitest_1.expect)(mockFs.mkdirSync).toHaveBeenCalledWith(vitest_1.expect.stringContaining('run-test-1'), { recursive: true });
+    });
+    (0, vitest_1.it)('writes spec files for each test in the job', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob({
+            specs: [
+                { testCaseId: 'tc-1', filename: 'login-test', specCode: 'code1', fixturesCode: null },
+                { testCaseId: 'tc-2', filename: 'dashboard-test', specCode: 'code2', fixturesCode: null },
+            ],
+        });
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        // Should write both spec files
+        const writeFileCalls = mockFs.writeFileSync.mock.calls;
+        const specWrites = writeFileCalls.filter((call) => call[0].endsWith('.spec.ts'));
+        (0, vitest_1.expect)(specWrites).toHaveLength(2);
+        (0, vitest_1.expect)(specWrites[0][0]).toContain('login-test.spec.ts');
+        (0, vitest_1.expect)(specWrites[0][1]).toBe('code1');
+        (0, vitest_1.expect)(specWrites[1][0]).toContain('dashboard-test.spec.ts');
+        (0, vitest_1.expect)(specWrites[1][1]).toBe('code2');
+    });
+    (0, vitest_1.it)('writes fixtures.ts when fixturesCode is provided', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob({
+            specs: [
+                { testCaseId: 'tc-1', filename: 'test1', specCode: 'code1', fixturesCode: 'fixture code here' },
+            ],
+        });
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        const writeFileCalls = mockFs.writeFileSync.mock.calls;
+        const fixtureWrite = writeFileCalls.find((call) => call[0].endsWith('fixtures.ts'));
+        (0, vitest_1.expect)(fixtureWrite).toBeDefined();
+        (0, vitest_1.expect)(fixtureWrite[1]).toBe('fixture code here');
+    });
+    (0, vitest_1.it)('writes playwright.config.ts', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        const writeFileCalls = mockFs.writeFileSync.mock.calls;
+        const configWrite = writeFileCalls.find((call) => call[0].endsWith('playwright.config.ts'));
+        (0, vitest_1.expect)(configWrite).toBeDefined();
+        (0, vitest_1.expect)(configWrite[1]).toContain('defineConfig');
+    });
+    (0, vitest_1.it)('writes .env file when envVars are provided', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob({
+            envVars: [
+                { name: 'BASE_URL', value: 'http://localhost:3000' },
+                { name: 'API_KEY', value: 'secret123' },
+            ],
+        });
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        const writeFileCalls = mockFs.writeFileSync.mock.calls;
+        const envWrite = writeFileCalls.find((call) => call[0].endsWith('.env'));
+        (0, vitest_1.expect)(envWrite).toBeDefined();
+        (0, vitest_1.expect)(envWrite[1]).toContain('BASE_URL=http://localhost:3000');
+        (0, vitest_1.expect)(envWrite[1]).toContain('API_KEY=secret123');
+    });
+    (0, vitest_1.it)('does not write .env file when envVars is empty', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob({ envVars: [] });
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        const writeFileCalls = mockFs.writeFileSync.mock.calls;
+        const envWrite = writeFileCalls.find((call) => call[0].endsWith('.env'));
+        (0, vitest_1.expect)(envWrite).toBeUndefined();
+    });
+    (0, vitest_1.it)('spawns npx playwright test with correct args', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        (0, vitest_1.expect)(mockSpawn).toHaveBeenCalledWith('npx', ['playwright', 'test', '--config=playwright.config.ts'], vitest_1.expect.objectContaining({
+            cwd: vitest_1.expect.stringContaining('run-test-1'),
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: true,
+        }));
+    });
+    (0, vitest_1.it)('reports progress when stdout contains progress pattern', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        // Simulate progress output from Playwright
+        mockChild._stdout.emit('data', Buffer.from('  [1/2] Running test...\n'));
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        (0, vitest_1.expect)(mockClient.reportProgress).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            jobId: 'job-test-1',
+            completedTests: 0, // current - 1 = 1 - 1 = 0
+        }));
+    });
+    (0, vitest_1.it)('reads and parses report.json when it exists', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        // existsSync: false for node_modules, true for report.json
+        mockFs.existsSync.mockImplementation((p) => {
+            if (p.endsWith('report.json'))
+                return true;
+            return false;
+        });
+        const report = {
+            suites: [{
+                    specs: [{
+                            file: 'login-test.spec.ts',
+                            tests: [{
+                                    results: [{
+                                            status: 'passed',
+                                            duration: 1234,
+                                            attachments: [],
+                                        }],
+                                }],
+                        }],
+                }],
+        };
+        mockFs.readFileSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json')) {
+                return JSON.stringify(report);
+            }
+            return '';
+        });
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        (0, vitest_1.expect)(mockClient.reportResults).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            jobId: 'job-test-1',
+            testRunId: 'run-test-1',
+            results: vitest_1.expect.arrayContaining([
+                vitest_1.expect.objectContaining({
+                    testCaseId: 'tc-1',
+                    status: 'passed',
+                    durationMs: 1234,
+                }),
+            ]),
+        }));
+    });
+    (0, vitest_1.it)('reports error results when report.json is missing', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 1);
+        await promise;
+        (0, vitest_1.expect)(mockClient.reportResults).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            results: vitest_1.expect.arrayContaining([
+                vitest_1.expect.objectContaining({
+                    testCaseId: 'tc-1',
+                    status: 'error',
+                    errorMessage: vitest_1.expect.any(String),
+                }),
+            ]),
+        }));
+    });
+    (0, vitest_1.it)('handles process failure (non-zero exit code) with stderr', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        // Emit stderr
+        mockChild._stderr.emit('data', Buffer.from('Error: Cannot find module'));
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 1);
+        await promise;
+        (0, vitest_1.expect)(mockClient.reportResults).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            results: vitest_1.expect.arrayContaining([
+                vitest_1.expect.objectContaining({
+                    status: 'error',
+                    errorMessage: vitest_1.expect.stringContaining('Cannot find module'),
+                }),
+            ]),
+        }));
+    });
+    (0, vitest_1.it)('cleans up work directory in finally block', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        (0, vitest_1.expect)(mockFs.rmSync).toHaveBeenCalledWith(vitest_1.expect.stringContaining('run-test-1'), { recursive: true, force: true });
+    });
+    (0, vitest_1.it)('handles cancellation from server', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        // Return cancelled: true on progress report
+        mockClient.reportProgress.mockResolvedValue({ cancelled: true });
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        // Emit progress pattern to trigger reportProgress
+        mockChild._stdout.emit('data', Buffer.from('[1/1] test\n'));
+        await new Promise(r => setTimeout(r, 50));
+        mockChild.emit('close', 0);
+        await promise;
+        // Should have called kill on the child process
+        (0, vitest_1.expect)(mockChild.kill).toHaveBeenCalledWith('SIGTERM');
+    });
+    (0, vitest_1.it)('uploads artifacts from report results', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        const workDir = path_1.default.join('/tmp', 'testblocks-agent', 'run-test-1');
+        const screenshotPath = path_1.default.join(workDir, 'screenshots', 'test.png');
+        // existsSync: true for report.json and screenshot file, false for others
+        mockFs.existsSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json'))
+                return true;
+            if (typeof p === 'string' && p.endsWith('test.png'))
+                return true;
+            return false;
+        });
+        const report = {
+            suites: [{
+                    specs: [{
+                            file: 'login-test.spec.ts',
+                            tests: [{
+                                    results: [{
+                                            status: 'passed',
+                                            duration: 500,
+                                            attachments: [
+                                                { path: screenshotPath, contentType: 'image/png', name: 'screenshot' },
+                                            ],
+                                        }],
+                                }],
+                        }],
+                }],
+        };
+        mockFs.readFileSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json')) {
+                return JSON.stringify(report);
+            }
+            return Buffer.from('fake image');
+        });
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        (0, vitest_1.expect)(mockClient.uploadArtifact).toHaveBeenCalledWith('run-test-1', vitest_1.expect.stringContaining('test.png'), vitest_1.expect.any(Buffer));
+    });
+    (0, vitest_1.it)('reports error to server when execution throws', async () => {
+        // Make spawn throw an error
+        mockSpawn.mockImplementation(() => {
+            throw new Error('spawn ENOENT');
+        });
+        const job = createTestJob();
+        await executeJobFn(job, mockClient);
+        (0, vitest_1.expect)(mockClient.reportResults).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+            results: vitest_1.expect.arrayContaining([
+                vitest_1.expect.objectContaining({
+                    status: 'error',
+                    errorMessage: vitest_1.expect.stringContaining('spawn ENOENT'),
+                }),
+            ]),
+        }));
+    });
+    (0, vitest_1.it)('writes package.json to work directory', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        const writeFileCalls = mockFs.writeFileSync.mock.calls;
+        const pkgWrite = writeFileCalls.find((call) => call[0].endsWith('package.json'));
+        (0, vitest_1.expect)(pkgWrite).toBeDefined();
+        const pkg = JSON.parse(pkgWrite[1]);
+        (0, vitest_1.expect)(pkg.name).toBe('testblocks-agent-run');
+        (0, vitest_1.expect)(pkg.private).toBe(true);
+    });
+    (0, vitest_1.it)('attempts to symlink node_modules when not present', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        // existsSync returns false (no existing node_modules, no report.json)
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob();
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        // Since existsSync returns false for all paths including node_modules sources,
+        // symlinkSync should NOT be called (no source node_modules found)
+        (0, vitest_1.expect)(mockFs.symlinkSync).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('only writes fixtures.ts once even with multiple specs', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        mockFs.existsSync.mockReturnValue(false);
+        const job = createTestJob({
+            specs: [
+                { testCaseId: 'tc-1', filename: 'test1', specCode: 'c1', fixturesCode: 'shared fixtures' },
+                { testCaseId: 'tc-2', filename: 'test2', specCode: 'c2', fixturesCode: 'shared fixtures' },
+            ],
+        });
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 0);
+        await promise;
+        const writeFileCalls = mockFs.writeFileSync.mock.calls;
+        const fixtureWrites = writeFileCalls.filter((call) => call[0].endsWith('fixtures.ts'));
+        (0, vitest_1.expect)(fixtureWrites).toHaveLength(1);
+    });
+    (0, vitest_1.it)('marks unprocessed tests as error when report has no matching spec', async () => {
+        const mockChild = createMockChildProcess();
+        mockSpawn.mockReturnValue(mockChild);
+        // Report has empty suites
+        mockFs.existsSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json'))
+                return true;
+            return false;
+        });
+        mockFs.readFileSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json')) {
+                return JSON.stringify({ suites: [] });
+            }
+            return '';
+        });
+        const job = createTestJob({
+            specs: [
+                { testCaseId: 'tc-1', filename: 'test1', specCode: 'c1', fixturesCode: null },
+                { testCaseId: 'tc-2', filename: 'test2', specCode: 'c2', fixturesCode: null },
+            ],
+        });
+        const promise = executeJobFn(job, mockClient);
+        await new Promise(r => setTimeout(r, 10));
+        mockChild.emit('close', 1);
+        await promise;
+        const results = mockClient.reportResults.mock.calls[0][0].results;
+        (0, vitest_1.expect)(results).toHaveLength(2);
+        (0, vitest_1.expect)(results[0].status).toBe('error');
+        (0, vitest_1.expect)(results[1].status).toBe('error');
+    });
+});
+(0, vitest_1.describe)('uploadFile (integration)', () => {
+    let mockFs;
+    let mockClient;
+    let executeJobFn;
+    (0, vitest_1.beforeEach)(async () => {
+        vitest_1.vi.resetModules();
+        vitest_1.vi.doMock('fs', () => ({
+            default: {
+                mkdirSync: vitest_1.vi.fn(),
+                writeFileSync: vitest_1.vi.fn(),
+                existsSync: vitest_1.vi.fn().mockReturnValue(false),
+                readFileSync: vitest_1.vi.fn().mockReturnValue(Buffer.from('file-content')),
+                rmSync: vitest_1.vi.fn(),
+                symlinkSync: vitest_1.vi.fn(),
+            },
+            mkdirSync: vitest_1.vi.fn(),
+            writeFileSync: vitest_1.vi.fn(),
+            existsSync: vitest_1.vi.fn().mockReturnValue(false),
+            readFileSync: vitest_1.vi.fn().mockReturnValue(Buffer.from('file-content')),
+            rmSync: vitest_1.vi.fn(),
+            symlinkSync: vitest_1.vi.fn(),
+        }));
+        vitest_1.vi.doMock('child_process', () => ({
+            spawn: vitest_1.vi.fn(),
+        }));
+        vitest_1.vi.doMock('os', () => ({
+            default: { tmpdir: () => '/tmp' },
+            tmpdir: () => '/tmp',
+        }));
+        vitest_1.vi.spyOn(console, 'log').mockImplementation(() => { });
+        vitest_1.vi.spyOn(console, 'error').mockImplementation(() => { });
+        vitest_1.vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        vitest_1.vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        mockFs = (await Promise.resolve().then(() => __importStar(require('fs')))).default;
+        const cp = await Promise.resolve().then(() => __importStar(require('child_process')));
+        const executorModule = await Promise.resolve().then(() => __importStar(require('../../executor')));
+        executeJobFn = executorModule.executeJob;
+        mockClient = createMockClient();
+        // Setup spawn to return a mock child
+        const mockChild = createMockChildProcess();
+        cp.spawn.mockReturnValue(mockChild);
+        // Schedule the mock child to close
+        setTimeout(() => mockChild.emit('close', 0), 20);
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+        vitest_1.vi.resetModules();
+    });
+    (0, vitest_1.it)('reads file from disk and uploads via client', async () => {
+        const workDir = path_1.default.join('/tmp', 'testblocks-agent', 'run-test-1');
+        const screenshotPath = path_1.default.join(workDir, 'screenshots', 'shot.png');
+        mockFs.existsSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json'))
+                return true;
+            if (typeof p === 'string' && p.endsWith('shot.png'))
+                return true;
+            return false;
+        });
+        const report = {
+            suites: [{
+                    specs: [{
+                            file: 'login-test.spec.ts',
+                            tests: [{
+                                    results: [{
+                                            status: 'passed',
+                                            duration: 100,
+                                            attachments: [
+                                                { path: screenshotPath, contentType: 'image/png', name: 'screenshot' },
+                                            ],
+                                        }],
+                                }],
+                        }],
+                }],
+        };
+        mockFs.readFileSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json')) {
+                return JSON.stringify(report);
+            }
+            return Buffer.from('png-file-data');
+        });
+        const job = createTestJob();
+        await executeJobFn(job, mockClient);
+        (0, vitest_1.expect)(mockClient.uploadArtifact).toHaveBeenCalled();
+        (0, vitest_1.expect)(mockClient.uploadArtifact).toHaveBeenCalledWith('run-test-1', vitest_1.expect.stringContaining('shot.png'), vitest_1.expect.any(Buffer));
+    });
+    (0, vitest_1.it)('handles upload failure gracefully (does not throw)', async () => {
+        const workDir = path_1.default.join('/tmp', 'testblocks-agent', 'run-test-1');
+        const screenshotPath = path_1.default.join(workDir, 'shot.png');
+        mockFs.existsSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json'))
+                return true;
+            if (typeof p === 'string' && p.endsWith('shot.png'))
+                return true;
+            return false;
+        });
+        const report = {
+            suites: [{
+                    specs: [{
+                            file: 'login-test.spec.ts',
+                            tests: [{
+                                    results: [{
+                                            status: 'passed',
+                                            duration: 100,
+                                            attachments: [
+                                                { path: screenshotPath, contentType: 'image/png', name: 'screenshot' },
+                                            ],
+                                        }],
+                                }],
+                        }],
+                }],
+        };
+        mockFs.readFileSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json')) {
+                return JSON.stringify(report);
+            }
+            return Buffer.from('img-data');
+        });
+        // Make upload fail
+        mockClient.uploadArtifact.mockRejectedValue(new Error('Upload failed: 500'));
+        const job = createTestJob();
+        // Should not throw
+        await (0, vitest_1.expect)(executeJobFn(job, mockClient)).resolves.toBeUndefined();
+        // uploadArtifact was called but failed; the job still completes
+        (0, vitest_1.expect)(mockClient.uploadArtifact).toHaveBeenCalled();
+        (0, vitest_1.expect)(mockClient.reportResults).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('skips upload when file does not exist on disk', async () => {
+        const workDir = path_1.default.join('/tmp', 'testblocks-agent', 'run-test-1');
+        const screenshotPath = path_1.default.join(workDir, 'missing.png');
+        mockFs.existsSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json'))
+                return true;
+            // The actual screenshot file does NOT exist
+            if (typeof p === 'string' && p.endsWith('missing.png'))
+                return false;
+            return false;
+        });
+        const report = {
+            suites: [{
+                    specs: [{
+                            file: 'login-test.spec.ts',
+                            tests: [{
+                                    results: [{
+                                            status: 'passed',
+                                            duration: 100,
+                                            attachments: [
+                                                { path: screenshotPath, contentType: 'image/png', name: 'screenshot' },
+                                            ],
+                                        }],
+                                }],
+                        }],
+                }],
+        };
+        mockFs.readFileSync.mockImplementation((p) => {
+            if (typeof p === 'string' && p.endsWith('report.json')) {
+                return JSON.stringify(report);
+            }
+            return '';
+        });
+        const job = createTestJob();
+        await executeJobFn(job, mockClient);
+        // uploadArtifact should NOT be called since file doesn't exist
+        (0, vitest_1.expect)(mockClient.uploadArtifact).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=executor.test.js.map