xtrm-tools 2.1.4 → 2.1.6

package/project-skills/tdd-guard/reporters/jest/src/JestReporter.test.ts

@@ -0,0 +1,302 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { JestReporter } from './JestReporter'
+import {
+  FileStorage,
+  MemoryStorage,
+  Config as TDDConfig,
+  DEFAULT_DATA_DIR,
+} from 'tdd-guard'
+import path from 'node:path'
+import {
+  createTest,
+  createTestResult,
+  createAggregatedResult,
+  createUnhandledError,
+  createModuleError,
+  createTestResultWithModuleError,
+} from './JestReporter.test-data'
+
+describe('JestReporter', () => {
+  let sut: ReturnType<typeof setupJestReporter>
+
+  beforeEach(() => {
+    sut = setupJestReporter()
+  })
+
+  describe('constructor', () => {
+    it('uses FileStorage by default', () => {
+      const reporter = new JestReporter()
+      expect(reporter['storage']).toBeInstanceOf(FileStorage)
+    })
+
+    it('accepts Storage instance in reporterOptions', () => {
+      const storage = new MemoryStorage()
+      const globalConfig = undefined
+      const reporterOptions = { storage }
+      const reporter = new JestReporter(globalConfig, reporterOptions)
+      expect(reporter['storage']).toBe(storage)
+    })
+
+    it('accepts projectRoot string in reporterOptions', () => {
+      const rootPath = '/some/project/root'
+      const globalConfig = undefined
+      const reporterOptions = { projectRoot: rootPath }
+      const reporter = new JestReporter(globalConfig, reporterOptions)
+
+      // Verify the storage is configured with the correct path
+      const fileStorage = reporter['storage'] as FileStorage
+      const config = fileStorage['config'] as TDDConfig
+      const expectedDataDir = path.join(
+        rootPath,
+        ...DEFAULT_DATA_DIR.split('/')
+      )
+      expect(config.dataDir).toBe(expectedDataDir)
+    })
+  })
+
+  describe('onTestResult', () => {
+    it('collects test results', () => {
+      const test = createTest()
+      const testResult = createTestResult()
+
+      sut.reporter.onTestResult(test, testResult)
+
+      expect(sut.reporter['testModules'].size).toBe(1)
+    })
+  })
+
+  describe('onRunComplete', () => {
+    it('saves test results to storage', async () => {
+      const test = createTest()
+      const testResult = createTestResult()
+      const aggregatedResult = createAggregatedResult()
+
+      // Collect test results first
+      sut.reporter.onTestResult(test, testResult)
+
+      // Run complete
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      // Verify results were saved
+      const parsed = await sut.getParsedData()
+      expect(parsed).toBeTruthy()
+      expect(parsed.testModules).toHaveLength(1)
+    })
+
+    it('includes test case details in output', async () => {
+      const test = createTest()
+      const testResult = createTestResult()
+      const aggregatedResult = createAggregatedResult()
+
+      // Collect test results
+      sut.reporter.onTestResult(test, testResult)
+
+      // Run complete
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      // Verify test details are included
+      const parsed = await sut.getParsedData()
+      const module = parsed.testModules[0]
+      expect(module.tests).toHaveLength(1)
+      expect(module.tests[0].name).toBe('should pass')
+      expect(module.tests[0].fullName).toBe('Example Suite should pass')
+      expect(module.tests[0].state).toBe('passed')
+    })
+
+    it('includes error details for failed tests', async () => {
+      const test = createTest()
+      const failedTestResult = createTestResult({ numFailingTests: 1 })
+      const aggregatedResult = createAggregatedResult()
+
+      // Collect test results
+      sut.reporter.onTestResult(test, failedTestResult)
+
+      // Run complete
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      // Verify error details are included
+      const parsed = await sut.getParsedData()
+      const module = parsed.testModules[0]
+      const failedTest = module.tests[0]
+      expect(failedTest.state).toBe('failed')
+      expect(failedTest.errors).toBeDefined()
+      expect(failedTest.errors).toHaveLength(1)
+      expect(failedTest.errors[0].message).toBe('expected 2 to be 3')
+    })
+
+    it('handles empty test runs', async () => {
+      // Run complete without any tests
+      await sut.reporter.onRunComplete(new Set(), createAggregatedResult())
+
+      // Verify empty output
+      const parsed = await sut.getParsedData()
+      expect(parsed.testModules).toEqual([])
+    })
+
+    it('includes unhandled errors in output', async () => {
+      const error = createUnhandledError()
+      const aggregatedResult = createAggregatedResult({
+        runExecError: error,
+      })
+
+      // Run complete with unhandled error
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      // Verify unhandled errors are included
+      const parsed = await sut.getParsedData()
+      expect(parsed.unhandledErrors).toBeDefined()
+      expect(parsed.unhandledErrors).toHaveLength(1)
+      expect(parsed.unhandledErrors[0].message).toBe(
+        'Cannot find module "./helpers"'
+      )
+      expect(parsed.unhandledErrors[0].name).toBe('Error')
+      expect(parsed.unhandledErrors[0].stack).toContain('imported from')
+    })
+
+    it('includes test run reason when tests pass', async () => {
+      const test = createTest()
+      const testResult = createTestResult()
+      const aggregatedResult = createAggregatedResult({
+        success: true,
+        numFailedTests: 0,
+      })
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      expect(parsed.reason).toBe('passed')
+    })
+
+    it('handles SerializableError without name property', async () => {
+      const aggregatedResult = createAggregatedResult({
+        runExecError: {
+          message: 'Module not found',
+          stack: 'at test.js:1:1',
+        },
+      })
+
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      expect(parsed.unhandledErrors[0].message).toBe('Module not found')
+      expect(parsed.unhandledErrors[0].name).toBe('Error')
+      expect(parsed.unhandledErrors[0].stack).toBe('at test.js:1:1')
+    })
+
+    it('includes module import errors as failed tests', async () => {
+      const test = createTest()
+      const testResult = createTestResultWithModuleError()
+      const aggregatedResult = createAggregatedResult()
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      const module = parsed.testModules[0]
+      expect(module.tests).toHaveLength(1)
+
+      const importErrorTest = module.tests[0]
+      expect(importErrorTest.name).toBe('Module failed to load (Error)')
+      expect(importErrorTest.fullName).toBe('Module failed to load (Error)')
+      expect(importErrorTest.state).toBe('failed')
+      expect(importErrorTest.errors).toHaveLength(1)
+      expect(importErrorTest.errors[0].message).toBe(
+        "Cannot find module './non-existent-module'"
+      )
+    })
+
+    it('preserves error stack trace from module import errors', async () => {
+      const test = createTest()
+      const moduleError = createModuleError({
+        message: "Cannot find module './helpers'",
+        stack:
+          "Error: Cannot find module './helpers'\n    at Function.Module._resolveFilename",
+        name: 'Error',
+      })
+      const testResult = createTestResultWithModuleError({
+        testExecError: moduleError,
+      })
+      const aggregatedResult = createAggregatedResult()
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      const importErrorTest = parsed.testModules[0].tests[0]
+
+      expect(importErrorTest.errors[0].stack).toBe(
+        "Error: Cannot find module './helpers'\n    at Function.Module._resolveFilename"
+      )
+      expect(importErrorTest.errors[0].name).toBe('Error')
+    })
+
+    it('uses error type in test name for module import errors', async () => {
+      const test = createTest()
+      const testResult = createTestResultWithModuleError({
+        testExecError: createModuleError({
+          message: 'Module parse failed',
+          stack: 'SyntaxError: Unexpected token',
+          name: 'SyntaxError',
+        }),
+      })
+      const aggregatedResult = createAggregatedResult()
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      const importErrorTest = parsed.testModules[0].tests[0]
+
+      expect(importErrorTest.name).toBe('Module failed to load (SyntaxError)')
+      expect(importErrorTest.fullName).toBe(
+        'Module failed to load (SyntaxError)'
+      )
+    })
+
+    it('handles SerializableError with type field for module import errors', async () => {
+      const test = createTest()
+      const testResult = createTestResultWithModuleError({
+        testExecError: createModuleError({
+          message: 'Module error',
+          stack: 'at test.js:1',
+          type: 'ReferenceError',
+          code: 'ERR_MODULE_NOT_FOUND',
+        }),
+      })
+      const aggregatedResult = createAggregatedResult()
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      const importErrorTest = parsed.testModules[0].tests[0]
+
+      expect(importErrorTest.name).toBe(
+        'Module failed to load (ReferenceError)'
+      )
+      expect(importErrorTest.errors[0].name).toBe('ReferenceError')
+      expect(importErrorTest.errors[0].operator).toBe('ERR_MODULE_NOT_FOUND')
+    })
+  })
+})
+
+// Test setup helper function
+function setupJestReporter() {
+  const storage = new MemoryStorage()
+  const globalConfig = undefined
+  const reporterOptions = { storage }
+  const reporter = new JestReporter(globalConfig, reporterOptions)
+
+  // Helper to get parsed test data
+  const getParsedData = async () => {
+    const savedData = await storage.getTest()
+    return savedData ? JSON.parse(savedData) : null
+  }
+
+  return {
+    reporter,
+    storage,
+    getParsedData,
+  }
+}

