@theihtisham/ai-testgen 1.0.0

package/tests/config.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { loadConfig, resolveConfig, findConfig, createSampleConfig } from '../src/config/loader.js';
+import { DEFAULT_CONFIG, LANGUAGE_EXTENSIONS, LANGUAGE_FRAMEWORKS } from '../src/config/defaults.js';
+
+describe('Configuration', () => {
+  describe('DEFAULT_CONFIG', () => {
+    it('has all required top-level fields', () => {
+      expect(DEFAULT_CONFIG.version).toBe('1.0.0');
+      expect(DEFAULT_CONFIG.language).toBe('auto');
+      expect(DEFAULT_CONFIG.framework).toBe('auto');
+      expect(DEFAULT_CONFIG.outputDir).toBe('__tests__');
+      expect(DEFAULT_CONFIG.coverage.target).toBe(90);
+      expect(DEFAULT_CONFIG.ai.enabled).toBe(false);
+      expect(DEFAULT_CONFIG.ai.privacyMode).toBe(true);
+      expect(DEFAULT_CONFIG.generation.unitTests).toBe(true);
+      expect(DEFAULT_CONFIG.generation.integrationTests).toBe(true);
+      expect(DEFAULT_CONFIG.generation.edgeCaseTests).toBe(true);
+      expect(DEFAULT_CONFIG.generation.mockGeneration).toBe(true);
+    });
+
+    it('has sensible defaults for all sections', () => {
+      expect(DEFAULT_CONFIG.exclude).toContain('node_modules/**');
+      expect(DEFAULT_CONFIG.watch.debounceMs).toBeGreaterThan(0);
+      expect(DEFAULT_CONFIG.generation.maxTestsPerFunction).toBeGreaterThan(0);
+      expect(DEFAULT_CONFIG.ai.temperature).toBeGreaterThanOrEqual(0);
+      expect(DEFAULT_CONFIG.ai.temperature).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('LANGUAGE_EXTENSIONS', () => {
+    it('maps all supported extensions', () => {
+      expect(LANGUAGE_EXTENSIONS['.ts']).toBe('typescript');
+      expect(LANGUAGE_EXTENSIONS['.tsx']).toBe('typescript');
+      expect(LANGUAGE_EXTENSIONS['.js']).toBe('javascript');
+      expect(LANGUAGE_EXTENSIONS['.jsx']).toBe('javascript');
+      expect(LANGUAGE_EXTENSIONS['.py']).toBe('python');
+      expect(LANGUAGE_EXTENSIONS['.go']).toBe('go');
+      expect(LANGUAGE_EXTENSIONS['.rs']).toBe('rust');
+    });
+
+    it('covers all 5 supported languages', () => {
+      const languages = new Set(Object.values(LANGUAGE_EXTENSIONS));
+      expect(languages.has('typescript')).toBe(true);
+      expect(languages.has('javascript')).toBe(true);
+      expect(languages.has('python')).toBe(true);
+      expect(languages.has('go')).toBe(true);
+      expect(languages.has('rust')).toBe(true);
+    });
+  });
+
+  describe('LANGUAGE_FRAMEWORKS', () => {
+    it('maps correct frameworks for each language', () => {
+      expect(LANGUAGE_FRAMEWORKS.typescript).toContain('jest');
+      expect(LANGUAGE_FRAMEWORKS.typescript).toContain('vitest');
+      expect(LANGUAGE_FRAMEWORKS.javascript).toContain('jest');
+      expect(LANGUAGE_FRAMEWORKS.python).toContain('pytest');
+      expect(LANGUAGE_FRAMEWORKS.go).toContain('go-test');
+    });
+  });
+
+  describe('loadConfig', () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'testgen-config-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('loads YAML config files', () => {
+      const configPath = path.join(tempDir, '.aitestgen.yml');
+      fs.writeFileSync(configPath, `
+language: typescript
+framework: vitest
+outputDir: tests
+coverage:
+  target: 95
+ai:
+  enabled: true
+  provider: openai
+`);
+      const config = loadConfig(configPath);
+      expect(config.language).toBe('typescript');
+      expect(config.framework).toBe('vitest');
+      expect(config.outputDir).toBe('tests');
+      expect(config.coverage.target).toBe(95);
+      expect(config.ai.enabled).toBe(true);
+    });
+
+    it('loads JSON config files', () => {
+      const configPath = path.join(tempDir, '.aitestgen.json');
+      fs.writeFileSync(configPath, JSON.stringify({
+        language: 'python',
+        framework: 'pytest',
+        outputDir: 'tests',
+      }));
+      const config = loadConfig(configPath);
+      expect(config.language).toBe('python');
+      expect(config.framework).toBe('pytest');
+      expect(config.outputDir).toBe('tests');
+    });
+
+    it('merges with defaults for missing fields', () => {
+      const configPath = path.join(tempDir, '.aitestgen.yml');
+      fs.writeFileSync(configPath, 'language: go');
+      const config = loadConfig(configPath);
+      expect(config.language).toBe('go');
+      expect(config.version).toBe('1.0.0'); // from defaults
+      expect(config.coverage.target).toBe(90); // from defaults
+    });
+  });
+
+  describe('findConfig', () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'testgen-find-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('finds config in the current directory', () => {
+      const configPath = path.join(tempDir, '.aitestgen.yml');
+      fs.writeFileSync(configPath, 'language: typescript');
+      const found = findConfig(tempDir);
+      expect(found).toBe(configPath);
+    });
+
+    it('finds config in parent directories', () => {
+      const childDir = path.join(tempDir, 'src', 'lib');
+      fs.mkdirSync(childDir, { recursive: true });
+      const configPath = path.join(tempDir, '.aitestgen.yml');
+      fs.writeFileSync(configPath, 'language: typescript');
+      const found = findConfig(childDir);
+      expect(found).toBe(configPath);
+    });
+
+    it('returns null when no config is found', () => {
+      const found = findConfig(os.tmpdir());
+      expect(found).toBeNull();
+    });
+  });
+
+  describe('createSampleConfig', () => {
+    let tempDir: string;
+
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'testgen-sample-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('creates a valid YAML config file', () => {
+      const outputPath = path.join(tempDir, '.aitestgen.yml');
+      createSampleConfig(outputPath);
+      expect(fs.existsSync(outputPath)).toBe(true);
+      const config = loadConfig(outputPath);
+      expect(config.ai.enabled).toBe(true);
+      expect(config.generation.unitTests).toBe(true);
+    });
+  });
+});

