@testspectra/cli 1.1.8-rc.9 → 1.1.11-rc.3

package/dist/commands/update.js

@@ -1,109 +0,0 @@
-import { execSync, execFileSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const PACKAGES = ['@testspectra/cli', '@testspectra/matchers'];
-function getLatestVersion(pkg) {
-    try {
-        const out = execFileSync('npm', ['view', pkg, 'version', '--json'], {
-            stdio: ['ignore', 'pipe', 'ignore'],
-            timeout: 10000,
-        })
-            .toString()
-            .trim()
-            .replace(/"/g, '');
-        return out || null;
-    }
-    catch {
-        return null;
-    }
-}
-function getCurrentVersion(pkg, cwd) {
-    // Walk up to find the installed version
-    let cur = path.resolve(cwd);
-    while (cur && cur !== path.dirname(cur)) {
-        const pkgJson = path.join(cur, 'node_modules', pkg, 'package.json');
-        if (fs.existsSync(pkgJson)) {
-            try {
-                const p = JSON.parse(fs.readFileSync(pkgJson, 'utf-8'));
-                return p.version ?? null;
-            }
-            catch { }
-        }
-        cur = path.dirname(cur);
-    }
-    return null;
-}
-function detectPackageManager(cwd) {
-    if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
-        return 'pnpm';
-    if (fs.existsSync(path.join(cwd, 'bun.lockb')) || fs.existsSync(path.join(cwd, 'bun.lock')))
-        return 'bun';
-    return 'npm';
-}
-function buildInstallCmd(pm, pkgSpecs) {
-    const list = pkgSpecs.join(' ');
-    switch (pm) {
-        case 'pnpm':
-            return `pnpm add -D ${list}`;
-        case 'bun':
-            return `bun add -d ${list}`;
-        case 'npm':
-        default:
-            return `npm install -D ${list}`;
-    }
-}
-export async function updateCommand(options = {}) {
-    const cwd = process.cwd();
-    const pm = detectPackageManager(cwd);
-    console.log('\x1b[36m┌  🔄 TestSpectra Self-Update\x1b[0m');
-    console.log('\x1b[36m│\x1b[0m');
-    console.log(`\x1b[36m│\x1b[0m  Package Manager: \x1b[33m${pm}\x1b[0m`);
-    console.log('\x1b[36m│\x1b[0m');
-    console.log('\x1b[36m│\x1b[0m  Fetching latest versions from npm registry...');
-    const updates = [];
-    for (const pkg of PACKAGES) {
-        const current = getCurrentVersion(pkg, cwd);
-        const latest = getLatestVersion(pkg);
-        const needsUpdate = !!latest && latest !== current;
-        updates.push({ pkg, current, latest, needsUpdate });
-        const currentStr = current ? `\x1b[33mv${current}\x1b[0m` : '\x1b[90m(not installed)\x1b[0m';
-        const latestStr = latest ? `\x1b[32mv${latest}\x1b[0m` : '\x1b[31m(unavailable)\x1b[0m';
-        const arrow = needsUpdate ? ` → ${latestStr}` : '';
-        const status = !latest ? '\x1b[31m✗\x1b[0m' : needsUpdate ? '\x1b[33m↑\x1b[0m' : '\x1b[32m✓\x1b[0m';
-        console.log(`\x1b[36m│\x1b[0m   ${status} ${pkg.padEnd(28)} ${currentStr}${arrow}`);
-    }
-    const toUpdate = updates.filter((u) => u.needsUpdate && u.latest);
-    console.log('\x1b[36m│\x1b[0m');
-    if (toUpdate.length === 0) {
-        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
-        console.log('\x1b[32m✓ All TestSpectra packages are already up-to-date!\x1b[0m\n');
-        return;
-    }
-    if (options.check) {
-        console.log(`\x1b[36m│\x1b[0m  \x1b[33m${toUpdate.length} update(s) available. Run \x1b[36mspectra update\x1b[33m to install.\x1b[0m`);
-        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m\n');
-        return;
-    }
-    const pkgSpecs = toUpdate.map((u) => `${u.pkg}@${u.latest}`);
-    const installCmd = buildInstallCmd(pm, pkgSpecs);
-    console.log(`\x1b[36m│\x1b[0m  Running: \x1b[90m${installCmd}\x1b[0m`);
-    console.log('\x1b[36m│\x1b[0m');
-    try {
-        execSync(installCmd, { cwd, stdio: 'inherit' });
-        console.log('\x1b[36m│\x1b[0m');
-        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
-        console.log('\x1b[32m🎉 TestSpectra updated successfully!\x1b[0m');
-        for (const u of toUpdate) {
-            console.log(`   \x1b[32m✓\x1b[0m ${u.pkg}: v${u.current ?? '?'} → v${u.latest}`);
-        }
-        console.log('');
-    }
-    catch (err) {
-        console.log('\x1b[36m└──────────────────────────────────────────────────────────\x1b[0m');
-        console.error(`\x1b[31m✗ Update failed: ${err.message}\x1b[0m\n`);
-        process.exit(1);
-    }
-}

package/dist/lifecycle/__tests__/lifecycle-engine.test.js

@@ -1,290 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { discoverGlobalHooks, discoverSuiteHooks } from '../hook-discovery.js';
-import { LifecycleDispatcher, HookExecutionError } from '../hook-dispatcher.js';
-import { calculateWorkerCount, groupSpecs } from '../parallel-grouping.js';
-describe('Core Lifecycle Execution Engine (docs/v2/cli/lifecycle-execution-engine.md)', () => {
-    let tmpDir;
-    beforeEach(() => {
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'testspectra-lifecycle-test-'));
-    });
-    afterEach(() => {
-        try {
-            fs.rmSync(tmpDir, { recursive: true, force: true });
-        }
-        catch { }
-    });
-    describe('Hook Discovery', () => {
-        it('discovers global-hooks and filters by platform hierarchy', () => {
-            const gBefore = path.join(tmpDir, 'global-hooks', 'before');
-            const gAfter = path.join(tmpDir, 'global-hooks', 'after');
-            fs.mkdirSync(gBefore, { recursive: true });
-            fs.mkdirSync(gAfter, { recursive: true });
-            fs.writeFileSync(path.join(gBefore, 'web.hook.ts'), 'export default async () => {}');
-            fs.writeFileSync(path.join(gBefore, 'mobile.hook.ts'), 'export default async () => {}');
-            fs.writeFileSync(path.join(gBefore, 'common.hook.ts'), 'export default async () => {}');
-            fs.writeFileSync(path.join(gAfter, 'web.hook.ts'), 'export default async () => {}');
-            const webGlobal = discoverGlobalHooks(tmpDir, 'web');
-            expect(webGlobal.before.some((h) => h.endsWith('web.hook.ts'))).toBe(true);
-            expect(webGlobal.before.some((h) => h.endsWith('common.hook.ts'))).toBe(true);
-            expect(webGlobal.before.some((h) => h.endsWith('mobile.hook.ts'))).toBe(false);
-            const mobileGlobal = discoverGlobalHooks(tmpDir, 'mobile');
-            expect(mobileGlobal.before.some((h) => h.endsWith('mobile.hook.ts'))).toBe(true);
-            expect(mobileGlobal.before.some((h) => h.endsWith('common.hook.ts'))).toBe(true);
-            expect(mobileGlobal.before.some((h) => h.endsWith('web.hook.ts'))).toBe(false);
-        });
-        it('discovers suite hooks (before, beforeEach, afterEach, after)', () => {
-            const suiteDir = path.join(tmpDir, 'specs', 'Auth');
-            for (const hookType of ['before', 'beforeEach', 'afterEach', 'after']) {
-                const hDir = path.join(suiteDir, 'hooks', hookType);
-                fs.mkdirSync(hDir, { recursive: true });
-                fs.writeFileSync(path.join(hDir, 'web.hook.ts'), 'export default async () => {}');
-            }
-            const suiteHooks = discoverSuiteHooks(suiteDir, 'web');
-            expect(suiteHooks.before.length).toBe(1);
-            expect(suiteHooks.beforeEach.length).toBe(1);
-            expect(suiteHooks.afterEach.length).toBe(1);
-            expect(suiteHooks.after.length).toBe(1);
-        });
-    });
-    describe('Lifecycle Dispatcher & Execution Flow', () => {
-        it('single run executes suite hooks without triggering global hooks', async () => {
-            const executionOrder = [];
-            const globalBeforeFn = vi.fn(async () => {
-                executionOrder.push('globalBefore');
-            });
-            const globalAfterFn = vi.fn(async () => {
-                executionOrder.push('globalAfter');
-            });
-            const suiteHooks = {
-                before: [
-                    async () => {
-                        executionOrder.push('suiteBefore');
-                    },
-                ],
-                beforeEach: [
-                    async () => {
-                        executionOrder.push('beforeEach');
-                    },
-                ],
-                afterEach: [
-                    async () => {
-                        executionOrder.push('afterEach');
-                    },
-                ],
-                after: [
-                    async () => {
-                        executionOrder.push('suiteAfter');
-                    },
-                ],
-            };
-            const dispatcher = new LifecycleDispatcher('single', {
-                before: [globalBeforeFn],
-                after: [globalAfterFn],
-            });
-            // Single run bypasses global before & global after
-            await dispatcher.runGlobalBefore();
-            expect(globalBeforeFn).not.toHaveBeenCalled();
-            const result = await dispatcher.executeSuite('AuthSuite', suiteHooks, [
-                {
-                    id: 'TC-01',
-                    title: 'Valid Login',
-                    fn: async () => {
-                        executionOrder.push('testBody');
-                    },
-                },
-            ]);
-            await dispatcher.runGlobalAfter();
-            expect(globalAfterFn).not.toHaveBeenCalled();
-            expect(result.status).toBe('PASSED');
-            expect(executionOrder).toEqual(['suiteBefore', 'beforeEach', 'testBody', 'afterEach', 'suiteAfter']);
-        });
-        it('global batch run executes global-hooks/before once at start and global-hooks/after once at finish', async () => {
-            const executionOrder = [];
-            const globalBeforeFn = vi.fn(async () => {
-                executionOrder.push('globalBefore');
-            });
-            const globalAfterFn = vi.fn(async () => {
-                executionOrder.push('globalAfter');
-            });
-            const dispatcher = new LifecycleDispatcher('global', {
-                before: [globalBeforeFn],
-                after: [globalAfterFn],
-            });
-            await dispatcher.runGlobalBefore();
-            expect(globalBeforeFn).toHaveBeenCalledTimes(1);
-            const suiteHooks = {
-                before: [
-                    async () => {
-                        executionOrder.push('suiteBefore');
-                    },
-                ],
-                beforeEach: [
-                    async () => {
-                        executionOrder.push('beforeEach');
-                    },
-                ],
-                afterEach: [
-                    async () => {
-                        executionOrder.push('afterEach');
-                    },
-                ],
-                after: [
-                    async () => {
-                        executionOrder.push('suiteAfter');
-                    },
-                ],
-            };
-            const result = await dispatcher.executeSuite('AuthSuite', suiteHooks, [
-                {
-                    id: 'TC-01',
-                    title: 'Test 1',
-                    fn: async () => {
-                        executionOrder.push('tc1');
-                    },
-                },
-                {
-                    id: 'TC-02',
-                    title: 'Test 2',
-                    fn: async () => {
-                        executionOrder.push('tc2');
-                    },
-                },
-            ]);
-            await dispatcher.runGlobalAfter();
-            expect(globalAfterFn).toHaveBeenCalledTimes(1);
-            expect(result.status).toBe('PASSED');
-            expect(executionOrder).toEqual([
-                'globalBefore',
-                'suiteBefore',
-                'beforeEach',
-                'tc1',
-                'afterEach',
-                'beforeEach',
-                'tc2',
-                'afterEach',
-                'suiteAfter',
-                'globalAfter',
-            ]);
-        });
-        it('when beforeEach fails, test body is skipped, afterEach is guaranteed to execute, and test is marked as ERROR', async () => {
-            const testBodyFn = vi.fn();
-            let afterEachRan = false;
-            const suiteHooks = {
-                before: [],
-                beforeEach: [
-                    async () => {
-                        throw new Error('Database connection failed in beforeEach');
-                    },
-                ],
-                afterEach: [
-                    async () => {
-                        afterEachRan = true;
-                    },
-                ],
-                after: [],
-            };
-            const dispatcher = new LifecycleDispatcher('single');
-            const result = await dispatcher.executeSuite('FailingBeforeEachSuite', suiteHooks, [
-                {
-                    id: 'TC-FAIL-01',
-                    title: 'Should be skipped',
-                    fn: testBodyFn,
-                },
-            ]);
-            expect(testBodyFn).not.toHaveBeenCalled();
-            expect(afterEachRan).toBe(true);
-            expect(result.results[0].status).toBe('ERROR');
-            expect(result.results[0].error?.message).toContain('Database connection failed in beforeEach');
-            expect(result.status).toBe('ERROR');
-        });
-        it('when afterEach fails, test transitions to ERROR status', async () => {
-            const suiteHooks = {
-                before: [],
-                beforeEach: [],
-                afterEach: [
-                    async () => {
-                        throw new Error('Teardown resource leak in afterEach');
-                    },
-                ],
-                after: [],
-            };
-            const dispatcher = new LifecycleDispatcher('single');
-            const result = await dispatcher.executeSuite('TeardownFailSuite', suiteHooks, [
-                {
-                    id: 'TC-01',
-                    title: 'Passing Body but failing afterEach',
-                    fn: async () => {
-                        // Passing body
-                    },
-                },
-            ]);
-            expect(result.results[0].status).toBe('ERROR');
-            expect(result.results[0].error?.message).toContain('Teardown resource leak in afterEach');
-            expect(result.status).toBe('ERROR');
-        });
-        it('when global-hooks/before fails, throws HookExecutionError immediately', async () => {
-            const dispatcher = new LifecycleDispatcher('global', {
-                before: [
-                    async () => {
-                        throw new Error('Global health check failed');
-                    },
-                ],
-                after: [],
-            });
-            await expect(dispatcher.runGlobalBefore()).rejects.toThrow(HookExecutionError);
-            await expect(dispatcher.runGlobalBefore()).rejects.toThrow('Global health check failed');
-        });
-    });
-    describe('Parallel Spec Grouping & Dynamic Worker Sizing', () => {
-        it('prioritizes explicit user concurrency flag over auto-calculation', () => {
-            const targets = Array.from({ length: 10 }, () => 'spec.ts');
-            expect(calculateWorkerCount(targets, { userConcurrency: 4 })).toBe(4);
-            // Clamps to item count if items < userConcurrency
-            expect(calculateWorkerCount(['only-one.ts'], { userConcurrency: 4 })).toBe(1);
-        });
-        it('enforces low-CPU safety ratio based on container/host CPU quota', () => {
-            const targets = Array.from({ length: 10 }, () => 'spec.ts');
-            const highRam = 16 * 1024 * 1024 * 1024; // 16 GB
-            // CPU <= 2 (e.g. 2-vCPU standard CI runner): clamped to 1 worker
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: 1, memoryBytesOverride: highRam })).toBe(1);
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: 2, memoryBytesOverride: highRam })).toBe(1);
-            // CPU 3 - 4: allocates 2 workers
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: 3, memoryBytesOverride: highRam })).toBe(2);
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: 4, memoryBytesOverride: highRam })).toBe(2);
-            // CPU > 4: allocates (cpu - 2) capped at maxWorkersCap (default 6)
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: 6, memoryBytesOverride: highRam })).toBe(4);
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: 8, memoryBytesOverride: highRam })).toBe(6);
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: 64, memoryBytesOverride: highRam })).toBe(6);
-        });
-        it('enforces memory-aware guard to prevent OOM kills during browser automation', () => {
-            const targets = Array.from({ length: 10 }, () => 'spec.ts');
-            const highCpu = 16;
-            // 500 MB RAM budget -> allows at most 1 worker (~600MB budget per browser)
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: highCpu, memoryBytesOverride: 500 * 1024 * 1024 })).toBe(1);
-            // 1.5 GB RAM budget -> allows 2 workers
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: highCpu, memoryBytesOverride: 1500 * 1024 * 1024 })).toBe(2);
-            // 2.5 GB RAM budget -> allows 4 workers
-            expect(calculateWorkerCount(targets, { cpuQuotaOverride: highCpu, memoryBytesOverride: 2500 * 1024 * 1024 })).toBe(4);
-        });
-        it('groups specs by suite directory in nested array format when mode is "suite"', () => {
-            const specs = [
-                'specs/Auth/TC-001/web.test.ts',
-                'specs/Auth/TC-002/web.test.ts',
-                'specs/Cart/TC-010/web.test.ts',
-                'specs/Cart/TC-011/web.test.ts',
-            ];
-            const grouped = groupSpecs(specs, 'suite');
-            expect(grouped.length).toBe(2);
-            expect(grouped[0]).toEqual(['specs/Auth/TC-001/web.test.ts', 'specs/Auth/TC-002/web.test.ts']);
-            expect(grouped[1]).toEqual(['specs/Cart/TC-010/web.test.ts', 'specs/Cart/TC-011/web.test.ts']);
-        });
-        it('flattens specs when mode is "testcase"', () => {
-            const specs = ['specs/Auth/TC-001/web.test.ts', 'specs/Auth/TC-002/web.test.ts', 'specs/Cart/TC-010/web.test.ts'];
-            const flat = groupSpecs(specs, 'testcase');
-            expect(flat).toEqual(specs);
-        });
-    });
-});

