tlc-claude-code 2.5.0 → 2.6.1

package/server/lib/e2e/framework-detector.test.js

@@ -0,0 +1,94 @@
+import { afterEach, describe, it } from 'vitest';
+const assert = require('node:assert');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { detectE2eFramework } = require('./framework-detector.js');
+
+const tempDirs = [];
+
+function createProjectDir() {
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'framework-detector-'));
+  tempDirs.push(projectDir);
+  return projectDir;
+}
+
+function writePackageJson(projectDir, packageJson) {
+  fs.writeFileSync(
+    path.join(projectDir, 'package.json'),
+    JSON.stringify(packageJson, null, 2)
+  );
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+  }
+});
+
+describe('detectE2eFramework', () => {
+  it('returns playwright when a Playwright config is present', () => {
+    const projectDir = createProjectDir();
+    writePackageJson(projectDir, {
+      name: 'playwright-project',
+      devDependencies: {},
+    });
+    fs.writeFileSync(path.join(projectDir, 'playwright.config.ts'), 'export default {};');
+
+    const result = detectE2eFramework({ projectDir, fs });
+
+    assert.deepStrictEqual(result, { framework: 'playwright' });
+  });
+
+  it('returns supertest when package.json declares supertest', () => {
+    const projectDir = createProjectDir();
+    writePackageJson(projectDir, {
+      name: 'supertest-project',
+      devDependencies: {
+        supertest: '^7.0.0',
+      },
+    });
+
+    const result = detectE2eFramework({ projectDir, fs });
+
+    assert.deepStrictEqual(result, { framework: 'supertest' });
+  });
+
+  it('prefers playwright when both signals are present', () => {
+    const projectDir = createProjectDir();
+    writePackageJson(projectDir, {
+      name: 'mixed-project',
+      dependencies: {
+        supertest: '^7.0.0',
+      },
+    });
+    fs.writeFileSync(path.join(projectDir, 'playwright.config.ts'), 'export default {};');
+
+    const result = detectE2eFramework({ projectDir, fs });
+
+    assert.deepStrictEqual(result, { framework: 'playwright' });
+  });
+
+  it('returns none when neither signal is present', () => {
+    const projectDir = createProjectDir();
+    writePackageJson(projectDir, {
+      name: 'plain-project',
+      dependencies: {
+        express: '^4.0.0',
+      },
+    });
+
+    const result = detectE2eFramework({ projectDir, fs });
+
+    assert.deepStrictEqual(result, { framework: 'none' });
+  });
+
+  it('returns none when package.json is missing', () => {
+    const projectDir = createProjectDir();
+
+    const result = detectE2eFramework({ projectDir, fs });
+
+    assert.deepStrictEqual(result, { framework: 'none' });
+  });
+});

package/server/lib/e2e/log-assertions.js