package/tests/coverage.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect } from 'vitest';
+import { predictCoverage, formatCoverageReport } from '../src/coverage.js';
+import { SourceAnalysis, TestSuite, CoveragePrediction } from '../src/types.js';
+
+function createMockAnalysis(): SourceAnalysis {
+  return {
+    filePath: '/src/utils.ts',
+    language: 'typescript',
+    functions: [
+      {
+        name: 'add',
+        isAsync: false,
+        isExported: true,
+        params: [
+          { name: 'a', type: 'number', optional: false, defaultValue: null },
+          { name: 'b', type: 'number', optional: false, defaultValue: null },
+        ],
+        returnType: 'number',
+        throws: [],
+        complexity: 1,
+        hasSideEffects: false,
+        startLine: 1,
+        endLine: 3,
+      },
+      {
+        name: 'divide',
+        isAsync: false,
+        isExported: true,
+        params: [
+          { name: 'a', type: 'number', optional: false, defaultValue: null },
+          { name: 'b', type: 'number', optional: false, defaultValue: null },
+        ],
+        returnType: 'number',
+        throws: ['Error'],
+        complexity: 3,
+        hasSideEffects: false,
+        startLine: 5,
+        endLine: 10,
+      },
+      {
+        name: 'formatName',
+        isAsync: false,
+        isExported: true,
+        params: [
+          { name: 'first', type: 'string', optional: false, defaultValue: null },
+          { name: 'last', type: 'string', optional: true, defaultValue: "''" },
+        ],
+        returnType: 'string',
+        throws: [],
+        complexity: 2,
+        hasSideEffects: false,
+        startLine: 12,
+        endLine: 16,
+      },
+    ],
+    classes: [
+      {
+        name: 'Calculator',
+        isExported: true,
+        constructorParams: [],
+        methods: [
+          {
+            name: 'round',
+            isAsync: false,
+            isExported: false,
+            params: [
+              { name: 'value', type: 'number', optional: false, defaultValue: null },
+            ],
+            returnType: 'number',
+            throws: [],
+            complexity: 1,
+            hasSideEffects: false,
+            startLine: 20,
+            endLine: 22,
+          },
+        ],
+        properties: [],
+        implements: [],
+        extends: null,
+      },
+    ],
+    interfaces: [],
+    exports: [
+      { name: 'add', type: 'function', filePath: '/src/utils.ts' },
+      { name: 'divide', type: 'function', filePath: '/src/utils.ts' },
+      { name: 'formatName', type: 'function', filePath: '/src/utils.ts' },
+      { name: 'Calculator', type: 'class', filePath: '/src/utils.ts' },
+    ],
+    imports: [],
+    dependencies: [],
+    linesOfCode: 30,
+    cyclomaticComplexity: 7,
+  };
+}
+
+function createMockSuite(testedNames: string[]): TestSuite {
+  return {
+    filePath: '/tests/utils.test.ts',
+    sourceFilePath: '/src/utils.ts',
+    language: 'typescript',
+    framework: 'vitest',
+    testCases: testedNames.map((name) => ({
+      name: `${name} test`,
+      type: 'unit' as const,
+      description: `Test ${name}`,
+      code: '',
+      expectedBehavior: 'Works',
+      inputDescription: 'Valid input',
+      tags: ['unit'],
+    })),
+    mocks: [],
+    imports: [],
+    setupCode: '',
+    teardownCode: '',
+    coverageEstimate: 80,
+  };
+}
+
+describe('Coverage Prediction', () => {
+  it('predicts coverage for fully tested code', () => {
+    const analysis = createMockAnalysis();
+    const suite = createMockSuite(['add', 'divide', 'formatName', 'round']);
+    const prediction = predictCoverage(analysis, suite);
+
+    expect(prediction.estimatedFunctionCoverage).toBeGreaterThan(50);
+  });
+
+  it('reports uncovered paths', () => {
+    const analysis = createMockAnalysis();
+    const suite = createMockSuite(['add']);
+    const prediction = predictCoverage(analysis, suite);
+
+    expect(prediction.uncoveredPaths.length).toBeGreaterThan(0);
+    expect(prediction.uncoveredPaths.some((p) => p.includes('divide'))).toBe(true);
+  });
+
+  it('suggests additional tests for uncovered code', () => {
+    const analysis = createMockAnalysis();
+    const suite = createMockSuite(['add']);
+    const prediction = predictCoverage(analysis, suite);
+
+    expect(prediction.suggestions.length).toBeGreaterThan(0);
+  });
+
+  it('identifies untested error paths', () => {
+    const analysis = createMockAnalysis();
+    const suite = createMockSuite(['add', 'divide', 'formatName']);
+    const prediction = predictCoverage(analysis, suite);
+
+    // divide throws but we have no error test
+    expect(prediction.suggestions.some((s) => s.includes('error path') || s.includes('error'))).toBe(true);
+  });
+
+  it('identifies untested optional parameters', () => {
+    const analysis = createMockAnalysis();
+    const suite = createMockSuite(['add', 'divide']);
+    const prediction = predictCoverage(analysis, suite);
+
+    // formatName has optional 'last' param
+    expect(
+      prediction.suggestions.some((s) => s.includes('formatName') && s.includes('optional')),
+    ).toBe(true);
+  });
+
+  it('provides coverage percentages between 0 and 100', () => {
+    const analysis = createMockAnalysis();
+    const suite = createMockSuite(['add']);
+    const prediction = predictCoverage(analysis, suite);
+
+    expect(prediction.estimatedLineCoverage).toBeGreaterThanOrEqual(0);
+    expect(prediction.estimatedLineCoverage).toBeLessThanOrEqual(100);
+    expect(prediction.estimatedBranchCoverage).toBeGreaterThanOrEqual(0);
+    expect(prediction.estimatedBranchCoverage).toBeLessThanOrEqual(100);
+    expect(prediction.estimatedFunctionCoverage).toBeGreaterThanOrEqual(0);
+    expect(prediction.estimatedFunctionCoverage).toBeLessThanOrEqual(100);
+  });
+
+  describe('formatCoverageReport', () => {
+    it('formats a readable coverage report', () => {
+      const prediction: CoveragePrediction = {
+        filePath: '/src/utils.ts',
+        estimatedLineCoverage: 85,
+        estimatedBranchCoverage: 72,
+        estimatedFunctionCoverage: 90,
+        uncoveredPaths: ['divide error path'],
+        suggestions: ['Add error path test for divide'],
+      };
+
+      const report = formatCoverageReport(prediction);
+      expect(report).toContain('85%');
+      expect(report).toContain('72%');
+      expect(report).toContain('90%');
+      expect(report).toContain('divide error path');
+      expect(report).toContain('Add error path test');
+    });
+  });
+});