package/dist/lifecycle/hook-discovery.d.ts

@@ -1,24 +0,0 @@
-import { PlatformTarget } from '../generator/type-generator.js';
-export type HookEntry = string | (() => Promise<void> | void);
-export interface DiscoveredSuiteHooks {
-    before: string[];
-    beforeEach: string[];
-    afterEach: string[];
-    after: string[];
-}
-export interface DiscoveredGlobalHooks {
-    before: string[];
-    after: string[];
-}
-export interface SuiteHooks {
-    before: HookEntry[];
-    beforeEach: HookEntry[];
-    afterEach: HookEntry[];
-    after: HookEntry[];
-}
-export interface GlobalHooks {
-    before: HookEntry[];
-    after: HookEntry[];
-}
-export declare function discoverGlobalHooks(cwd: string, platform?: PlatformTarget): DiscoveredGlobalHooks;
-export declare function discoverSuiteHooks(suiteDir: string, platform?: PlatformTarget): DiscoveredSuiteHooks;

package/dist/lifecycle/hook-discovery.js

@@ -1,60 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { PLATFORM_HIERARCHY } from '../generator/type-generator.js';
-function resolveHookFilesForType(dir, platform = 'web') {
-    if (!fs.existsSync(dir))
-        return [];
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const hierarchy = PLATFORM_HIERARCHY[platform] || ['common'];
-    const matched = [];
-    // Group files by base name if applicable or collect directly
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.hook.ts'))
-            continue;
-        const parts = entry.name.split('.');
-        // Formats:
-        // 1. web.hook.ts -> parts = ['web', 'hook', 'ts']
-        // 2. auth.web.hook.ts -> parts = ['auth', 'web', 'hook', 'ts']
-        // 3. auth.hook.ts -> parts = ['auth', 'hook', 'ts']
-        let filePlatform = 'common';
-        if (parts.length === 3) {
-            filePlatform = parts[0];
-        }
-        else if (parts.length >= 4) {
-            filePlatform = parts[parts.length - 3];
-        }
-        if (hierarchy.includes(filePlatform) || filePlatform === 'common') {
-            matched.push(path.join(dir, entry.name));
-        }
-    }
-    // Sort by hierarchy priority
-    matched.sort((a, b) => {
-        const getPriority = (filePath) => {
-            const base = path.basename(filePath);
-            for (let i = 0; i < hierarchy.length; i++) {
-                if (base.includes(`.${hierarchy[i]}.`) || base.startsWith(`${hierarchy[i]}.`)) {
-                    return i;
-                }
-            }
-            return hierarchy.length;
-        };
-        return getPriority(a) - getPriority(b);
-    });
-    return matched;
-}
-export function discoverGlobalHooks(cwd, platform = 'web') {
-    const globalHooksDir = path.join(cwd, 'global-hooks');
-    return {
-        before: resolveHookFilesForType(path.join(globalHooksDir, 'before'), platform),
-        after: resolveHookFilesForType(path.join(globalHooksDir, 'after'), platform),
-    };
-}
-export function discoverSuiteHooks(suiteDir, platform = 'web') {
-    const hooksDir = path.join(suiteDir, 'hooks');
-    return {
-        before: resolveHookFilesForType(path.join(hooksDir, 'before'), platform),
-        beforeEach: resolveHookFilesForType(path.join(hooksDir, 'beforeEach'), platform),
-        afterEach: resolveHookFilesForType(path.join(hooksDir, 'afterEach'), platform),
-        after: resolveHookFilesForType(path.join(hooksDir, 'after'), platform),
-    };
-}

