@testspectra/cli 1.0.70 → 1.1.0-rc.1

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

@@ -0,0 +1,34 @@
+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>;
+}

package/dist/lifecycle/hook-dispatcher.js

@@ -0,0 +1,190 @@
+import { pathToFileURL } from 'url';
+export class HookExecutionError extends Error {
+    phase;
+    originalError;
+    constructor(phase, originalError) {
+        super(`Hook failure during [${phase}]: ${originalError?.message || String(originalError)}`);
+        this.phase = phase;
+        this.originalError = originalError;
+        this.name = 'HookExecutionError';
+    }
+}
+export async function runHook(hookPathOrFn, timeoutMs = 10000) {
+    let fn;
+    if (typeof hookPathOrFn === 'function') {
+        fn = hookPathOrFn;
+    }
+    else {
+        try {
+            const fileUrl = pathToFileURL(hookPathOrFn).href;
+            const mod = await import(fileUrl);
+            fn = mod.default || mod;
+            if (typeof fn !== 'function') {
+                throw new Error(`Hook file ${hookPathOrFn} does not export a default function`);
+            }
+        }
+        catch (err) {
+            throw new Error(`Failed to load hook from ${hookPathOrFn}: ${err.message}`);
+        }
+    }
+    let timeoutId = null;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(new Error(`Hook execution timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    try {
+        await Promise.race([Promise.resolve(fn()), timeoutPromise]);
+    }
+    finally {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    }
+}
+export class LifecycleDispatcher {
+    mode;
+    globalHooks;
+    constructor(mode = 'single', globalHooks = { before: [], after: [] }) {
+        this.mode = mode;
+        this.globalHooks = globalHooks;
+    }
+    async runGlobalBefore() {
+        if (this.mode !== 'global')
+            return;
+        for (const hook of this.globalHooks.before) {
+            try {
+                await runHook(hook);
+            }
+            catch (err) {
+                throw new HookExecutionError('globalBefore', err);
+            }
+        }
+    }
+    async runGlobalAfter() {
+        if (this.mode !== 'global')
+            return;
+        let firstError = null;
+        for (const hook of this.globalHooks.after) {
+            try {
+                await runHook(hook);
+            }
+            catch (err) {
+                if (!firstError)
+                    firstError = err;
+            }
+        }
+        if (firstError) {
+            throw new HookExecutionError('globalAfter', firstError);
+        }
+    }
+    async executeSuite(suiteName, suiteHooks, testCases) {
+        const results = [];
+        let suiteLevelError;
+        // 1. Run suite before hook
+        let beforeSuiteFailed = false;
+        for (const hook of suiteHooks.before) {
+            try {
+                await runHook(hook);
+            }
+            catch (err) {
+                beforeSuiteFailed = true;
+                suiteLevelError = new HookExecutionError('before', err);
+                break;
+            }
+        }
+        if (beforeSuiteFailed) {
+            // All test cases in suite are skipped / marked ERROR
+            for (const tc of testCases) {
+                results.push({
+                    id: tc.id,
+                    title: tc.title,
+                    status: 'ERROR',
+                    error: suiteLevelError,
+                    durationMs: 0,
+                });
+            }
+            // Always execute suite after hook even on before failure
+            for (const hook of suiteHooks.after) {
+                try {
+                    await runHook(hook);
+                }
+                catch { }
+            }
+            return {
+                suiteName,
+                results,
+                status: 'ERROR',
+                error: suiteLevelError,
+            };
+        }
+        // 2. Run each test case with beforeEach and afterEach
+        for (const tc of testCases) {
+            const startTime = Date.now();
+            let tcStatus = 'PASSED';
+            let tcError;
+            let beforeEachFailed = false;
+            // Run beforeEach hooks
+            for (const hook of suiteHooks.beforeEach) {
+                try {
+                    await runHook(hook);
+                }
+                catch (err) {
+                    beforeEachFailed = true;
+                    tcStatus = 'ERROR';
+                    tcError = new HookExecutionError('beforeEach', err);
+                    break;
+                }
+            }
+            // Run test body if beforeEach passed
+            if (!beforeEachFailed) {
+                try {
+                    await tc.fn();
+                    tcStatus = 'PASSED';
+                }
+                catch (err) {
+                    tcStatus = 'FAILED';
+                    tcError = err instanceof Error ? err : new Error(String(err));
+                }
+            }
+            // afterEach is GUARANTEED to execute even if beforeEach or test body failed
+            for (const hook of suiteHooks.afterEach) {
+                try {
+                    await runHook(hook);
+                }
+                catch (err) {
+                    // If test passed or failed, an afterEach failure transitions it to ERROR (Teardown Failure)
+                    tcStatus = 'ERROR';
+                    if (!tcError) {
+                        tcError = new HookExecutionError('afterEach', err);
+                    }
+                }
+            }
+            results.push({
+                id: tc.id,
+                title: tc.title,
+                status: tcStatus,
+                error: tcError,
+                durationMs: Date.now() - startTime,
+            });
+        }
+        // 3. Run suite after hook
+        for (const hook of suiteHooks.after) {
+            try {
+                await runHook(hook);
+            }
+            catch (err) {
+                if (!suiteLevelError) {
+                    suiteLevelError = new HookExecutionError('after', err);
+                }
+            }
+        }
+        const hasErrors = results.some((r) => r.status === 'ERROR') || !!suiteLevelError;
+        const hasFailures = results.some((r) => r.status === 'FAILED');
+        return {
+            suiteName,
+            results,
+            status: hasErrors ? 'ERROR' : hasFailures ? 'FAILED' : 'PASSED',
+            error: suiteLevelError,
+        };
+    }
+}

package/dist/lifecycle/index.d.ts

@@ -0,0 +1,3 @@
+export * from './hook-discovery.js';
+export * from './hook-dispatcher.js';
+export * from './parallel-grouping.js';

package/dist/lifecycle/index.js

@@ -0,0 +1,3 @@
+export * from './hook-discovery.js';
+export * from './hook-dispatcher.js';
+export * from './parallel-grouping.js';

package/dist/lifecycle/parallel-grouping.d.ts

@@ -0,0 +1,27 @@
+export type ParallelizationMode = 'suite' | 'testcase';
+export interface WorkerSizingOptions {
+    maxWorkersCap?: number;
+    userConcurrency?: number;
+    cpuQuotaOverride?: number;
+    memoryBytesOverride?: number;
+}
+/**
+ * Detects actual CPU quota available to the process, accounting for
+ * Docker and Kubernetes cgroup v1 and cgroup v2 container limits.
+ */
+export declare function detectContainerCpuQuota(): number;
+/**
+ * Detects available memory in bytes, respecting container cgroup memory limits
+ * to prevent Linux OOM (Out of Memory) kills.
+ */
+export declare function detectAvailableMemoryBytes(): number;
+/**
+ * Dynamically computes optimal worker concurrency respecting:
+ * 1. Explicit user concurrency flag (--concurrency <N> or config)
+ * 2. Real container cgroups CPU quota & host CPU count
+ * 3. Low-CPU safety ratio (clamping <=2 CPUs to 1 worker, 3-4 CPUs to 2 workers)
+ * 4. Memory-aware guard (~600MB RAM budget per Chromium instance to prevent OOM kills)
+ * 5. Target items count & maximum worker cap
+ */
+export declare function calculateWorkerCount(targetItems: any[], options?: WorkerSizingOptions | number): number;
+export declare function groupSpecs(specPaths: string[], mode?: ParallelizationMode): (string | string[])[];

package/dist/lifecycle/parallel-grouping.js

@@ -0,0 +1,151 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+/**
+ * Detects actual CPU quota available to the process, accounting for
+ * Docker and Kubernetes cgroup v1 and cgroup v2 container limits.
+ */
+export function detectContainerCpuQuota() {
+    try {
+        // 1. Check cgroup v2 (Unified Hierarchy): /sys/fs/cgroup/cpu.max
+        // Format: "<quota> <period>" e.g. "200000 100000" or "max 100000"
+        if (fs.existsSync('/sys/fs/cgroup/cpu.max')) {
+            const content = fs.readFileSync('/sys/fs/cgroup/cpu.max', 'utf-8').trim();
+            const [quotaStr, periodStr] = content.split(/\s+/);
+            if (quotaStr && quotaStr !== 'max' && periodStr) {
+                const quota = parseFloat(quotaStr);
+                const period = parseFloat(periodStr);
+                if (quota > 0 && period > 0) {
+                    return Math.max(0.5, quota / period);
+                }
+            }
+        }
+        // 2. Check cgroup v1: /sys/fs/cgroup/cpu/cpu.cfs_quota_us and cpu.cfs_period_us
+        if (fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us') && fs.existsSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us')) {
+            const quota = parseFloat(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'utf-8').trim());
+            const period = parseFloat(fs.readFileSync('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'utf-8').trim());
+            if (quota > 0 && period > 0) {
+                return Math.max(0.5, quota / period);
+            }
+        }
+    }
+    catch { }
+    // 3. Fallback to host CPU count
+    if (typeof os.availableParallelism === 'function') {
+        try {
+            return os.availableParallelism();
+        }
+        catch { }
+    }
+    return os.cpus()?.length || 2;
+}
+/**
+ * Detects available memory in bytes, respecting container cgroup memory limits
+ * to prevent Linux OOM (Out of Memory) kills.
+ */
+export function detectAvailableMemoryBytes() {
+    try {
+        // 1. Check cgroup v2: /sys/fs/cgroup/memory.max and /sys/fs/cgroup/memory.current
+        if (fs.existsSync('/sys/fs/cgroup/memory.max')) {
+            const maxStr = fs.readFileSync('/sys/fs/cgroup/memory.max', 'utf-8').trim();
+            if (maxStr !== 'max') {
+                const limit = parseFloat(maxStr);
+                let usage = 0;
+                if (fs.existsSync('/sys/fs/cgroup/memory.current')) {
+                    usage = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory.current', 'utf-8').trim()) || 0;
+                }
+                if (limit > 0) {
+                    return Math.max(0, limit - usage);
+                }
+            }
+        }
+        // 2. Check cgroup v1: /sys/fs/cgroup/memory/memory.limit_in_bytes
+        if (fs.existsSync('/sys/fs/cgroup/memory/memory.limit_in_bytes')) {
+            const limit = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'utf-8').trim());
+            // cgroup v1 sets a huge number (e.g. 9223372036854771712) when no limit is enforced
+            if (limit > 0 && limit < 1e15) {
+                let usage = 0;
+                if (fs.existsSync('/sys/fs/cgroup/memory/memory.usage_in_bytes')) {
+                    usage = parseFloat(fs.readFileSync('/sys/fs/cgroup/memory/memory.usage_in_bytes', 'utf-8').trim()) || 0;
+                }
+                return Math.max(0, limit - usage);
+            }
+        }
+    }
+    catch { }
+    // 3. Fallback to host available memory (estimating reclaimable cache/buffer on modern OS)
+    try {
+        const free = os.freemem();
+        const total = os.totalmem();
+        return Math.max(free, total * 0.4);
+    }
+    catch {
+        return 1024 * 1024 * 1024; // 1 GB fallback
+    }
+}
+/**
+ * Dynamically computes optimal worker concurrency respecting:
+ * 1. Explicit user concurrency flag (--concurrency <N> or config)
+ * 2. Real container cgroups CPU quota & host CPU count
+ * 3. Low-CPU safety ratio (clamping <=2 CPUs to 1 worker, 3-4 CPUs to 2 workers)
+ * 4. Memory-aware guard (~600MB RAM budget per Chromium instance to prevent OOM kills)
+ * 5. Target items count & maximum worker cap
+ */
+export function calculateWorkerCount(targetItems, options) {
+    const opts = typeof options === 'number' ? { maxWorkersCap: options } : options || {};
+    const itemCount = targetItems.length;
+    if (itemCount === 0)
+        return 1;
+    // 1. Explicit User Concurrency has absolute priority
+    if (opts.userConcurrency && opts.userConcurrency > 0) {
+        return Math.min(opts.userConcurrency, itemCount);
+    }
+    // 2. Determine CPU Quota (cgroups aware)
+    const cpuCount = opts.cpuQuotaOverride !== undefined ? opts.cpuQuotaOverride : detectContainerCpuQuota();
+    // 3. Low-CPU Safety Ratio:
+    // - CPU <= 2: Max 1 worker (prevents severe thrashing on 2-vCPU CI runners)
+    // - CPU 3-4: Max 2 workers
+    // - CPU > 4: cpuCount - 2 (leaves 2 cores for OS/IDE/DevTools)
+    let cpuBasedWorkers = 1;
+    if (cpuCount <= 2) {
+        cpuBasedWorkers = 1;
+    }
+    else if (cpuCount <= 4) {
+        cpuBasedWorkers = 2;
+    }
+    else {
+        cpuBasedWorkers = Math.max(1, Math.floor(cpuCount - 2));
+    }
+    // 4. Memory-Aware Guard (Anti-OOM):
+    // Allocate ~600MB per Chromium browser instance
+    const MEMORY_PER_WORKER_BYTES = 600 * 1024 * 1024;
+    const availableMemBytes = opts.memoryBytesOverride !== undefined ? opts.memoryBytesOverride : detectAvailableMemoryBytes();
+    const memBasedWorkers = Math.max(1, Math.floor(availableMemBytes / MEMORY_PER_WORKER_BYTES));
+    // 5. Apply Maximum Cap and Item Count Clamping
+    const maxCap = opts.maxWorkersCap || 6;
+    return Math.max(1, Math.min(cpuBasedWorkers, memBasedWorkers, maxCap, itemCount));
+}
+export function groupSpecs(specPaths, mode = 'suite') {
+    if (mode === 'testcase') {
+        return [...specPaths];
+    }
+    // Group by suite directory
+    const suiteGroups = new Map();
+    for (const specPath of specPaths) {
+        const normalized = specPath.replace(/\\/g, '/');
+        const parts = normalized.split('/');
+        let suiteKey = 'default';
+        const specsIdx = parts.findIndex((p) => p === 'specs' || p === 'suites');
+        if (specsIdx !== -1 && specsIdx + 1 < parts.length) {
+            suiteKey = parts.slice(0, specsIdx + 2).join('/');
+        }
+        else {
+            suiteKey = path.dirname(normalized);
+        }
+        if (!suiteGroups.has(suiteKey)) {
+            suiteGroups.set(suiteKey, []);
+        }
+        suiteGroups.get(suiteKey).push(specPath);
+    }
+    return Array.from(suiteGroups.values());
+}

package/dist/linter/__tests__/anonymous-export.test.d.ts

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

package/dist/linter/__tests__/anonymous-export.test.js

@@ -0,0 +1,184 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { extractModuleExports } from '../extractor.js';
+import { SpecLinter } from '../spec-linter.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+describe('Anonymous Default Export (testspectra/require-anonymous-default-export)', () => {
+    const tempDir = path.join(__dirname, '__temp_anonymous_export__');
+    beforeEach(() => {
+        fs.mkdirSync(tempDir, { recursive: true });
+    });
+    afterEach(() => {
+        if (fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('extractModuleExports()', () => {
+        it('detects valid anonymous async default export in .step.ts', () => {
+            const code = `export default async function () {
+  await LoginPage.open();
+}`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(true);
+            expect(result.hasNamedExports).toBe(false);
+            expect(result.testBlocks).toHaveLength(0);
+        });
+        it('detects valid anonymous async arrow function default export in .step.ts', () => {
+            const code = `export default async () => {
+  await LoginPage.open();
+};`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(true);
+            expect(result.hasNamedExports).toBe(false);
+        });
+        it('detects named function with export default (forbidden)', () => {
+            const code = `export default async function login() {
+  await LoginPage.open();
+}`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(false);
+            expect(result.hasNamedExports).toBe(true);
+            expect(result.namedExportLines).toHaveLength(1);
+            expect(result.namedExportLines[0].name).toBe('login');
+            expect(result.namedExportLines[0].line).toBe(1);
+        });
+        it('detects named export function (forbidden)', () => {
+            const code = `export async function verifyUser() {
+  await UserPage.verify();
+}`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(false);
+            expect(result.hasNamedExports).toBe(true);
+            expect(result.namedExportLines[0].name).toBe('verifyUser');
+        });
+        it('detects named export class (forbidden)', () => {
+            const code = `export class Helper {}`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(false);
+            expect(result.hasNamedExports).toBe(true);
+            expect(result.namedExportLines[0].name).toBe('Helper');
+        });
+        it('detects export { ... } clauses (forbidden)', () => {
+            const code = `const a = 1; export { a };`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(false);
+            expect(result.hasNamedExports).toBe(true);
+            expect(result.namedExportLines[0].name).toBe('a');
+        });
+        it('detects named arrow function with export default (forbidden)', () => {
+            const code = `const fn = async () => {}; export default async function named() {}`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(false);
+            expect(result.hasNamedExports).toBe(true);
+        });
+        it('detects valid anonymous async default export in .action.ts', () => {
+            const code = `export default async function (email: string) {
+  await this.get("#email").type(email);
+}`;
+            const result = extractModuleExports(code, 'web.action.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(true);
+            expect(result.hasNamedExports).toBe(false);
+        });
+        it('detects valid anonymous async default export in .hook.ts', () => {
+            const code = `export default async function () {}`;
+            const result = extractModuleExports(code, 'web.hook.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(true);
+            expect(result.hasNamedExports).toBe(false);
+        });
+        it('detects missing default export', () => {
+            const code = `function verifyLogin() {
+  await LoginPage.open();
+}`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(false);
+        });
+        it('detects non-async default export as invalid', () => {
+            const code = `export default function verifyLogin() {
+  console.log("hello");
+}`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.hasAnonymousAsyncDefaultExport).toBe(false);
+        });
+        it('detects forbidden it() and describe() blocks in shared module', () => {
+            const code = `export default async function () {}
+it("test block", async () => {});
+describe("suite block", () => {});
+`;
+            const result = extractModuleExports(code, 'web.step.ts');
+            expect(result.testBlocks).toHaveLength(2);
+            expect(result.testBlocks[0].name).toBe('it');
+            expect(result.testBlocks[1].name).toBe('describe');
+        });
+    });
+    describe('testspectra/require-anonymous-default-export workspace validation', () => {
+        it('emits testspectra/require-anonymous-default-export when shared step lacks anonymous async default export', () => {
+            const stepsDir = path.join(tempDir, 'shared', 'testing', 'support', 'steps', 'login');
+            fs.mkdirSync(stepsDir, { recursive: true });
+            fs.writeFileSync(path.join(stepsDir, 'web.step.ts'), `function verifyLogin() {
+  console.log("no export");
+}
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/require-anonymous-default-export');
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+            expect(errors[0].message).toContain('anonymous async function as default export');
+        });
+        it('passes validation when shared step has valid anonymous async default export', () => {
+            const stepsDir = path.join(tempDir, 'shared', 'testing', 'support', 'steps', 'login');
+            fs.mkdirSync(stepsDir, { recursive: true });
+            fs.writeFileSync(path.join(stepsDir, 'web.step.ts'), `export default async function () {
+  await LoginPage.open();
+}
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/require-anonymous-default-export');
+            expect(errors).toHaveLength(0);
+        });
+        it('emits testspectra/require-anonymous-default-export when shared action has named exports', () => {
+            const actionsDir = path.join(tempDir, 'shared', 'testing', 'support', 'actions', 'fillForm');
+            fs.mkdirSync(actionsDir, { recursive: true });
+            fs.writeFileSync(path.join(actionsDir, 'web.action.ts'), `export default async function () {}
+export function helper() {}
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/require-anonymous-default-export');
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+            expect(errors.some((d) => d.message.includes('Named export'))).toBe(true);
+        });
+        it('emits testspectra/require-anonymous-default-export when shared hook has test blocks', () => {
+            const hooksDir = path.join(tempDir, 'shared', 'testing', 'global-hooks', 'before');
+            fs.mkdirSync(hooksDir, { recursive: true });
+            fs.writeFileSync(path.join(hooksDir, 'web.hook.ts'), `export default async function () {}
+it("should run", async () => {});
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/require-anonymous-default-export');
+            expect(errors.length).toBeGreaterThanOrEqual(1);
+            expect(errors.some((d) => d.message.includes('it() block is forbidden'))).toBe(true);
+        });
+        it('does NOT emit testspectra/require-anonymous-default-export for valid shared step files', () => {
+            const stepsDir = path.join(tempDir, 'shared', 'testing', 'support', 'steps', 'verify');
+            fs.mkdirSync(stepsDir, { recursive: true });
+            fs.writeFileSync(path.join(stepsDir, 'web.step.ts'), `export default async function () {
+  await Page.open();
+  await Page.element.should("be.visible");
+}
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/require-anonymous-default-export');
+            expect(errors).toHaveLength(0);
+        });
+        it('does NOT emit testspectra/require-anonymous-default-export for files outside shared/ directory', () => {
+            const featureDir = path.join(tempDir, 'packages', 'playground', 'e2e');
+            fs.mkdirSync(featureDir, { recursive: true });
+            fs.writeFileSync(path.join(featureDir, 'helper.ts'), `export function helper() {}
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/require-anonymous-default-export');
+            expect(errors).toHaveLength(0);
+        });
+    });
+});

package/dist/linter/__tests__/component-test-imports.test.d.ts

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