xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,199 +0,0 @@
-import type { Test, TestResult, AggregatedResult } from '@jest/reporters'
-import type { Config } from '@jest/types'
-
-// Create a minimal snapshot object that satisfies the type requirements
-const createSnapshot = (): TestResult['snapshot'] =>
-  ({
-    added: 0,
-    didUpdate: false,
-    failure: false,
-    filesAdded: 0,
-    filesRemoved: 0,
-    filesRemovedList: [],
-    filesUnmatched: 0,
-    filesUpdated: 0,
-    matched: 0,
-    total: 0,
-    unchecked: 0,
-    uncheckedKeysByFile: [],
-    unmatched: 0,
-    updated: 0,
-    // Additional properties that might be required by different versions
-    fileDeleted: false,
-    uncheckedKeys: [],
-  }) as TestResult['snapshot']
-
-// Create a minimal snapshot summary for AggregatedResult
-const createSnapshotSummary = (): AggregatedResult['snapshot'] =>
-  ({
-    added: 0,
-    didUpdate: false,
-    failure: false,
-    filesAdded: 0,
-    filesRemoved: 0,
-    filesRemovedList: [],
-    filesUnmatched: 0,
-    filesUpdated: 0,
-    matched: 0,
-    total: 0,
-    unchecked: 0,
-    uncheckedKeysByFile: [],
-    unmatched: 0,
-    updated: 0,
-  }) as AggregatedResult['snapshot']
-
-// Create a minimal Test object
-export function createTest(overrides?: Partial<Test>): Test {
-  // For test purposes, we create minimal mock implementations
-  const mockContext = {
-    config: {} as Config.ProjectConfig,
-    hasteFS: {} as never, // Using never since we don't access these properties
-    moduleMap: {} as never, // Using never since we don't access these properties
-    resolver: {} as never, // Using never since we don't access these properties
-  }
-
-  return {
-    context: mockContext,
-    duration: 100,
-    path: '/test/example.test.ts',
-    ...overrides,
-  } as Test
-}
-
-// Create a minimal TestResult object
-export function createTestResult(overrides?: Partial<TestResult>): TestResult {
-  const base: TestResult = {
-    leaks: false,
-    numFailingTests: 0,
-    numPassingTests: 1,
-    numPendingTests: 0,
-    numTodoTests: 0,
-    openHandles: [],
-    perfStats: {
-      end: 1000,
-      runtime: 100,
-      slow: false,
-      start: 900,
-      loadTestEnvironmentEnd: 950,
-      loadTestEnvironmentStart: 920,
-      setupAfterEnvEnd: 980,
-      setupAfterEnvStart: 960,
-      setupFilesEnd: 940,
-      setupFilesStart: 930,
-    },
-    skipped: false,
-    snapshot: createSnapshot(),
-    testExecError: undefined,
-    testFilePath: '/test/example.test.ts',
-    testResults: [
-      {
-        ancestorTitles: ['Example Suite'],
-        duration: 5,
-        failureDetails: [],
-        failureMessages: [],
-        fullName: 'Example Suite should pass',
-        invocations: 1,
-        location: undefined,
-        numPassingAsserts: 0,
-        retryReasons: [],
-        status: 'passed',
-        title: 'should pass',
-      },
-    ],
-    ...overrides,
-  }
-
-  // If test is failing, update the test results
-  if (overrides?.numFailingTests && overrides.numFailingTests > 0) {
-    base.testResults = [
-      {
-        ancestorTitles: ['Example Suite'],
-        duration: 5,
-        failureDetails: [{}],
-        failureMessages: ['expected 2 to be 3'],
-        fullName: 'Example Suite should fail',
-        invocations: 1,
-        location: undefined,
-        numPassingAsserts: 0,
-        retryReasons: [],
-        status: 'failed',
-        title: 'should fail',
-      },
-    ]
-  }
-
-  return base
-}
-
-// Create a minimal AggregatedResult object
-export function createAggregatedResult(
-  overrides?: Partial<AggregatedResult>
-): AggregatedResult {
-  return {
-    numFailedTestSuites: 0,
-    numFailedTests: 0,
-    numPassedTestSuites: 1,
-    numPassedTests: 1,
-    numPendingTestSuites: 0,
-    numPendingTests: 0,
-    numRuntimeErrorTestSuites: 0,
-    numTodoTests: 0,
-    numTotalTestSuites: 1,
-    numTotalTests: 1,
-    openHandles: [],
-    runExecError: undefined,
-    snapshot: createSnapshotSummary(),
-    startTime: Date.now(),
-    success: true,
-    testResults: [],
-    wasInterrupted: false,
-    ...overrides,
-  }
-}
-
-export function createUnhandledError(
-  overrides: Partial<{ name: string; message: string; stack: string }> = {}
-): AggregatedResult['runExecError'] {
-  return {
-    message: overrides.message ?? 'Cannot find module "./helpers"',
-    stack:
-      overrides.stack ??
-      "Error: Cannot find module './helpers' imported from '/src/example.test.ts'",
-    ...(overrides.name && { name: overrides.name }),
-    // SerializableError might have additional properties but these are the required ones
-  }
-}
-
-// Create a module error (testExecError) for import failures
-export function createModuleError(
-  overrides: Partial<{
-    name: string
-    message: string
-    stack: string
-    type: string
-    code: string
-  }> = {}
-): TestResult['testExecError'] {
-  return {
-    message: overrides.message ?? "Cannot find module './non-existent-module'",
-    stack:
-      overrides.stack ??
-      "Error: Cannot find module './non-existent-module'\n    at Resolver.resolveModule",
-    ...(overrides.name && { name: overrides.name }),
-    ...(overrides.type && { type: overrides.type }),
-    ...(overrides.code && { code: overrides.code }),
-  }
-}
-
-// Create a TestResult with module import error
-export function createTestResultWithModuleError(
-  overrides?: Partial<TestResult>
-): TestResult {
-  return createTestResult({
-    testExecError: createModuleError(),
-    testResults: [], // No test results when module fails to load
-    numFailingTests: 0,
-    numPassingTests: 0,
-    ...overrides,
-  })
-}

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

@@ -1,302 +0,0 @@
-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

@@ -1,201 +0,0 @@
-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

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