@testspectra/cli 1.0.70 → 1.1.0-rc.0

package/dist/commands/__tests__/run.test.js

@@ -0,0 +1,277 @@
+import { describe, expect, it, vi } from 'vitest';
+import { runCommand } from '../run.js';
+import { RustCoreBridge } from '../../runner/bridge.js';
+import { ConfigLoader } from '../../config/loader.js';
+import { TypeGenerator } from '../../types/generator.js';
+describe('runCommand Integration & Dynamic Worker Sizing', () => {
+    it('passes calculated dynamic worker count to RustCoreBridge payload', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: {
+                baseUrl: 'http://localhost:3000',
+                maxConcurrentSessions: '1',
+                headless: true,
+                implicitWait: '5000',
+                pageLoadTimeout: '30000',
+                scriptTimeout: '30000',
+                parallelizationMode: 'suite',
+            },
+            androidConfig: {},
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.2s',
+                results: [],
+                logs: [],
+            };
+        });
+        // Run single spec
+        await runCommand(['specs/Auth/TC-0001/web.test.ts']);
+        expect(bridgeOptionsReceived).not.toBeNull();
+        // 1 test case -> worker count must be clamped to 1
+        expect(bridgeOptionsReceived.config.webConfig.maxConcurrentSessions).toBe('1');
+    });
+    it('respects user-specified --concurrency option and passes it to RustCoreBridge', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: {
+                baseUrl: 'http://localhost:3000',
+                maxConcurrentSessions: '1',
+                headless: true,
+                implicitWait: '5000',
+                pageLoadTimeout: '30000',
+                scriptTimeout: '30000',
+                parallelizationMode: 'suite',
+            },
+            androidConfig: {},
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '2.5s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand(['specs/Auth/TC-0001/web.test.ts'], { concurrency: 4 });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        // 1 item clamped to 1
+        expect(bridgeOptionsReceived.config.webConfig.maxConcurrentSessions).toBe('1');
+    });
+    it('correctly serializes target android and devices options into RustCoreBridge payload', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: {
+                baseUrl: 'http://localhost:3000',
+                maxConcurrentSessions: '1',
+            },
+            androidConfig: {
+                driverServer: 'http://127.0.0.1:4800',
+                devices: [{ id: 'emulator-5554' }],
+            },
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand(['specs/Auth/TC-0001/android.test.ts'], {
+            target: 'android',
+            devices: 'emulator-5554,emulator-5556',
+        });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.platform).toBe('android');
+        expect(bridgeOptionsReceived.config.androidConfig.deviceName).toBeUndefined();
+        expect(bridgeOptionsReceived.config.androidConfig.devices).toEqual([
+            { id: 'emulator-5554' },
+            { id: 'emulator-5556' },
+        ]);
+        expect(bridgeOptionsReceived.targetDevice).toBe('emulator-5554,emulator-5556');
+    });
+    it('correctly serializes single --device option into devices array of objects', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: { driverServer: 'http://127.0.0.1:4800' },
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand(['specs/Auth/TC-0001/android.test.ts'], {
+            target: 'android',
+            device: 'emulator-5554',
+        });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.platform).toBe('android');
+        expect(bridgeOptionsReceived.config.androidConfig.deviceName).toBeUndefined();
+        expect(bridgeOptionsReceived.config.androidConfig.devices).toEqual([{ id: 'emulator-5554' }]);
+        expect(bridgeOptionsReceived.targetDevice).toBe('emulator-5554');
+    });
+    it('correctly serializes --all-devices flag into auto devices in config', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: { driverServer: 'http://127.0.0.1:4800' },
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand(['specs/Auth/TC-0001/android.test.ts'], {
+            target: 'android',
+            allDevices: true,
+        });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.platform).toBe('android');
+        expect(bridgeOptionsReceived.config.androidConfig.deviceName).toBeUndefined();
+        expect(bridgeOptionsReceived.config.androidConfig.devices).toBe('auto');
+        expect(bridgeOptionsReceived.targetDevice).toBe('auto');
+    });
+    it('correctly serializes --multi-device flag into auto devices in config', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: { driverServer: 'http://127.0.0.1:4800' },
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand(['specs/Auth/TC-0001/android.test.ts'], {
+            target: 'android',
+            multiDevice: true,
+        });
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.platform).toBe('android');
+        expect(bridgeOptionsReceived.config.androidConfig.deviceName).toBeUndefined();
+        expect(bridgeOptionsReceived.config.androidConfig.devices).toBe('auto');
+        expect(bridgeOptionsReceived.targetDevice).toBe('auto');
+    });
+    it('sets process.exitCode to 1 when tests fail', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: {},
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async () => {
+            return {
+                status: 'failed',
+                duration: '1.5s',
+                passedCount: 1,
+                failedCount: 1,
+                results: [],
+                logs: [],
+            };
+        });
+        process.exitCode = undefined;
+        await runCommand(['specs/ApiInterception'], { target: 'web' });
+        expect(process.exitCode).toBe(1);
+        process.exitCode = undefined; // reset
+    });
+    it('incorporates TESTSPECTRA_CARRIED_OVER into summary card calculation', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: {},
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async () => {
+            return {
+                status: 'passed',
+                duration: '2.0s',
+                passedCount: 1,
+                failedCount: 0,
+                results: [],
+                logs: [],
+            };
+        });
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        process.env.TESTSPECTRA_CARRIED_OVER = JSON.stringify({
+            passed: 3,
+            durationMs: 4000,
+        });
+        await runCommand(['specs/ApiInterception/TC-0008-fetch-mocking/web.test.ts'], { target: 'web' });
+        delete process.env.TESTSPECTRA_CARRIED_OVER;
+        const logged = consoleSpy.mock.calls.map((c) => c[0]).join('\n');
+        expect(logged).toContain('4 passed');
+        expect(logged).toContain('3 carried over');
+        expect(logged).toContain('4 total');
+        expect(logged).toContain('6.0s');
+        consoleSpy.mockRestore();
+    });
+    it('correctly passes multiple specs to RustCoreBridge payload', async () => {
+        vi.spyOn(TypeGenerator, 'writeDeclarationFiles').mockImplementation(() => { });
+        vi.spyOn(ConfigLoader, 'loadConfig').mockResolvedValue({
+            webConfig: { baseUrl: 'http://localhost:3000' },
+            androidConfig: {},
+            iosConfig: {},
+            browsers: [],
+            executionConfig: {},
+        });
+        let bridgeOptionsReceived = null;
+        vi.spyOn(RustCoreBridge, 'run').mockImplementation(async (options) => {
+            bridgeOptionsReceived = options;
+            return {
+                status: 'passed',
+                duration: '1.0s',
+                results: [],
+                logs: [],
+            };
+        });
+        await runCommand(['specs/Auth/TC-0001/web.test.ts', 'specs/Auth/TC-0002/web.test.ts']);
+        expect(bridgeOptionsReceived).not.toBeNull();
+        expect(bridgeOptionsReceived.specs).toEqual(['specs/Auth/TC-0001/web.test.ts', 'specs/Auth/TC-0002/web.test.ts']);
+    });
+});

