qa360 2.2.1 → 2.2.7

package/cli/dist/core/discoverer/index.js

@@ -0,0 +1,250 @@
+/**
+ * QA360 Test Discoverer
+ *
+ * Automatically discovers and categorizes test files in a project.
+ * Supports Playwright, K6, Cypress, and other test frameworks.
+ */
+import { stat } from 'fs/promises';
+import { relative } from 'path';
+import { glob } from 'glob';
+/**
+ * Test Discoverer
+ *
+ * Scans a project directory for test files and categorizes them
+ * by framework and type.
+ */
+export class TestDiscoverer {
+    rootDir;
+    defaultPatterns;
+    // Default test patterns
+    DEFAULT_PATTERNS = [
+        'tests/**/*',
+        'test/**/*',
+        '**/*.spec.ts',
+        '**/*.spec.js',
+        '**/*.test.ts',
+        '**/*.test.js',
+        '**/__tests__/**/*',
+    ];
+    // Default exclusions
+    DEFAULT_EXCLUDES = [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/.next/**',
+        '**/.nuxt/**',
+        '**/coverage/**',
+        '**/*.d.ts',
+    ];
+    constructor(options = {}) {
+        this.rootDir = options.rootDir || process.cwd();
+        this.defaultPatterns = options.patterns || this.DEFAULT_PATTERNS;
+    }
+    /**
+     * Discover all test files in the project
+     */
+    async discover() {
+        const files = await this.findTestFiles();
+        const categorized = {
+            playwright: [],
+            k6: [],
+            cypress: [],
+            jest: [],
+            vitest: [],
+            other: [],
+        };
+        for (const file of files) {
+            const category = this.categorizeFile(file);
+            categorized[category].push(file);
+        }
+        return categorized;
+    }
+    /**
+     * Find all test files using glob patterns
+     */
+    async findTestFiles() {
+        const files = await glob(this.defaultPatterns, {
+            cwd: this.rootDir,
+            absolute: true,
+            ignore: this.DEFAULT_EXCLUDES,
+        });
+        const results = [];
+        for (const filePath of files) {
+            const statResult = await stat(filePath).catch(() => null);
+            if (!statResult?.isFile())
+                continue;
+            results.push({
+                path: filePath,
+                type: this.detectType(filePath),
+                framework: this.detectFramework(filePath),
+                relativePath: relative(this.rootDir, filePath),
+            });
+        }
+        return results;
+    }
+    /**
+     * Categorize a file into a test category
+     */
+    categorizeFile(file) {
+        switch (file.framework) {
+            case 'playwright':
+                return 'playwright';
+            case 'k6':
+                return 'k6';
+            case 'cypress':
+                return 'cypress';
+            case 'jest':
+                return 'jest';
+            case 'vitest':
+                return 'vitest';
+            default:
+                return 'other';
+        }
+    }
+    /**
+     * Detect the test framework from file path and content
+     */
+    detectFramework(filePath) {
+        const path = filePath.toLowerCase();
+        // Check by path patterns first
+        if (path.includes('playwright') || path.endsWith('.spec.ts') || path.endsWith('.spec.js')) {
+            return 'playwright';
+        }
+        if (path.includes('k6') || path.includes('perf') || path.includes('load')) {
+            return 'k6';
+        }
+        if (path.includes('cypress') || path.includes('.cy.')) {
+            return 'cypress';
+        }
+        if (path.includes('vitest')) {
+            return 'vitest';
+        }
+        if (path.includes('__tests__') || path.includes('.test.')) {
+            return 'jest';
+        }
+        return 'unknown';
+    }
+    /**
+     * Detect the type of test (api, ui, perf, etc.)
+     */
+    detectType(filePath) {
+        const path = filePath.toLowerCase();
+        const name = filePath.toLowerCase();
+        // Detect by directory/file name
+        if (name.includes('api') || name.includes('endpoint')) {
+            return 'api';
+        }
+        if (name.includes('ui') || name.includes('e2e') || name.includes('ui-e2e')) {
+            return 'e2e';
+        }
+        if (name.includes('perf') || name.includes('performance') || name.includes('load')) {
+            return 'perf';
+        }
+        if (name.includes('security') || name.includes('sast')) {
+            return 'sast';
+        }
+        if (name.includes('a11y') || name.includes('accessibility')) {
+            return 'a11y';
+        }
+        if (name.includes('unit')) {
+            return 'unit';
+        }
+        if (name.includes('integration')) {
+            return 'integration';
+        }
+        // Default for framework-specific conventions
+        const framework = this.detectFramework(filePath);
+        switch (framework) {
+            case 'k6':
+                return 'perf';
+            case 'cypress':
+                return 'e2e';
+            default:
+                return 'unit';
+        }
+    }
+    /**
+     * Route a test file to the appropriate QA360 adapter
+     */
+    routeToAdapter(test) {
+        switch (test.framework) {
+            case 'playwright':
+                if (test.type === 'api') {
+                    return { adapter: 'playwright-api' };
+                }
+                return { adapter: 'playwright-ui' };
+            case 'k6':
+                return { adapter: 'k6-perf', config: { testType: test.type } };
+            case 'cypress':
+                return { adapter: 'cypress-ui' };
+            default:
+                return { adapter: 'generic', config: { testPath: test.path } };
+        }
+    }
+    /**
+     * Discover tests for a specific gate
+     */
+    async discoverForGate(gate) {
+        const allTests = await this.discover();
+        switch (gate) {
+            case 'api_smoke':
+                return [
+                    ...allTests.playwright.filter(t => t.type === 'api'),
+                    ...allTests.jest.filter(t => t.type === 'api'),
+                    ...allTests.vitest.filter(t => t.type === 'api'),
+                ];
+            case 'ui':
+            case 'e2e':
+                return [
+                    ...allTests.playwright.filter(t => t.type === 'e2e' || t.type === 'ui'),
+                    ...allTests.cypress.filter(t => t.type === 'e2e'),
+                ];
+            case 'perf':
+                return allTests.k6;
+            case 'security':
+            case 'sast':
+                return [
+                    ...allTests.playwright.filter(t => t.path.includes('security')),
+                    ...allTests.other.filter(t => t.type === 'sast'),
+                ];
+            default:
+                return [];
+        }
+    }
+    /**
+     * Get summary statistics of discovered tests
+     */
+    async getSummary() {
+        const tests = await this.discover();
+        return {
+            total: this.countAll(tests),
+            byFramework: {
+                playwright: tests.playwright.length,
+                k6: tests.k6.length,
+                cypress: tests.cypress.length,
+                jest: tests.jest.length,
+                vitest: tests.vitest.length,
+                other: tests.other.length,
+            },
+            byType: this.countByType(tests),
+        };
+    }
+    countAll(tests) {
+        return Object.values(tests).reduce((sum, arr) => sum + arr.length, 0);
+    }
+    countByType(tests) {
+        const counts = {};
+        for (const category of Object.values(tests)) {
+            for (const test of category) {
+                counts[test.type] = (counts[test.type] || 0) + 1;
+            }
+        }
+        return counts;
+    }
+}
+/**
+ * Create a test discoverer
+ */
+export function createTestDiscoverer(options) {
+    return new TestDiscoverer(options);
+}