@@ -0,0 +1,107 @@
+'use strict';
+
+function normalizeEntry(entry) {
+  if (typeof entry === 'string') {
+    const trimmed = entry.trim();
+    const upper = trimmed.toUpperCase();
+
+    if (upper.includes('ERROR')) {
+      return { level: 'ERROR', message: trimmed };
+    }
+
+    if (upper.includes('WARN')) {
+      return { level: 'WARN', message: trimmed };
+    }
+
+    return null;
+  }
+
+  if (!entry || typeof entry !== 'object') {
+    return null;
+  }
+
+  const rawLevel = typeof entry.level === 'string'
+    ? entry.level
+    : typeof entry.severity === 'string'
+      ? entry.severity
+      : null;
+
+  const rawMessage = typeof entry.message === 'string'
+    ? entry.message
+    : typeof entry.msg === 'string'
+      ? entry.msg
+      : typeof entry.content === 'string'
+        ? entry.content
+        : null;
+
+  if (!rawLevel || !rawMessage) {
+    return null;
+  }
+
+  const normalizedLevel = rawLevel.toUpperCase();
+
+  if (normalizedLevel === 'WARNING') {
+    return { level: 'WARN', message: rawMessage };
+  }
+
+  if (normalizedLevel === 'WARN' || normalizedLevel === 'ERROR') {
+    return { level: normalizedLevel, message: rawMessage };
+  }
+
+  return null;
+}
+
+function createMemoryCollector(buffer) {
+  const startIndex = buffer.length;
+  let stopIndex = null;
+
+  function getEntries(level) {
+    const endIndex = stopIndex === null ? buffer.length : stopIndex;
+    const entries = buffer.slice(startIndex, endIndex);
+
+    return entries
+      .map(normalizeEntry)
+      .filter((entry) => entry && entry.level === level)
+      .map((entry) => entry.message);
+  }
+
+  return {
+    getErrors() {
+      return getEntries('ERROR');
+    },
+
+    getWarnings() {
+      return getEntries('WARN');
+    },
+
+    assertClean() {
+      const errors = this.getErrors();
+
+      if (errors.length > 0) {
+        throw new Error(`Expected no ERROR logs, but found:\n${errors.join('\n')}`);
+      }
+    },
+
+    stop() {
+      if (stopIndex === null) {
+        stopIndex = buffer.length;
+      }
+    },
+  };
+}
+
+function createLogCollector(options) {
+  const { logSource } = options || {};
+
+  if (logSource !== 'memory' && !Array.isArray(logSource)) {
+    throw new TypeError('createLogCollector requires logSource "memory" or an array buffer');
+  }
+
+  const buffer = logSource === 'memory' ? [] : logSource;
+
+  return createMemoryCollector(buffer);
+}
+
+module.exports = {
+  createLogCollector,
+};

package/server/lib/e2e/log-assertions.test.js

@@ -0,0 +1,68 @@
+'use strict';
+
+import { describe, it, expect } from 'vitest';
+
+const { createLogCollector } = require('./log-assertions.js');
+
+describe('createLogCollector', () => {
+  it('collects warning and error messages from an in-memory buffer', () => {
+    const buffer = [];
+    const collector = createLogCollector({ logSource: buffer });
+
+    buffer.push({ level: 'info', message: 'startup complete' });
+    buffer.push({ level: 'warn', message: 'slow request' });
+    buffer.push({ severity: 'warning', message: 'deprecated config' });
+    buffer.push({ level: 'error', message: 'database unavailable' });
+    buffer.push('plain ERROR line');
+
+    expect(collector.getWarnings()).toEqual([
+      'slow request',
+      'deprecated config',
+    ]);
+    expect(collector.getErrors()).toEqual([
+      'database unavailable',
+      'plain ERROR line',
+    ]);
+  });
+
+  it('assertClean passes when only warnings are present', () => {
+    const buffer = [];
+    const collector = createLogCollector({ logSource: buffer });
+
+    buffer.push({ level: 'warn', message: 'retrying request' });
+
+    expect(() => collector.assertClean()).not.toThrow();
+  });
+
+  it('assertClean throws with the error contents in the message', () => {
+    const buffer = [];
+    const collector = createLogCollector({ logSource: buffer });
+
+    buffer.push({ level: 'error', message: 'first failure' });
+    buffer.push('ERROR second failure');
+
+    expect(() => collector.assertClean()).toThrowError(
+      /first failure[\s\S]*ERROR second failure/
+    );
+  });
+
+  it('stop freezes the observed range', () => {
+    const buffer = [];
+    const collector = createLogCollector({ logSource: buffer });
+
+    buffer.push({ level: 'warn', message: 'before stop' });
+    collector.stop();
+    buffer.push({ level: 'error', message: 'after stop' });
+
+    expect(collector.getWarnings()).toEqual(['before stop']);
+    expect(collector.getErrors()).toEqual([]);
+  });
+
+  it('supports a standalone memory source for tests', () => {
+    const collector = createLogCollector({ logSource: 'memory' });
+
+    expect(collector.getWarnings()).toEqual([]);
+    expect(collector.getErrors()).toEqual([]);
+    expect(() => collector.assertClean()).not.toThrow();
+  });
+});

