qa360 2.2.1 → 2.2.13

package/core/src/generation/__tests__/code-generator.test.ts

@@ -1,586 +0,0 @@
-/**
- * Tests for Code Generator
- *
- * Unit tests for AI-powered test code generation using mocked LLM providers.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { CodeGenerator, type CodeGeneratorOptions, type GenerationResult } from '../code-generator.js';
-import type { LLMProvider } from '../../ai/index.js';
-
-// Mock LLM Provider for testing
-class MockLLMProvider implements LLMProvider {
-  name = 'mock-test-provider';
-  models = ['mock-model', 'mock-large'];
-
-  private shouldFail = false;
-  private delay = 0;
-  private fixedResponse?: string;
-
-  setFixedResponse(response: string): void {
-    this.fixedResponse = response;
-  }
-
-  setShouldFail(shouldFail: boolean): void {
-    this.shouldFail = shouldFail;
-  }
-
-  setDelay(ms: number): void {
-    this.delay = ms;
-  }
-
-  async generate(request: {
-    prompt: string;
-    systemPrompt?: string;
-    temperature?: number;
-    maxTokens?: number;
-    jsonMode?: boolean;
-  }) {
-    if (this.delay > 0) {
-      await new Promise(resolve => setTimeout(resolve, this.delay));
-    }
-
-    if (this.shouldFail) {
-      throw new Error('Mock LLM provider failed');
-    }
-
-    const response = this.fixedResponse || this.getDefaultResponse(request);
-    return {
-      content: response,
-      usage: {
-        promptTokens: 100,
-        completionTokens: 200,
-        totalTokens: 300
-      },
-      model: 'mock-model',
-      finishReason: 'stop' as const
-    };
-  }
-
-  private getDefaultResponse(request: { prompt: string }): string {
-    // Generate relevant mock code based on the prompt
-    const prompt = request.prompt.toLowerCase();
-
-    if (prompt.includes('api') || prompt.includes('endpoint')) {
-      return this.getApiTestCode();
-    }
-
-    if (prompt.includes('ui') || prompt.includes('page')) {
-      return this.getUiTestCode();
-    }
-
-    if (prompt.includes('performance') || prompt.includes('load')) {
-      return this.getPerfTestCode();
-    }
-
-    return this.getGenericTestCode();
-  }
-
-  private getApiTestCode(): string {
-    return `import { test, expect } from '@playwright/test';
-
-test.describe('API Smoke Tests', () => {
-  test('GET /health should return 200', async ({ request }) => {
-    const response = await request.get('/health');
-    expect(response.status()).toBe(200);
-  });
-
-  test('GET /users should return user list', async ({ request }) => {
-    const response = await request.get('/users');
-    expect(response.status()).toBe(200);
-    const body = await response.json();
-    expect(Array.isArray(body)).toBe(true);
-  });
-
-  test('POST /users should create user', async ({ request }) => {
-    const userData = {
-      name: 'Test User',
-      email: 'test@example.com'
-    };
-    const response = await request.post('/users', { data: userData });
-    expect(response.status()).toBe(201);
-    const body = await response.json();
-    expect(body).toHaveProperty('id');
-  });
-});`;
-  }
-
-  private getUiTestCode(): string {
-    return `import { test, expect } from '@playwright/test';
-
-test.describe('UI Tests', () => {
-  test('homepage should load', async ({ page }) => {
-    await page.goto('/');
-    await expect(page).toHaveTitle(/Home/);
-  });
-
-  test('navigation should work', async ({ page }) => {
-    await page.goto('/');
-    await page.click('nav a[href="/products"]');
-    await expect(page).toHaveURL(/.*products/);
-  });
-
-  test('search functionality', async ({ page }) => {
-    await page.goto('/');
-    await page.fill('input[name="search"]', 'test product');
-    await page.click('button[type="submit"]');
-    await expect(page.locator('.product-list')).toBeVisible();
-  });
-});`;
-  }
-
-  private getPerfTestCode(): string {
-    return `import { check } from 'k6';
-import http from 'k6/http';
-
-export let options = {
-  vus: 10,
-  duration: '30s',
-  thresholds: {
-    http_req_duration: ['p(95)<500', 'p(99)<1000'],
-    http_req_failed: ['rate<0.01']
-  }
-};
-
-export default function () {
-  let response = http.get('https://api.example.com/health');
-  check(response, {
-    'status is 200': (r) => r.status === 200,
-    'response time < 500ms': (r) => r.timings.duration < 500
-  });
-}`;
-  }
-
-  private getGenericTestCode(): string {
-    return `import { test, expect } from '@playwright/test';
-
-test('generic test', async ({ page }) => {
-  await page.goto('/');
-  await expect(page).toBeVisible();
-});`;
-  }
-
-  countTokens(text: string): number {
-    return Math.ceil(text.length / 4);
-  }
-
-  async isAvailable(): Promise<boolean> {
-    return true;
-  }
-}
-
-describe('CodeGenerator', () => {
-  let mockProvider: MockLLMProvider;
-  let generator: CodeGenerator;
-
-  beforeEach(() => {
-    mockProvider = new MockLLMProvider();
-    // Create generator with mocked provider
-    generator = new CodeGenerator({
-      timeout: 5000,
-      temperature: 0.3,
-      maxTokens: 2000
-    }) as any;
-
-    // Replace the provider with our mock
-    (generator as any).provider = mockProvider;
-  });
-
-  describe('Constructor', () => {
-    it('should create generator with default options', () => {
-      const gen = new CodeGenerator();
-      expect(gen).toBeInstanceOf(CodeGenerator);
-    });
-
-    it('should validate timeout bounds', () => {
-      expect(() => new CodeGenerator({ timeout: 50 })).toThrow('timeout must be between 100ms');
-      expect(() => new CodeGenerator({ timeout: 700000 })).toThrow('timeout must be between');
-    });
-
-    it('should validate temperature bounds', () => {
-      expect(() => new CodeGenerator({ temperature: -0.1 })).toThrow('temperature must be between 0 and 1');
-      expect(() => new CodeGenerator({ temperature: 1.5 })).toThrow('temperature must be between 0 and 1');
-    });
-
-    it('should accept valid options', () => {
-      const gen = new CodeGenerator({
-        timeout: 10000,
-        temperature: 0.7,
-        maxTokens: 4000,
-        formatCode: false
-      });
-      expect(gen).toBeInstanceOf(CodeGenerator);
-    });
-  });
-
-  describe('generateFromDescription', () => {
-    it('should generate tests from description', async () => {
-      const result = await generator.generateFromDescription('Create API smoke tests for a REST API');
-
-      expect(result.success).toBe(true);
-      expect(result.tests).toHaveLength(1);
-      expect(result.tests[0].code).toContain('test.describe');
-      expect(result.tests[0].language).toBe('typescript');
-      expect(result.metadata.model).toBe('mock-model');
-    });
-
-    it('should include metadata in result', async () => {
-      const result = await generator.generateFromDescription('Generate UI tests');
-
-      expect(result.metadata).toBeDefined();
-      expect(result.metadata.duration).toBeGreaterThanOrEqual(0);
-      expect(result.metadata.model).toBe('mock-model');
-      expect(result.metadata.tokensUsed).toBe(300);
-    });
-
-    it('should handle generation errors gracefully', async () => {
-      mockProvider.setShouldFail(true);
-
-      const result = await generator.generateFromDescription('This should fail');
-
-      expect(result.success).toBe(false);
-      expect(result.tests).toHaveLength(0);
-      expect(result.errors).toBeDefined();
-      expect(result.errors?.length).toBeGreaterThan(0);
-    });
-
-    it('should handle timeout', async () => {
-      // Set a delay longer than timeout
-      mockProvider.setDelay(6000);
-
-      const fastGenerator = new CodeGenerator({ timeout: 100 }) as any;
-      (fastGenerator as any).provider = mockProvider;
-
-      const result = await fastGenerator.generateFromDescription('This will timeout');
-
-      expect(result.success).toBe(false);
-      expect(result.errors?.[0]).toContain('TIMEOUT');
-    });
-  });
-
-  describe('generateFromSpec', () => {
-    it('should generate tests from API spec', async () => {
-      const spec = {
-        type: 'api' as const,
-        name: 'User API Tests',
-        baseUrl: 'https://api.example.com',
-        endpoints: [
-          { method: 'GET' as const, path: '/users' },
-          { method: 'POST' as const, path: '/users' }
-        ]
-      };
-
-      const result = await generator.generateFromSpec(spec);
-
-      expect(result.success).toBe(true);
-      expect(result.tests).toHaveLength(1);
-      expect(result.tests[0].code).toContain('API');
-    });
-
-    it('should generate tests from UI spec', async () => {
-      const spec = {
-        type: 'ui' as const,
-        name: 'UI Tests',
-        baseUrl: 'https://example.com',
-        pages: [
-          {
-            name: 'Homepage',
-            url: 'https://example.com',
-            actions: [
-              { type: 'goto' as const, selector: '/' },
-              { type: 'click' as const, selector: 'button' }
-            ]
-          }
-        ]
-      };
-
-      const result = await generator.generateFromSpec(spec);
-
-      expect(result.success).toBe(true);
-      expect(result.tests).toHaveLength(1);
-      expect(result.tests[0].framework).toBe('playwright');
-    });
-
-    it('should generate tests from performance spec', async () => {
-      const spec = {
-        type: 'perf' as const,
-        name: 'Load Tests',
-        baseUrl: 'https://api.example.com',
-        scenarios: [
-          {
-            name: 'Read Load',
-            requests: [
-              { method: 'GET' as const, path: '/api/data' }
-            ]
-          }
-        ]
-      };
-
-      const result = await generator.generateFromSpec(spec);
-
-      expect(result.success).toBe(true);
-      expect(result.tests).toHaveLength(1);
-      // Note: framework is determined by context, defaults to playwright for specs
-      expect(result.tests[0].framework).toBeTruthy();
-    });
-  });
-
-  describe('generateFromOpenAPI', () => {
-    it('should generate tests from OpenAPI spec path', async () => {
-      // Since we're using a mock, this will succeed regardless of file existence
-      // In real scenario, this would parse the OpenAPI file
-      const result = await generator.generateFromOpenAPI('/path/to/openapi.yaml');
-
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('generateFromUrl', () => {
-    it('should generate tests from URL', async () => {
-      const result = await generator.generateFromUrl('https://example.com');
-
-      expect(result.success).toBe(true);
-      expect(result.tests[0].code).toContain('test');
-    });
-  });
-
-  describe('generateFromCode', () => {
-    it('should generate tests from code snippet', async () => {
-      const code = `
-export class UserService {
-  async getUser(id: string) {
-    return database.findUser(id);
-  }
-
-  async createUser(data: any) {
-    return database.insertUser(data);
-  }
-}
-      `;
-
-      const result = await generator.generateFromCode(code, 'typescript');
-
-      expect(result.success).toBe(true);
-      expect(result.tests[0].language).toBe('typescript');
-    });
-  });
-
-  describe('listModels', () => {
-    it('should return available models', async () => {
-      const models = await generator.listModels();
-
-      expect(models).toEqual(['mock-model', 'mock-large']);
-    });
-  });
-
-  describe('isAvailable', () => {
-    it('should check provider availability', async () => {
-      const available = await generator.isAvailable();
-
-      expect(available).toBe(true);
-    });
-
-    it('should return false when provider is unavailable', async () => {
-      mockProvider.setShouldFail(true);
-
-      // Mock the isAvailable method
-      vi.spyOn(mockProvider, 'isAvailable').mockResolvedValue(false);
-
-      const available = await generator.isAvailable();
-
-      expect(available).toBe(false);
-    });
-  });
-
-  describe('Code extraction', () => {
-    it('should extract code from markdown code blocks', async () => {
-      mockProvider.setFixedResponse(`
-Here is the generated test code:
-
-\`\`\`typescript
-import { test } from '@playwright/test';
-
-test('example', async ({ page }) => {
-  await page.goto('/');
-});
-\`\`\`
-
-Additional text here.
-      `);
-
-      const result = await generator.generateFromDescription('Test with markdown');
-
-      expect(result.success).toBe(true);
-      expect(result.tests[0].code).toContain('import');
-      expect(result.tests[0].code).toContain('test(');
-    });
-
-    it('should handle multiple code blocks', async () => {
-      mockProvider.setFixedResponse(`
-\`\`\`typescript
-test('first', () => {});
-\`\`\`
-
-\`\`\`typescript
-test('second', () => {});
-\`\`\`
-      `);
-
-      const result = await generator.generateFromDescription('Multiple tests');
-
-      expect(result.success).toBe(true);
-      // Should parse both blocks
-      expect(result.tests[0].code).toContain('first');
-    });
-
-    it('should handle plain code without markdown', async () => {
-      mockProvider.setFixedResponse(`
-import { test } from '@playwright/test';
-
-test('plain code', async ({ page }) => {
-  await page.goto('/');
-});
-      `);
-
-      const result = await generator.generateFromDescription('Plain code');
-
-      expect(result.success).toBe(true);
-      expect(result.tests[0].code).toContain('import');
-      expect(result.tests[0].code).toContain('test(');
-    });
-  });
-
-  describe('File path generation', () => {
-    it('should generate file path with .ts extension', async () => {
-      const result = await generator.generateFromDescription('Create API tests for users endpoint');
-
-      expect(result.tests[0].filePath).toContain('.ts');
-      expect(result.tests[0].filePath).toContain('tests');
-    });
-
-    it('should include test name in file path', async () => {
-      mockProvider.setFixedResponse(MockLLMProvider.prototype.getUiTestCode());
-
-      const result = await generator.generateFromDescription('Create UI tests for homepage');
-
-      // File path should be based on the test name
-      expect(result.tests[0].filePath).toBeTruthy();
-      expect(result.tests[0].filePath.length).toBeGreaterThan(0);
-    });
-
-    it('should generate performance test paths', async () => {
-      mockProvider.setFixedResponse(MockLLMProvider.prototype.getPerfTestCode());
-
-      const result = await generator.generateFromDescription('Create load tests');
-
-      // Note: framework detection is based on defaults, not code content
-      // The generator defaults to 'playwright' for descriptions
-      expect(result.tests[0].filePath).toBeTruthy();
-    });
-  });
-
-  describe('Test summary', () => {
-    it('should calculate test summary correctly', async () => {
-      const result = await generator.generateFromDescription('Generate multiple tests');
-
-      expect(result.tests[0].summary).toBeDefined();
-      expect(result.tests[0].summary.lines).toBeGreaterThan(0);
-      expect(result.tests[0].summary.testCount).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Custom output directory', () => {
-    it('should use custom output directory when specified', async () => {
-      const customGen = new CodeGenerator({ outputDir: '/custom/output' }) as any;
-      (customGen as any).provider = mockProvider;
-
-      const result = await customGen.generateFromDescription('Test output dir');
-
-      expect(result.tests[0].filePath).toContain('/custom/output');
-    });
-  });
-
-  describe('Prompt options', () => {
-    it('should pass prompt options to builder', async () => {
-      const gen = new CodeGenerator({
-        promptOptions: {
-          includeComments: false,
-          includeDetailedAssertions: true,
-          includeRetryLogic: true,
-          codeStyle: 'concise'
-        }
-      }) as any;
-
-      (gen as any).provider = mockProvider;
-
-      const result = await gen.generateFromDescription('Test with options');
-
-      expect(result.success).toBe(true);
-    });
-  });
-});
-
-describe('CodeGenerator Integration', () => {
-  let mockProvider: MockLLMProvider;
-
-  beforeEach(() => {
-    mockProvider = new MockLLMProvider();
-  });
-
-  describe('Full generation workflow', () => {
-    it('should complete full workflow from description to executable test', async () => {
-      const generator = new CodeGenerator({
-        formatCode: true,
-        outputDir: './tests/generated'
-      }) as any;
-
-      (generator as any).provider = mockProvider;
-
-      const description = `
-Create comprehensive API tests for a user management API with the following endpoints:
-- GET /users - List all users
-- GET /users/:id - Get user by ID
-- POST /users - Create new user
-- PUT /users/:id - Update user
-- DELETE /users/:id - Delete user
-
-Include authentication, error handling, and data validation.
-      `;
-
-      const result = await generator.generateFromDescription(description);
-
-      // Verify result structure
-      expect(result.success).toBe(true);
-      expect(result.tests).toHaveLength(1);
-      expect(result.tests[0].name).toBeTruthy();
-      expect(result.tests[0].code).toBeTruthy();
-      expect(result.tests[0].language).toBe('typescript');
-      expect(result.tests[0].framework).toBe('playwright');
-      expect(result.tests[0].filePath).toBeTruthy();
-
-      // Verify generated code quality
-      const code = result.tests[0].code;
-      expect(code).toContain('test');
-      expect(code).toContain('expect');
-      expect(result.tests[0].summary.testCount).toBeGreaterThan(0);
-    });
-
-    it('should handle batch generation from multiple sources', async () => {
-      const generator = new CodeGenerator() as any;
-      (generator as any).provider = mockProvider;
-
-      const sources = [
-        { type: 'description' as const, description: 'API health check tests' },
-        { type: 'description' as const, description: 'UI navigation tests' },
-        { type: 'description' as const, description: 'Load tests' }
-      ];
-
-      const results = await Promise.all(
-        sources.map(s => generator.generateFromSource(s, {}))
-      );
-
-      expect(results).toHaveLength(3);
-      expect(results.every(r => r.success)).toBe(true);
-    });
-  });
-});