qa360 2.1.7 → 2.2.0

package/core/src/discoverer/index.ts

@@ -0,0 +1,374 @@
+/**
+ * QA360 Test Discoverer
+ *
+ * Automatically discovers and categorizes test files in a project.
+ * Supports Playwright, K6, Cypress, and other test frameworks.
+ */
+
+import { readdir, stat } from 'fs/promises';
+import { join, relative, extname } from 'path';
+import { glob } from 'glob';
+
+/**
+ * Detected test information
+ */
+export interface TestFile {
+  path: string;
+  type: TestType;
+  framework: TestFramework;
+  relativePath: string;
+}
+
+/**
+ * Discovered tests in a project
+ */
+export interface DiscoveredTests {
+  playwright: TestFile[];
+  k6: TestFile[];
+  cypress: TestFile[];
+  jest: TestFile[];
+  vitest: TestFile[];
+  other: TestFile[];
+}
+
+/**
+ * Test type categories
+ */
+export type TestType =
+  | 'api'
+  | 'ui'
+  | 'e2e'
+  | 'perf'
+  | 'load'
+  | 'security'
+  | 'sast'
+  | 'dast'
+  | 'a11y'
+  | 'unit'
+  | 'integration';
+
+/**
+ * Supported test frameworks
+ */
+export type TestFramework =
+  | 'playwright'
+  | 'k6'
+  | 'cypress'
+  | 'jest'
+  | 'vitest'
+  | 'mocha'
+  | 'jasmine'
+  | 'unknown';
+
+/**
+ * Test discovery options
+ */
+export interface DiscoverOptions {
+  rootDir?: string;
+  patterns?: string[];
+  excludePatterns?: string[];
+}
+
+/**
+ * Result of routing a test to an adapter
+ */
+export interface AdapterRouting {
+  adapter: string;
+  config?: Record<string, unknown>;
+}
+
+/**
+ * Test Discoverer
+ *
+ * Scans a project directory for test files and categorizes them
+ * by framework and type.
+ */
+export class TestDiscoverer {
+  private readonly rootDir: string;
+  private readonly defaultPatterns: string[];
+
+  // Default test patterns
+  private readonly DEFAULT_PATTERNS = [
+    'tests/**/*',
+    'test/**/*',
+    '**/*.spec.ts',
+    '**/*.spec.js',
+    '**/*.test.ts',
+    '**/*.test.js',
+    '**/__tests__/**/*',
+  ];
+
+  // Default exclusions
+  private readonly DEFAULT_EXCLUDES = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.next/**',
+    '**/.nuxt/**',
+    '**/coverage/**',
+    '**/*.d.ts',
+  ];
+
+  constructor(options: DiscoverOptions = {}) {
+    this.rootDir = options.rootDir || process.cwd();
+    this.defaultPatterns = options.patterns || this.DEFAULT_PATTERNS;
+  }
+
+  /**
+   * Discover all test files in the project
+   */
+  async discover(): Promise<DiscoveredTests> {
+    const files = await this.findTestFiles();
+    const categorized: DiscoveredTests = {
+      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
+   */
+  private async findTestFiles(): Promise<TestFile[]> {
+    const files = await glob(this.defaultPatterns, {
+      cwd: this.rootDir,
+      absolute: true,
+      ignore: this.DEFAULT_EXCLUDES,
+    });
+
+    const results: TestFile[] = [];
+
+    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
+   */
+  private categorizeFile(file: TestFile): keyof DiscoveredTests {
+    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: string): TestFramework {
+    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: string): TestType {
+    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: TestFile): AdapterRouting {
+    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: string): Promise<TestFile[]> {
+    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(): Promise<TestSummary> {
+    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),
+    };
+  }
+
+  private countAll(tests: DiscoveredTests): number {
+    return Object.values(tests).reduce((sum, arr) => sum + arr.length, 0);
+  }
+
+  private countByType(tests: DiscoveredTests): Record<string, number> {
+    const counts: Record<string, number> = {};
+
+    for (const category of Object.values(tests)) {
+      for (const test of category) {
+        counts[test.type] = (counts[test.type] || 0) + 1;
+      }
+    }
+
+    return counts;
+  }
+}
+
+/**
+ * Test summary statistics
+ */
+export interface TestSummary {
+  total: number;
+  byFramework: {
+    playwright: number;
+    k6: number;
+    cypress: number;
+    jest: number;
+    vitest: number;
+    other: number;
+  };
+  byType: Record<string, number>;
+}
+
+/**
+ * Create a test discoverer
+ */
+export function createTestDiscoverer(options?: DiscoverOptions): TestDiscoverer {
+  return new TestDiscoverer(options);
+}

package/core/src/fixtures/__tests__/loader.test.ts

@@ -0,0 +1,246 @@
+/**
+ * QA360 Data Fixtures Loader Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { writeFile, mkdir, rm } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+import { FixtureLoader, FixtureError } from '../loader.js';
+import type { FixtureFile } from '../types.js';
+
+describe('FixtureLoader', () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `qa360-fixtures-test-${Date.now()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  describe('load', () => {
+    it('should load YAML fixture files', async () => {
+      const yamlContent = `
+testUsers:
+  buyer:
+    email: buyer@example.com
+    password: Buyer123!
+  admin:
+    email: admin@example.com
+    password: Admin456!
+`;
+      const yamlPath = join(testDir, 'users.yml');
+      await writeFile(yamlPath, yamlContent, 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      const registry = await loader.load(['users.yml']);
+
+      expect(registry.users).toBeDefined();
+      expect(registry.users.testUsers).toBeDefined();
+      expect(registry.users.testUsers.buyer).toEqual({
+        email: 'buyer@example.com',
+        password: 'Buyer123!'
+      });
+    });
+
+    it('should load JSON fixture files', async () => {
+      const jsonContent = {
+        products: {
+          laptop: { name: 'MacBook Pro', price: 1999 },
+          phone: { name: 'iPhone', price: 999 }
+        }
+      };
+      const jsonPath = join(testDir, 'products.json');
+      await writeFile(jsonPath, JSON.stringify(jsonContent, null, 2), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      const registry = await loader.load(['products.json']);
+
+      expect(registry.products).toBeDefined();
+      expect(registry.products.products.laptop.name).toBe('MacBook Pro');
+    });
+
+    it('should load multiple fixture files', async () => {
+      const usersContent = { users: { buyer: { email: 'buyer@test.com' } } };
+      const productsContent = { products: { laptop: { price: 1999 } } };
+
+      await writeFile(join(testDir, 'users.yml'), JSON.stringify(usersContent), 'utf-8');
+      await writeFile(join(testDir, 'products.yml'), JSON.stringify(productsContent), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      const registry = await loader.load(['users.yml', 'products.yml']);
+
+      expect(registry.users).toBeDefined();
+      expect(registry.products).toBeDefined();
+      expect(Object.keys(registry)).toHaveLength(2);
+    });
+
+    it('should throw FixtureError for non-existent files', async () => {
+      const loader = new FixtureLoader(testDir);
+
+      await expect(loader.load(['nonexistent.yml'])).rejects.toThrow(FixtureError);
+      await expect(loader.load(['nonexistent.yml'])).rejects.toMatchObject({
+        code: 'FIXTURE_NOT_FOUND'
+      });
+    });
+
+    it('should throw FixtureError for invalid YAML', async () => {
+      const invalidYaml = `
+testUsers:
+  buyer:
+    email: buyer@example.com
+    password: Buyer123!
+    invalid: [unclosed array
+`;
+      const yamlPath = join(testDir, 'invalid.yml');
+      await writeFile(yamlPath, invalidYaml, 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+
+      await expect(loader.load(['invalid.yml'])).rejects.toThrow(FixtureError);
+    });
+  });
+
+  describe('get', () => {
+    it('should get nested fixture values using dot notation', async () => {
+      const content = {
+        testUsers: {
+          buyer: {
+            email: 'buyer@example.com',
+            password: 'Buyer123!'
+          }
+        }
+      };
+      await writeFile(join(testDir, 'users.yml'), JSON.stringify(content), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      await loader.load(['users.yml']);
+
+      const email = loader.get('users.testUsers.buyer.email');
+      expect(email).toBe('buyer@example.com');
+
+      const buyer = loader.get('users.testUsers.buyer');
+      expect(buyer).toEqual({
+        email: 'buyer@example.com',
+        password: 'Buyer123!'
+      });
+    });
+
+    it('should throw FixtureError for non-existent paths', async () => {
+      const content = { testUsers: { buyer: { email: 'buyer@test.com' } } };
+      await writeFile(join(testDir, 'users.yml'), JSON.stringify(content), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      await loader.load(['users.yml']);
+
+      expect(() => loader.get('users.nonexistent')).toThrow(FixtureError);
+      expect(() => loader.get('users.testUsers.nonexistent')).toThrow(FixtureError);
+    });
+  });
+
+  describe('has', () => {
+    it('should return true for existing paths', async () => {
+      const content = { testUsers: { buyer: { email: 'buyer@test.com' } } };
+      await writeFile(join(testDir, 'users.yml'), JSON.stringify(content), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      await loader.load(['users.yml']);
+
+      expect(loader.has('users.testUsers.buyer.email')).toBe(true);
+      expect(loader.has('users.testUsers')).toBe(true);
+      expect(loader.has('users')).toBe(true);
+    });
+
+    it('should return false for non-existent paths', async () => {
+      const content = { testUsers: { buyer: { email: 'buyer@test.com' } } };
+      await writeFile(join(testDir, 'users.yml'), JSON.stringify(content), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      await loader.load(['users.yml']);
+
+      expect(loader.has('users.nonexistent')).toBe(false);
+      expect(loader.has('nonexistent')).toBe(false);
+    });
+  });
+
+  describe('getAll', () => {
+    it('should return a copy of the fixture registry', async () => {
+      const content = { testUsers: { buyer: { email: 'buyer@test.com' } } };
+      await writeFile(join(testDir, 'users.yml'), JSON.stringify(content), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      await loader.load(['users.yml']);
+
+      const registry1 = loader.getAll();
+      const registry2 = loader.getAll();
+
+      expect(registry1).toEqual(registry2);
+      expect(registry1).not.toBe(registry2); // Different references
+    });
+  });
+
+  describe('getFixtureNames', () => {
+    it('should return list of fixture file names', async () => {
+      await writeFile(join(testDir, 'users.yml'), JSON.stringify({ users: {} }), 'utf-8');
+      await writeFile(join(testDir, 'products.yml'), JSON.stringify({ products: {} }), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      await loader.load(['users.yml', 'products.yml']);
+
+      const names = loader.getFixtureNames();
+      expect(names).toContain('users');
+      expect(names).toContain('products');
+      expect(names).toHaveLength(2);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty fixture files', async () => {
+      await writeFile(join(testDir, 'empty.yml'), '{}', 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      const registry = await loader.load(['empty.yml']);
+
+      expect(registry.empty).toEqual({});
+    });
+
+    it('should handle fixture files with special characters in values', async () => {
+      const content = {
+        special: {
+          unicode: '你好世界 🌍',
+          escape: 'Line 1\nLine 2\tTabbed',
+          quote: 'She said "hello"'
+        }
+      };
+      await writeFile(join(testDir, 'special.yml'), JSON.stringify(content), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      await loader.load(['special.yml']);
+
+      expect(loader.get('special.special.unicode')).toBe('你好世界 🌍');
+      expect(loader.get('special.special.escape')).toContain('\n');
+      expect(loader.get('special.special.quote')).toContain('"hello"');
+    });
+
+    it('should handle arrays in fixture data', async () => {
+      const content = {
+        tags: ['production', 'critical', 'api'],
+        users: [
+          { id: 1, name: 'Alice' },
+          { id: 2, name: 'Bob' }
+        ]
+      };
+      await writeFile(join(testDir, 'arrays.yml'), JSON.stringify(content), 'utf-8');
+
+      const loader = new FixtureLoader(testDir);
+      await loader.load(['arrays.yml']);
+
+      expect(loader.get('arrays.tags')).toEqual(['production', 'critical', 'api']);
+      expect(loader.get('arrays.users')).toHaveLength(2);
+    });
+  });
+});