package/dist/lifecycle/hook-dispatcher.d.ts

@@ -1,34 +0,0 @@
-import { SuiteHooks, GlobalHooks } from './hook-discovery.js';
-export type TestCaseStatus = 'PASSED' | 'FAILED' | 'SKIPPED' | 'ERROR';
-export interface TestCaseResult {
-    id: string;
-    title: string;
-    status: TestCaseStatus;
-    error?: Error;
-    durationMs: number;
-}
-export interface SuiteExecutionResult {
-    suiteName: string;
-    results: TestCaseResult[];
-    status: 'PASSED' | 'FAILED' | 'ERROR';
-    error?: Error;
-}
-export type HookFn = () => Promise<void> | void;
-export declare class HookExecutionError extends Error {
-    phase: 'before' | 'beforeEach' | 'afterEach' | 'after' | 'globalBefore' | 'globalAfter';
-    originalError: any;
-    constructor(phase: 'before' | 'beforeEach' | 'afterEach' | 'after' | 'globalBefore' | 'globalAfter', originalError: any);
-}
-export declare function runHook(hookPathOrFn: string | HookFn, timeoutMs?: number): Promise<void>;
-export declare class LifecycleDispatcher {
-    mode: 'single' | 'global';
-    globalHooks: GlobalHooks;
-    constructor(mode?: 'single' | 'global', globalHooks?: GlobalHooks);
-    runGlobalBefore(): Promise<void>;
-    runGlobalAfter(): Promise<void>;
-    executeSuite(suiteName: string, suiteHooks: SuiteHooks, testCases: Array<{
-        id: string;
-        title: string;
-        fn: () => Promise<void>;
-    }>): Promise<SuiteExecutionResult>;
-}