package/tests/file-utils.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  readFile,
+  writeFile,
+  fileExists,
+  getRelativePath,
+  ensureDir,
+  getFileHash,
+  hashString,
+} from '../src/utils/file.js';
+
+describe('File Utilities', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'testgen-file-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('readFile', () => {
+    it('reads file contents', () => {
+      const filePath = path.join(tempDir, 'test.txt');
+      fs.writeFileSync(filePath, 'hello world');
+      expect(readFile(filePath)).toBe('hello world');
+    });
+
+    it('throws for non-existent files', () => {
+      expect(() => readFile(path.join(tempDir, 'missing.txt'))).toThrow('File not found');
+    });
+  });
+
+  describe('writeFile', () => {
+    it('writes file contents', () => {
+      const filePath = path.join(tempDir, 'output.txt');
+      writeFile(filePath, 'test content');
+      expect(fs.readFileSync(filePath, 'utf-8')).toBe('test content');
+    });
+
+    it('creates directories as needed', () => {
+      const filePath = path.join(tempDir, 'nested', 'deep', 'output.txt');
+      writeFile(filePath, 'nested content');
+      expect(fs.readFileSync(filePath, 'utf-8')).toBe('nested content');
+    });
+  });
+
+  describe('fileExists', () => {
+    it('returns true for existing files', () => {
+      const filePath = path.join(tempDir, 'exists.txt');
+      fs.writeFileSync(filePath, 'content');
+      expect(fileExists(filePath)).toBe(true);
+    });
+
+    it('returns false for non-existent files', () => {
+      expect(fileExists(path.join(tempDir, 'missing.txt'))).toBe(false);
+    });
+  });
+
+  describe('getRelativePath', () => {
+    it('computes relative paths between files', () => {
+      const from = '/src/components/App.tsx';
+      const to = '/src/utils/helpers.ts';
+      const rel = getRelativePath(from, to);
+      expect(rel).toBe('../utils/helpers.ts');
+    });
+
+    it('prefixes with ./ for same-directory files', () => {
+      const from = '/src/App.tsx';
+      const to = '/src/utils.ts';
+      const rel = getRelativePath(from, to);
+      expect(rel).toBe('./utils.ts');
+    });
+  });
+
+  describe('ensureDir', () => {
+    it('creates directories recursively', () => {
+      const dirPath = path.join(tempDir, 'a', 'b', 'c');
+      ensureDir(dirPath);
+      expect(fs.existsSync(dirPath)).toBe(true);
+    });
+
+    it('does not throw for existing directories', () => {
+      expect(() => ensureDir(tempDir)).not.toThrow();
+    });
+  });
+
+  describe('getFileHash', () => {
+    it('returns consistent hashes for same content', () => {
+      const filePath1 = path.join(tempDir, 'file1.txt');
+      const filePath2 = path.join(tempDir, 'file2.txt');
+      fs.writeFileSync(filePath1, 'same content');
+      fs.writeFileSync(filePath2, 'same content');
+
+      expect(getFileHash(filePath1)).toBe(getFileHash(filePath2));
+    });
+
+    it('returns different hashes for different content', () => {
+      const filePath1 = path.join(tempDir, 'file1.txt');
+      const filePath2 = path.join(tempDir, 'file2.txt');
+      fs.writeFileSync(filePath1, 'content A');
+      fs.writeFileSync(filePath2, 'content B');
+
+      expect(getFileHash(filePath1)).not.toBe(getFileHash(filePath2));
+    });
+  });
+
+  describe('hashString', () => {
+    it('returns consistent hash for same input', () => {
+      expect(hashString('test')).toBe(hashString('test'));
+    });
+
+    it('returns different hash for different input', () => {
+      expect(hashString('test1')).not.toBe(hashString('test2'));
+    });
+  });
+});