package/project-skills/tdd-guard/reporters/jest/src/JestReporter.ts

@@ -0,0 +1,201 @@
+import { BaseReporter, Config } from '@jest/reporters'
+import type { Test, TestResult, AggregatedResult } from '@jest/reporters'
+import type { AssertionResult } from '@jest/test-result'
+import type { TestContext } from '@jest/test-result'
+import { Storage, FileStorage, Config as TDDConfig } from 'tdd-guard'
+import type {
+  TDDGuardReporterOptions,
+  CapturedError,
+  CapturedTest,
+  CapturedTestRun,
+  CapturedUnhandledError,
+  CapturedModule,
+} from './types'
+
+export class JestReporter extends BaseReporter {
+  private readonly storage: Storage
+  private readonly testModules: Map<
+    string,
+    { test: Test; testResult: TestResult }
+  > = new Map()
+
+  constructor(
+    _globalConfig?: Config.GlobalConfig,
+    reporterOptions?: TDDGuardReporterOptions
+  ) {
+    super()
+    this.storage = this.initializeStorage(reporterOptions)
+  }
+
+  private initializeStorage(options?: TDDGuardReporterOptions): Storage {
+    if (options?.storage) {
+      return options.storage
+    }
+
+    if (options?.projectRoot) {
+      const config = new TDDConfig({ projectRoot: options.projectRoot })
+      return new FileStorage(config)
+    }
+
+    return new FileStorage()
+  }
+
+  override onTestResult(test: Test, testResult: TestResult): void {
+    this.testModules.set(test.path, { test, testResult })
+  }
+
+  override async onRunComplete(
+    _contexts: Set<TestContext>,
+    results: AggregatedResult
+  ): Promise<void> {
+    const output: CapturedTestRun = {
+      testModules: this.buildTestModules(),
+      unhandledErrors: this.buildUnhandledErrors(results),
+      reason: this.determineTestRunReason(results),
+    }
+
+    await this.storage.saveTest(JSON.stringify(output, null, 2))
+  }
+
+  private determineTestRunReason(
+    results: AggregatedResult
+  ): 'passed' | 'failed' | 'interrupted' {
+    if (results.wasInterrupted) {
+      return 'interrupted'
+    }
+
+    if (results.numFailedTestSuites === 0 && results.numTotalTestSuites > 0) {
+      return 'passed'
+    }
+
+    return 'failed'
+  }
+
+  private mapTestResult(test: AssertionResult): CapturedTest {
+    const result: CapturedTest = {
+      name: test.title,
+      fullName: test.fullName,
+      state: test.status,
+    }
+
+    // Process failure details if present
+    if (test.failureMessages.length > 0) {
+      result.errors = this.processTestErrors(test)
+    }
+
+    return result
+  }
+
+  private processTestErrors(test: AssertionResult): CapturedError[] {
+    if (test.failureDetails.length === 0) {
+      return test.failureMessages.map((message) => ({ message }))
+    }
+
+    return test.failureDetails.map((detail: unknown, index: number) => {
+      const message = test.failureMessages[index] || ''
+      const error: CapturedError = { message }
+
+      if (detail && typeof detail === 'object') {
+        this.extractErrorDetails(error, detail as Record<string, unknown>)
+        this.parseExpectedActualFromMessage(error, message)
+      }
+
+      return error
+    })
+  }
+
+  private extractErrorDetails(
+    error: CapturedError,
+    obj: Record<string, unknown>
+  ): void {
+    if ('actual' in obj) error.actual = String(obj.actual)
+    if ('expected' in obj) error.expected = String(obj.expected)
+    if ('showDiff' in obj) error.showDiff = Boolean(obj.showDiff)
+    if ('operator' in obj) error.operator = String(obj.operator)
+    if ('diff' in obj) error.diff = String(obj.diff)
+    if ('name' in obj) error.name = String(obj.name)
+    if ('ok' in obj) error.ok = Boolean(obj.ok)
+    if ('stack' in obj) error.stack = String(obj.stack)
+  }
+
+  private parseExpectedActualFromMessage(
+    error: CapturedError,
+    message: string
+  ): void {
+    if (!error.expected || !error.actual) {
+      const expectedMatch = /Expected:\s*(\d+)/.exec(message)
+      const receivedMatch = /Received:\s*(\d+)/.exec(message)
+      if (expectedMatch && !error.expected) error.expected = expectedMatch[1]
+      if (receivedMatch && !error.actual) error.actual = receivedMatch[1]
+    }
+  }
+
+  private createTestFromExecError(execError: unknown): CapturedTest {
+    const errorObj = execError as Record<string, unknown>
+    const message = String(errorObj.message ?? 'Unknown error')
+
+    const error: CapturedError = {
+      message,
+      name: typeof errorObj.name === 'string' ? errorObj.name : 'Error',
+      stack: typeof errorObj.stack === 'string' ? errorObj.stack : undefined,
+    }
+
+    // Extract additional fields from Jest's SerializableError
+    if ('code' in errorObj && errorObj.code !== undefined) {
+      error.operator = String(errorObj.code)
+    }
+    if ('type' in errorObj && typeof errorObj.type === 'string') {
+      error.name = errorObj.type
+    }
+
+    const errorType = error.name ?? 'Error'
+    const testName = `Module failed to load (${errorType})`
+
+    return {
+      name: testName,
+      fullName: testName,
+      state: 'failed',
+      errors: [error],
+    }
+  }
+
+  private buildTestModules(): CapturedModule[] {
+    return Array.from(this.testModules.entries()).map(([path, data]) => {
+      const { testResult } = data
+
+      // Handle module/import errors
+      if (testResult.testExecError && testResult.testResults.length === 0) {
+        return {
+          moduleId: path,
+          tests: [this.createTestFromExecError(testResult.testExecError)],
+        }
+      }
+
+      return {
+        moduleId: path,
+        tests: testResult.testResults.map((test: AssertionResult) =>
+          this.mapTestResult(test)
+        ),
+      }
+    })
+  }
+
+  private buildUnhandledErrors(
+    results: AggregatedResult
+  ): CapturedUnhandledError[] {
+    if (!results.runExecError) {
+      return []
+    }
+
+    const error = results.runExecError
+    const errorObj = error as Record<string, unknown>
+
+    return [
+      {
+        message: String(errorObj.message ?? 'Unknown error'),
+        name: typeof errorObj.name === 'string' ? errorObj.name : 'Error',
+        stack: typeof errorObj.stack === 'string' ? errorObj.stack : undefined,
+      },
+    ]
+  }
+}