package/server/lib/e2e/test-generator.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const path = require('node:path');
+
+const { parseAcceptanceCriteria } = require('./acceptance-parser.js');
+
+function slugify(value) {
+  const slug = String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/-+/g, '-')
+    .trim();
+
+  return slug || 'scenario';
+}
+
+function escapeSingleQuotes(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+function resolveScenarioName(scenario, index) {
+  if (typeof scenario === 'string') {
+    return `Scenario ${index + 1}`;
+  }
+
+  return scenario.title
+    || scenario.name
+    || scenario.slug
+    || scenario.id
+    || `Scenario ${index + 1}`;
+}
+
+function resolveScenarioSlug(scenario, index) {
+  if (scenario && typeof scenario === 'object' && typeof scenario.slug === 'string' && scenario.slug.trim()) {
+    return slugify(scenario.slug);
+  }
+
+  return slugify(resolveScenarioName(scenario, index));
+}
+
+function resolvePlanContent(scenario) {
+  if (typeof scenario === 'string') {
+    return scenario;
+  }
+
+  if (!scenario || typeof scenario !== 'object') {
+    return '';
+  }
+
+  return scenario.planContent
+    || scenario.acceptanceCriteria
+    || scenario.content
+    || scenario.description
+    || '';
+}
+
+function buildPlaywrightContent(scenarioName, criteria) {
+  const tests = criteria.map(({ criterion }) => `  test('${escapeSingleQuotes(criterion)}', async ({ page }) => {
+    // TODO: Implement the browser flow for this acceptance criterion.
+    // TODO: Assert application logs remain clean for this flow.
+  });
+`).join('\n');
+
+  return `'use strict';
+
+const { test } = require('@playwright/test');
+
+test.describe('${escapeSingleQuotes(scenarioName)}', () => {
+  test.afterEach(async ({ page }, testInfo) => {
+    await page.screenshot({
+      path: testInfo.outputPath('screenshot.png'),
+      fullPage: true,
+    });
+  });
+
+${tests}});
+`;
+}
+
+function buildSupertestContent(scenarioName, criteria) {
+  const tests = criteria.map(({ criterion }) => `  it('${escapeSingleQuotes(criterion)}', async () => {
+    // TODO: Implement the API flow with supertest.
+    // TODO: Assert application logs remain clean for this flow.
+  });
+`).join('\n');
+
+  return `'use strict';
+
+const { afterEach, describe, it } = require('vitest');
+const request = require('supertest');
+
+describe('${escapeSingleQuotes(scenarioName)}', () => {
+  afterEach(async () => {
+    // TODO: Capture a screenshot or response artifact after each test.
+  });
+
+${tests}});
+`;
+}
+
+function buildFileContent(scenarioName, criteria, framework) {
+  if (framework === 'playwright') {
+    return buildPlaywrightContent(scenarioName, criteria);
+  }
+
+  if (framework === 'supertest') {
+    return buildSupertestContent(scenarioName, criteria);
+  }
+
+  throw new Error(`Unsupported E2E framework: ${framework}`);
+}
+
+function generateE2eTests(options) {
+  const {
+    scenarios = [],
+    framework,
+    outputDir = '',
+  } = options || {};
+
+  const files = [];
+  const skipped = [];
+
+  for (const [index, scenario] of scenarios.entries()) {
+    const scenarioName = resolveScenarioName(scenario, index);
+    const slug = resolveScenarioSlug(scenario, index);
+    const planContent = resolvePlanContent(scenario);
+    const parsedCriteria = parseAcceptanceCriteria({ planContent });
+    const actionableCriteria = [];
+
+    for (const item of parsedCriteria) {
+      if (item.type === 'manual') {
+        skipped.push({
+          slug,
+          criterion: item.criterion,
+          type: item.type,
+        });
+        continue;
+      }
+
+      actionableCriteria.push(item);
+    }
+
+    if (actionableCriteria.length === 0) {
+      continue;
+    }
+
+    files.push({
+      path: path.join(outputDir, 'e2e', `${slug}.test.ts`),
+      content: buildFileContent(scenarioName, actionableCriteria, framework),
+    });
+  }
+
+  return { files, skipped };
+}
+
+module.exports = {
+  generateE2eTests,
+};

package/server/lib/e2e/test-generator.test.js

@@ -0,0 +1,121 @@
+'use strict';
+
+import { describe, it } from 'vitest';
+const assert = require('node:assert');
+
+const { generateE2eTests } = require('./test-generator.js');
+
+describe('generateE2eTests', () => {
+  it('generates playwright test files from parsed acceptance criteria', () => {
+    const result = generateE2eTests({
+      scenarios: [
+        {
+          title: 'User Login',
+          planContent: `
+- [ ] User can click the sign in button
+Given the user is on the login page
+When they click the sign in button
+Then the dashboard page should load
+`,
+        },
+      ],
+      framework: 'playwright',
+      outputDir: 'generated',
+    });
+
+    assert.deepStrictEqual(result.skipped, []);
+    assert.strictEqual(result.files.length, 1);
+    assert.strictEqual(result.files[0].path, 'generated/e2e/user-login.test.ts');
+    assert.match(result.files[0].content, /const \{ test \} = require\('@playwright\/test'\);/);
+    assert.match(result.files[0].content, /test\.afterEach\(async \(\{ page \}, testInfo\) =>/);
+    assert.match(result.files[0].content, /path: testInfo\.outputPath\('screenshot\.png'\)/);
+    assert.match(result.files[0].content, /test\('User can click the sign in button', async \(\{ page \}\) =>/);
+    assert.match(result.files[0].content, /test\('the dashboard page should load', async \(\{ page \}\) =>/);
+    assert.match(result.files[0].content, /Assert application logs remain clean for this flow\./);
+  });
+
+  it('generates supertest test files with an afterEach artifact hook', () => {
+    const result = generateE2eTests({
+      scenarios: [
+        {
+          slug: 'health-check',
+          acceptanceCriteria: `
+- [ ] GET /health endpoint returns 200
+`,
+        },
+      ],
+      framework: 'supertest',
+      outputDir: '',
+    });
+
+    assert.deepStrictEqual(result.skipped, []);
+    assert.strictEqual(result.files.length, 1);
+    assert.strictEqual(result.files[0].path, 'e2e/health-check.test.ts');
+    assert.match(result.files[0].content, /const \{ afterEach, describe, it \} = require\('vitest'\);/);
+    assert.match(result.files[0].content, /const request = require\('supertest'\);/);
+    assert.match(result.files[0].content, /afterEach\(async \(\) =>/);
+    assert.match(result.files[0].content, /Capture a screenshot or response artifact after each test\./);
+    assert.match(result.files[0].content, /it\('GET \/health endpoint returns 200', async \(\) =>/);
+  });
+
+  it('skips manual criteria while still generating files for automatable tests', () => {
+    const result = generateE2eTests({
+      scenarios: [
+        {
+          title: 'Mixed Coverage',
+          planContent: `
+Data is retained for 30 days.
+- [ ] User can click the export button
+`,
+        },
+      ],
+      framework: 'playwright',
+      outputDir: 'artifacts',
+    });
+
+    assert.deepStrictEqual(result.skipped, [
+      {
+        slug: 'mixed-coverage',
+        criterion: 'Data is retained for 30 days.',
+        type: 'manual',
+      },
+    ]);
+    assert.strictEqual(result.files.length, 1);
+    assert.strictEqual(result.files[0].path, 'artifacts/e2e/mixed-coverage.test.ts');
+    assert.match(result.files[0].content, /test\('User can click the export button'/);
+    assert.doesNotMatch(result.files[0].content, /Data is retained for 30 days\./);
+  });
+
+  it('omits files for scenarios that only produce manual criteria', () => {
+    const result = generateE2eTests({
+      scenarios: [
+        {
+          title: 'Manual Review',
+          planContent: 'Data is retained for 30 days.',
+        },
+      ],
+      framework: 'supertest',
+      outputDir: 'tmp',
+    });
+
+    assert.deepStrictEqual(result.files, []);
+    assert.deepStrictEqual(result.skipped, [
+      {
+        slug: 'manual-review',
+        criterion: 'Data is retained for 30 days.',
+        type: 'manual',
+      },
+    ]);
+  });
+
+  it('throws for unsupported frameworks', () => {
+    assert.throws(
+      () => generateE2eTests({
+        scenarios: [{ title: 'User Login', planContent: '- [ ] User can click the sign in button' }],
+        framework: 'cypress',
+        outputDir: 'generated',
+      }),
+      /Unsupported E2E framework: cypress/
+    );
+  });
+});