package/cli/dist/core/fixtures/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * QA360 Data Fixtures System
+ *
+ * Exports all fixture-related functionality.
+ */
+export * from './types.js';
+export * from './loader.js';
+export * from './resolver.js';

package/cli/dist/core/fixtures/index.js

@@ -0,0 +1,8 @@
+/**
+ * QA360 Data Fixtures System
+ *
+ * Exports all fixture-related functionality.
+ */
+export * from './types.js';
+export * from './loader.js';
+export * from './resolver.js';

package/cli/dist/core/fixtures/loader.d.ts

@@ -0,0 +1,65 @@
+/**
+ * QA360 Data Fixtures Loader
+ *
+ * Loads YAML/JSON fixture files and provides access to fixture data.
+ */
+import { FixtureFile, FixtureRegistry } from './types.js';
+export declare class FixtureLoader {
+    private registry;
+    private baseDir;
+    constructor(baseDir: string);
+    /**
+     * Load fixture files from the specified paths
+     *
+     * @param fixturePaths - Array of relative or absolute paths to fixture files
+     * @returns The loaded fixture registry
+     */
+    load(fixturePaths: string[]): Promise<FixtureRegistry>;
+    /**
+     * Load a single fixture file
+     *
+     * @param fixturePath - Path to the fixture file
+     * @returns The loaded fixture file
+     */
+    loadFile(fixturePath: string): Promise<FixtureFile>;
+    /**
+     * Get a fixture value by path (e.g., "testUsers.buyer.email")
+     *
+     * @param path - Dot-notation path to the fixture value
+     * @returns The fixture value
+     */
+    get(path: string): unknown;
+    /**
+     * Get all loaded fixtures
+     *
+     * @returns The fixture registry
+     */
+    getAll(): FixtureRegistry;
+    /**
+     * Check if a fixture path exists
+     *
+     * @param path - Dot-notation path to check
+     * @returns True if the path exists
+     */
+    has(path: string): boolean;
+    /**
+     * Get fixture names (top-level keys)
+     *
+     * @returns Array of fixture names
+     */
+    getFixtureNames(): string[];
+    /**
+     * Resolve a relative path to an absolute path
+     *
+     * @param fixturePath - Relative or absolute path
+     * @returns Absolute path
+     */
+    private resolvePath;
+    /**
+     * Extract fixture name from file path
+     *
+     * @param fixturePath - Path to the fixture file
+     * @returns Fixture name (filename without extension or directory)
+     */
+    private getFixtureName;
+}