package/project-skills/tdd-guard/reporters/jest/src/index.ts

@@ -0,0 +1,4 @@
+import { JestReporter } from './JestReporter'
+
+export { JestReporter }
+export default JestReporter

package/project-skills/tdd-guard/reporters/jest/src/types.ts

@@ -0,0 +1,42 @@
+import type { Storage } from 'tdd-guard'
+
+export interface TDDGuardReporterOptions {
+  storage?: Storage
+  projectRoot?: string
+}
+
+export interface CapturedError {
+  message: string
+  actual?: string
+  expected?: string
+  showDiff?: boolean
+  operator?: string
+  diff?: string
+  name?: string
+  ok?: boolean
+  stack?: string
+}
+
+export interface CapturedTest {
+  name: string
+  fullName: string
+  state: string
+  errors?: CapturedError[]
+}
+
+export interface CapturedModule {
+  moduleId: string
+  tests: CapturedTest[]
+}
+
+export interface CapturedUnhandledError {
+  message: string
+  name: string
+  stack?: string
+}
+
+export interface CapturedTestRun {
+  testModules: CapturedModule[]
+  unhandledErrors?: CapturedUnhandledError[]
+  reason?: 'passed' | 'failed' | 'interrupted'
+}

package/project-skills/tdd-guard/reporters/jest/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["**/*.test.ts", "**/*.spec.ts"]
+}

