import { describe, it, expect } from 'vitest';
import {
  extractImportsAndStrings, verifyRealTestContent, verifyRealTest,
} from './tdd-real-test-verifier.mjs';

describe('verifyRealTestContent', () => {
  it('rejects empty test body (no expect)', () => {
    const r = verifyRealTestContent('test("x", () => {})', ['app/Foo.mjs']);
    expect(r).toEqual({ valid: false, reason: 'no_expect_call' });
  });
  it('rejects content with no expect call (bare expect identifier)', () => {
    expect(verifyRealTestContent('const x = expect;', ['app/Foo.mjs'])).toEqual({ valid: false, reason: 'no_expect_call' });
  });
  it('rejects content with expect() but no test/it block', () => {
    expect(verifyRealTestContent('const r = expect(1);', ['app/Foo.mjs'])).toEqual({ valid: false, reason: 'no_test_block' });
  });
  it('rejects no coverage of edited files', () => {
    const content = `import { bar } from './bar.mjs'; test('t', () => { expect(bar()).toBe(1); });`;
    const r = verifyRealTestContent(content, ['app/Models/User.php']);
    expect(r).toEqual({ valid: false, reason: 'no_coverage_of_edited_files' });
  });
  it('accepts real test importing an edited file', () => {
    const content = `import { foo } from './foo.mjs'; test('t', () => { expect(foo()).toBe(1); });`;
    const r = verifyRealTestContent(content, ['tools/foo.mjs']);
    expect(r).toEqual({ valid: true });
  });
});

describe('extractImportsAndStrings', () => {
  it("includes import from path", () => {
    const result = extractImportsAndStrings("import {a} from './x.mjs'");
    expect(result).toContain('./x.mjs');
  });
  it("includes require path", () => {
    const result = extractImportsAndStrings("require('./y.mjs')");
    expect(result).toContain('./y.mjs');
  });
  it("includes string literal path", () => {
    const result = extractImportsAndStrings("const p = 'app/Models/User'");
    expect(result).toContain('app/Models/User');
  });
});

describe('verifyRealTestContent — coverage variants', () => {
  it('matches via string literal path not import', () => {
    const content = `test('t',()=>{ const p='tools/foo.mjs'; expect(p).toBeTruthy(); });`;
    const r = verifyRealTestContent(content, ['tools/foo.mjs']);
    expect(r).toEqual({ valid: true });
  });
  it('matches basename across extensions', () => {
    // import string './Foo.test.mjs' includes substring 'Foo' -> matches edited 'app/Foo.php'
    const content = `import './Foo.test.mjs'; test('t',()=>{ expect(1).toBe(1); });`;
    const r = verifyRealTestContent(content, ['app/Foo.php']);
    expect(r).toEqual({ valid: true });
  });
  it('empty editedFilesList → valid if expect+test', () => {
    const content = `test('t',()=>{ expect(1).toBe(1); });`;
    const r = verifyRealTestContent(content, []);
    expect(r).toEqual({ valid: true });
  });
  it('it() block also accepted', () => {
    const r = verifyRealTestContent(`it('x',()=>{expect(1).toBe(1)})`, []);
    expect(r).toEqual({ valid: true });
  });
  it('trivial expect(true).toBe(true) with import passes — acceptable residual', () => {
    const content = `import './foo.mjs'; test('t',()=>{expect(true).toBe(true)});`;
    const r = verifyRealTestContent(content, ['tools/foo.mjs']);
    expect(r).toEqual({ valid: true });
  });
});

describe('verifyRealTest — fs wrapper', () => {
  it('returns valid:true for good test content via readFile', () => {
    const r = verifyRealTest(
      '/x',
      ['tools/foo.mjs'],
      { readFile: () => "import './foo.mjs'; test('t',()=>{expect(1).toBe(1)})" },
    );
    expect(r).toEqual({ valid: true });
  });
  it('returns test_file_not_found on ENOENT', () => {
    const err = new Error('ENOENT: no such file');
    err.code = 'ENOENT';
    const r = verifyRealTest('/missing', [], { readFile: () => { throw err; } });
    expect(r).toEqual({ valid: false, reason: 'test_file_not_found' });
  });
  it('returns test_file_read_error on non-ENOENT errors (e.g. EACCES)', () => {
    const err = new Error('EACCES: permission denied');
    err.code = 'EACCES';
    const r = verifyRealTest('/forbidden', [], { readFile: () => { throw err; } });
    expect(r).toEqual({ valid: false, reason: 'test_file_read_error' });
  });
});