package/cli/dist/core/fixtures/loader.js

@@ -0,0 +1,161 @@
+/**
+ * QA360 Data Fixtures Loader
+ *
+ * Loads YAML/JSON fixture files and provides access to fixture data.
+ */
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import * as yaml from 'js-yaml';
+import { FixtureError, } from './types.js';
+export class FixtureLoader {
+    registry = {};
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    /**
+     * Load fixture files from the specified paths
+     *
+     * @param fixturePaths - Array of relative or absolute paths to fixture files
+     * @returns The loaded fixture registry
+     */
+    async load(fixturePaths) {
+        this.registry = {};
+        for (const path of fixturePaths) {
+            await this.loadFile(path);
+        }
+        return this.registry;
+    }
+    /**
+     * Load a single fixture file
+     *
+     * @param fixturePath - Path to the fixture file
+     * @returns The loaded fixture file
+     */
+    async loadFile(fixturePath) {
+        const fullPath = this.resolvePath(fixturePath);
+        if (!existsSync(fullPath)) {
+            throw new FixtureError(`Fixture file not found: ${fixturePath}`, 'FIXTURE_NOT_FOUND', fullPath);
+        }
+        try {
+            const content = await readFile(fullPath, 'utf-8');
+            const ext = fullPath.split('.').pop()?.toLowerCase();
+            let fixtureData;
+            if (ext === 'yml' || ext === 'yaml') {
+                fixtureData = yaml.load(content);
+            }
+            else if (ext === 'json') {
+                fixtureData = JSON.parse(content);
+            }
+            else {
+                // Try to detect format from content
+                if (content.trim().startsWith('{')) {
+                    fixtureData = JSON.parse(content);
+                }
+                else {
+                    fixtureData = yaml.load(content);
+                }
+            }
+            // Validate that the loaded data is an object
+            if (!fixtureData || typeof fixtureData !== 'object' || Array.isArray(fixtureData)) {
+                throw new FixtureError(`Fixture file must contain an object with named fixtures: ${fixturePath}`, 'INVALID_FIXTURE_FORMAT', fullPath);
+            }
+            // Merge fixture data into registry (keys become directly accessible)
+            // This allows $fixtures.environments.production.baseUrl instead of
+            // $fixtures.fixtures.environments.production.baseUrl
+            const fixtureName = this.getFixtureName(fixturePath);
+            this.registry[fixtureName] = fixtureData; // Keep filename reference for debug
+            // Also merge top-level keys for direct access
+            for (const [key, value] of Object.entries(fixtureData)) {
+                // Skip if key already exists (first file wins)
+                // We need to cast because FixtureValue is broader than FixtureFile
+                if (!(key in this.registry)) {
+                    this.registry[key] = value;
+                }
+            }
+            return fixtureData;
+        }
+        catch (error) {
+            if (error instanceof FixtureError) {
+                throw error;
+            }
+            throw new FixtureError(`Failed to load fixture file: ${fixturePath} - ${error instanceof Error ? error.message : 'Unknown error'}`, 'FIXTURE_LOAD_ERROR', fullPath);
+        }
+    }
+    /**
+     * Get a fixture value by path (e.g., "testUsers.buyer.email")
+     *
+     * @param path - Dot-notation path to the fixture value
+     * @returns The fixture value
+     */
+    get(path) {
+        const parts = path.split('.');
+        let current = this.registry;
+        for (const part of parts) {
+            if (current && typeof current === 'object' && part in current) {
+                current = current[part];
+            }
+            else {
+                throw new FixtureError(`Fixture path not found: ${path}`, 'FIXTURE_PATH_NOT_FOUND');
+            }
+        }
+        return current;
+    }
+    /**
+     * Get all loaded fixtures
+     *
+     * @returns The fixture registry
+     */
+    getAll() {
+        return { ...this.registry };
+    }
+    /**
+     * Check if a fixture path exists
+     *
+     * @param path - Dot-notation path to check
+     * @returns True if the path exists
+     */
+    has(path) {
+        try {
+            this.get(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get fixture names (top-level keys)
+     *
+     * @returns Array of fixture names
+     */
+    getFixtureNames() {
+        return Object.keys(this.registry);
+    }
+    /**
+     * Resolve a relative path to an absolute path
+     *
+     * @param fixturePath - Relative or absolute path
+     * @returns Absolute path
+     */
+    resolvePath(fixturePath) {
+        if (resolve(fixturePath) === fixturePath) {
+            // Already absolute
+            return fixturePath;
+        }
+        // Resolve relative to base directory
+        return resolve(this.baseDir, fixturePath);
+    }
+    /**
+     * Extract fixture name from file path
+     *
+     * @param fixturePath - Path to the fixture file
+     * @returns Fixture name (filename without extension or directory)
+     */
+    getFixtureName(fixturePath) {
+        // Get the filename without extension
+        const filename = fixturePath.split('/').pop() || fixturePath;
+        return filename.replace(/\.(yml|yaml|json)$/, '');
+    }
+}

package/cli/dist/core/fixtures/resolver.d.ts

@@ -0,0 +1,79 @@
+/**
+ * QA360 Data Fixtures Resolver
+ *
+ * Resolves fixture references in configuration objects.
+ *
+ * Syntax:
+ * - $fixtures.fixtureName.key.subkey
+ * - Nested in objects: { url: "/login", email: "$fixtures.users.buyer.email" }
+ * - In arrays: ["$fixtures.users.buyer.email", "$fixtures.users.admin.email"]
+ */
+import { ParsedReference, FixtureResolverOptions, FixtureResolverResult } from './types.js';
+import { FixtureLoader } from './loader.js';
+export declare class FixtureResolver {
+    private loader;
+    private baseDir;
+    private unresolved;
+    constructor(loader: FixtureLoader, baseDir: string);
+    /**
+     * Resolve fixture references in a configuration object
+     *
+     * @param config - The configuration object to resolve
+     * @param options - Resolver options
+     * @returns The resolved configuration
+     */
+    resolve(config: unknown, options: FixtureResolverOptions): FixtureResolverResult;
+    /**
+     * Check if a value contains any fixture references
+     *
+     * @param value - The value to check
+     * @returns True if fixture references are found
+     */
+    private hasFixtureReferences;
+    /**
+     * Resolve fixture references in a value
+     *
+     * @param value - The value to resolve
+     * @param options - Resolver options
+     * @returns The resolved value
+     */
+    private resolveValue;
+    /**
+     * Resolve a fixture path (e.g., "testUsers.buyer.email")
+     *
+     * @param path - The fixture path
+     * @param options - Resolver options
+     * @returns The resolved fixture value
+     */
+    private resolveFixturePath;
+    /**
+     * Parse a fixture reference string
+     *
+     * @param ref - The reference string (e.g., "$fixtures.testUsers.buyer")
+     * @returns The parsed reference
+     */
+    parseReference(ref: string): ParsedReference | null;
+    /**
+     * Create a fixture reference string
+     *
+     * @param fixtureFile - The fixture file name
+     * @param valuePath - The path within the fixture
+     * @returns The fixture reference string
+     */
+    createReference(fixtureFile: string, ...valuePath: string[]): string;
+    /**
+     * Get the list of unresolved references from the last resolve() call
+     *
+     * @returns Array of unresolved paths
+     */
+    getUnresolved(): string[];
+}
+/**
+ * Resolve fixtures in a configuration object (convenience function)
+ *
+ * @param config - The configuration object
+ * @param fixturePaths - Array of fixture file paths
+ * @param baseDir - Base directory for resolving relative paths
+ * @returns The resolved configuration
+ */
+export declare function resolveFixtures(config: unknown, fixturePaths: string[], baseDir: string): Promise<FixtureResolverResult>;