package/project-skills/tdd-guard/reporters/vitest/src/VitestReporter.test-data.ts

@@ -0,0 +1,85 @@
+import type { TestModule, TestCase, TestResult } from 'vitest/node'
+import type { SerializedError } from '@vitest/utils'
+
+const DEFAULT_MODULE_ID = '/test/example.test.ts'
+const DEFAULT_TEST_NAME = 'should pass'
+const DEFAULT_TEST_FULL_NAME = 'Example Suite > should pass'
+
+// Helper to create a valid TestResult for a given state
+export function createTestResult(state: TestResult['state']): TestResult {
+  switch (state) {
+    case 'failed':
+      return { state: 'failed', errors: [] }
+    case 'passed':
+      return { state: 'passed', errors: undefined }
+    case 'skipped':
+      return { state: 'skipped', errors: undefined, note: undefined }
+    case 'pending':
+      return { state: 'pending', errors: undefined }
+  }
+}
+
+// Creates a minimal TestModule mock for testing
+function createTestModule(props: {
+  moduleId: string
+  errors?: () => SerializedError[]
+}): TestModule {
+  return {
+    moduleId: props.moduleId,
+    errors: props.errors ?? ((): SerializedError[] => []),
+  } as TestModule
+}
+
+export function testModule(overrides?: {
+  moduleId?: string
+  errors?: () => SerializedError[]
+}): TestModule {
+  return createTestModule({
+    moduleId: overrides?.moduleId ?? DEFAULT_MODULE_ID,
+    errors: overrides?.errors,
+  })
+}
+
+export function createTestCase(overrides?: Partial<TestCase>): TestCase {
+  const defaultModule = createTestModule({ moduleId: DEFAULT_MODULE_ID })
+
+  return {
+    name: DEFAULT_TEST_NAME,
+    fullName: DEFAULT_TEST_FULL_NAME,
+    module: defaultModule,
+    result: () => ({ state: 'passed', errors: [] }) as TestResult,
+    ...overrides,
+  } as TestCase
+}
+
+export function failedTestCase(overrides?: Partial<TestCase>): TestCase {
+  return createTestCase({
+    name: 'should fail',
+    fullName: 'Example Suite > should fail',
+    result: () =>
+      ({
+        state: 'failed',
+        errors: [
+          {
+            message: 'expected 2 to be 3',
+            stack: 'Error: expected 2 to be 3\n    at test.ts:7:19',
+            expected: '3',
+            actual: '2',
+          },
+        ],
+      }) as TestResult,
+    ...overrides,
+  })
+}
+
+export function createUnhandledError(
+  overrides: Partial<SerializedError> = {}
+): SerializedError {
+  return {
+    name: 'Error',
+    message: 'Cannot find module "./helpers"',
+    stack:
+      "Error: Cannot find module './helpers' imported from '/src/example.test.ts'",
+    ...overrides,
+  }
+}