package/dist/commands/__tests__/watch.test.d.ts

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

package/dist/commands/__tests__/watch.test.js

@@ -0,0 +1,155 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { startWatcher, watchCommand } from '../watch.js';
+async function waitForCondition(fn, timeout = 2500, interval = 25) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        if (fn())
+            return;
+        await new Promise((r) => setTimeout(r, interval));
+    }
+    if (!fn()) {
+        throw new Error(`Timed out waiting for file watcher condition after ${timeout}ms`);
+    }
+}
+describe('watch command and startWatcher daemon', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'spectra-watch-test-'));
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+    });
+    it('runs initial generation on startWatcher startup', () => {
+        fs.mkdirSync(path.join(tmpDir, 'page-objects', 'AuthPage'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, 'page-objects', 'AuthPage', 'web.ts'), 'export default class AuthPage {}');
+        const handle = startWatcher(tmpDir, 30);
+        try {
+            const webDtsPath = path.join(tmpDir, '.testspectra', 'types', 'web.d.ts');
+            expect(fs.existsSync(webDtsPath)).toBe(true);
+            const content = fs.readFileSync(webDtsPath, 'utf-8');
+            expect(content).toContain('declare const AuthPage:');
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('dynamically regenerates types when new page object or step is added during watch', async () => {
+        const handle = startWatcher(tmpDir, 30);
+        // Allow OS watcher handle to hook in
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        try {
+            // 1. Add page object dynamically
+            const poDir = path.join(tmpDir, 'page-objects', 'CheckoutPage');
+            fs.mkdirSync(poDir, { recursive: true });
+            fs.writeFileSync(path.join(poDir, 'web.ts'), 'export default class CheckoutPage {}');
+            // 2. Add step dynamically
+            const stepDir = path.join(tmpDir, 'support', 'steps', 'submitOrder');
+            fs.mkdirSync(stepDir, { recursive: true });
+            fs.writeFileSync(path.join(stepDir, 'web.step.ts'), 'export default async function submitOrder() {}');
+            // Poll until watcher updates web.d.ts
+            await waitForCondition(() => {
+                try {
+                    const webDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+                    return webDts.includes('declare const CheckoutPage:') && webDts.includes('"submitOrder":');
+                }
+                catch {
+                    return false;
+                }
+            });
+            const webDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+            expect(webDts).toContain('declare const CheckoutPage:');
+            expect(webDts).toContain('"submitOrder":');
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('dynamically purges types when a file is deleted during watch', async () => {
+        const poDir = path.join(tmpDir, 'page-objects', 'TemporaryPage');
+        fs.mkdirSync(poDir, { recursive: true });
+        const poFile = path.join(poDir, 'web.ts');
+        fs.writeFileSync(poFile, 'export default class TemporaryPage {}');
+        const handle = startWatcher(tmpDir, 30);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        try {
+            let webDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+            expect(webDts).toContain('declare const TemporaryPage:');
+            // Delete file during watch
+            fs.unlinkSync(poFile);
+            // Poll until watcher purges TemporaryPage from web.d.ts
+            await waitForCondition(() => {
+                try {
+                    const content = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+                    return !content.includes('TemporaryPage');
+                }
+                catch {
+                    return false;
+                }
+            });
+            webDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'web.d.ts'), 'utf-8');
+            expect(webDts).not.toContain('TemporaryPage');
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('dynamically generates strongly-typed fixture imports on new json file', async () => {
+        const handle = startWatcher(tmpDir, 30);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        try {
+            const fixturesDir = path.join(tmpDir, 'fixtures');
+            fs.mkdirSync(fixturesDir, { recursive: true });
+            fs.writeFileSync(path.join(fixturesDir, 'accountData.json'), JSON.stringify({ balance: 5000 }));
+            await waitForCondition(() => {
+                try {
+                    const fixturesDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'fixtures.d.ts'), 'utf-8');
+                    return fixturesDts.includes("readonly accountData: typeof import('../../fixtures/accountData.json');");
+                }
+                catch {
+                    return false;
+                }
+            });
+            const fixturesDts = fs.readFileSync(path.join(tmpDir, '.testspectra', 'types', 'fixtures.d.ts'), 'utf-8');
+            expect(fixturesDts).toContain("readonly accountData: typeof import('../../fixtures/accountData.json');");
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('ignores file changes in node_modules, .git, and .testspectra directories', async () => {
+        const handle = startWatcher(tmpDir, 30);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        try {
+            const gitDir = path.join(tmpDir, '.git');
+            fs.mkdirSync(gitDir, { recursive: true });
+            fs.writeFileSync(path.join(gitDir, 'HEAD'), 'ref: refs/heads/main');
+            const nodeModulesDir = path.join(tmpDir, 'node_modules', 'dummy');
+            fs.mkdirSync(nodeModulesDir, { recursive: true });
+            fs.writeFileSync(path.join(nodeModulesDir, 'package.json'), '{}');
+            // None of these should cause errors or corrupt generated types
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            const typesDir = path.join(tmpDir, '.testspectra', 'types');
+            expect(fs.existsSync(typesDir)).toBe(true);
+        }
+        finally {
+            handle.close();
+        }
+    });
+    it('invokes watchCommand CLI wrapper without throwing and closes cleanly', async () => {
+        const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        // Create a dummy page object
+        fs.mkdirSync(path.join(tmpDir, 'page-objects', 'HomePage'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, 'page-objects', 'HomePage', 'web.ts'), 'export default class HomePage {}');
+        // Run watchCommand with custom cwd
+        await watchCommand({ cwd: tmpDir, debounceMs: 30 });
+        const typesPath = path.join(tmpDir, '.testspectra', 'types', 'web.d.ts');
+        expect(fs.existsSync(typesPath)).toBe(true);
+        logSpy.mockRestore();
+    });
+});