xtrm-tools 2.0.0

package/project-skills/tdd-guard/test/integration/test-context.test.ts

@@ -0,0 +1,66 @@
+import { describe, test, expect, beforeEach } from 'vitest'
+import { VitestReporter } from 'tdd-guard-vitest'
+import { TestResultsProcessor } from '../../src/processors'
+import { MemoryStorage } from '../../src/storage/MemoryStorage'
+import { testData } from '../utils'
+
+describe('Test Context', () => {
+  describe('reporter and processor handle module import errors correctly', () => {
+    let storage: MemoryStorage
+    let reporter: VitestReporter
+    let processor: TestResultsProcessor
+    let result: string
+
+    beforeEach(async () => {
+      // Setup
+      storage = new MemoryStorage()
+      reporter = new VitestReporter(storage)
+      processor = new TestResultsProcessor()
+
+      // Given a module with import error
+      const moduleWithError = testData.testModule({
+        moduleId: '/src/utils/helpers.test.ts',
+      })
+
+      // And an import error
+      const importError = testData.createUnhandledError()
+
+      // When the reporter processes the module with error
+      reporter.onTestModuleCollected(moduleWithError)
+      await reporter.onTestRunEnd([], [importError])
+
+      // And the processor formats the stored data
+      const storedData = await storage.getTest()
+      expect(storedData).toBeTruthy()
+      result = processor.process(storedData!)
+    })
+
+    test('shows the module as passed with 0 tests', () => {
+      expect(result).toContain('✓ /src/utils/helpers.test.ts (0 tests)')
+    })
+
+    test('displays unhandled errors section', () => {
+      expect(result).toContain('Unhandled Errors:')
+    })
+
+    test('shows error name and message', () => {
+      expect(result).toContain('× Error: Cannot find module "./helpers"')
+    })
+
+    test('includes stack trace header', () => {
+      expect(result).toContain('Stack:')
+    })
+
+    test('shows import location in stack trace', () => {
+      expect(result).toContain('imported from')
+    })
+
+    test('summary shows 1 passed test file', () => {
+      expect(result).toContain('Test Files  1 passed (1)')
+    })
+
+    test('summary shows 0 tests', () => {
+      expect(result).toContain('Tests  0 passed (0)')
+    })
+  })
+})

package/project-skills/tdd-guard/test/integration/validator.core.test.ts

@@ -0,0 +1,96 @@
+import { describe, test } from 'vitest'
+import { validator } from '../../src/validation/validator'
+import { Context } from '../../src/contracts/types/Context'
+import { Config } from '../../src/config/Config'
+import { ModelClientProvider } from '../../src/providers/ModelClientProvider'
+import { testData } from '../utils'
+import { expectDecision } from '../utils/factories/scenarios'
+
+const { createEditOperation, languages } = testData
+
+describe('Core Validator Scenarios', () => {
+  const config = new Config({ mode: 'test' })
+  const provider = new ModelClientProvider()
+  const model = provider.getModelClient(config)
+
+  languages.forEach((lang) => {
+    const { methodStubReturning0, methodImplementation, empty, completeClass } =
+      lang.implementationModifications
+
+    describe(`${lang.language} scenarios`, () => {
+      test('should allow making a failing test pass', async () => {
+        const oldContent = methodStubReturning0.content
+        const newContent = methodImplementation.content
+        const operation = createEditOperation(
+          lang.implementationFile,
+          oldContent,
+          newContent
+        )
+        const context: Context = {
+          modifications: operation,
+          todo: JSON.stringify(lang.todos.methodInProgress.content),
+          test: lang.testResults.assertionError.content,
+        }
+
+        const result = await validator(context, model)
+        expectDecision(result, undefined)
+      })
+
+      test('should block premature implementation', async () => {
+        const oldContent = empty.content
+        const newContent = completeClass.content
+        const operation = createEditOperation(
+          lang.implementationFile,
+          oldContent,
+          newContent
+        )
+        const context: Context = {
+          modifications: operation,
+          todo: JSON.stringify(lang.todos.methodInProgress.content),
+          test: lang.testResults.notDefined.content,
+        }
+
+        const result = await validator(context, model)
+        expectDecision(result, 'block')
+      })
+
+      test('should block adding multiple tests at once', async () => {
+        const oldContent =
+          lang.testModifications.emptyTestContainerWithImports.content
+        const newContent =
+          lang.testModifications.multipleTestsWithImports.content
+        const operation = createEditOperation(
+          lang.testFile,
+          oldContent,
+          newContent
+        )
+        const context: Context = {
+          modifications: operation,
+          todo: JSON.stringify(lang.todos.empty.content),
+          test: lang.testResults.empty.content,
+        }
+
+        const result = await validator(context, model)
+        expectDecision(result, 'block')
+      })
+
+      test('should allow test refactoring when tests are passing', async () => {
+        const oldContent = lang.testModifications.multipleTests.content
+        const newContent = lang.testModifications.refactoredTests.content
+        const operation = createEditOperation(
+          lang.testFile,
+          oldContent,
+          newContent
+        )
+        const context: Context = {
+          modifications: operation,
+          todo: JSON.stringify(lang.todos.empty.content),
+          test: lang.testResults.passing.content,
+        }
+
+        const result = await validator(context, model)
+        expectDecision(result, undefined)
+      })
+    })
+  })
+})

package/project-skills/tdd-guard/test/integration/validator.scenarios.test.ts

@@ -0,0 +1,497 @@
+import { describe, test } from 'vitest'
+import { validator } from '../../src/validation/validator'
+import { Config } from '../../src/config/Config'
+import { ModelClientProvider } from '../../src/providers/ModelClientProvider'
+import { testData } from '@testUtils'
+import { TestData } from '../utils/factories/scenarios/types'
+import { Context } from '../../src/contracts/types/Context'
+import {
+  Todo,
+  FileModificationSchema,
+} from '../../src/contracts/schemas/toolSchemas'
+import { expectDecision } from '../utils/factories/scenarios'
+
+const {
+  createWriteOperation,
+  createEditOperation,
+  createMultiEditOperation,
+  languages,
+} = testData
+
+export interface Scenario {
+  filePath: string
+  oldContent?: TestData
+  newContent: TestData
+  todos: TestData<Todo[]>
+  testResult: TestData
+  violation: boolean
+}
+
+type OperationType = 'Write' | 'Edit' | 'MultiEdit'
+
+describe('Validator', () => {
+  const config = new Config({ mode: 'test' })
+  const provider = new ModelClientProvider()
+  const model = provider.getModelClient(config)
+  const defaultOperations: OperationType[] = ['Edit', 'Write']
+
+  languages.forEach((lang) => {
+    describe(`${lang.language} scenarios`, () => {
+      const testFile = lang.testFile
+      const implementationFile = lang.implementationFile
+      const {
+        testModifications,
+        implementationModifications,
+        refactoringImplementation,
+        refactoringTestResults,
+        refactoringTests,
+        todos,
+        testResults,
+      } = lang
+
+      describe('Valid operations', () => {
+        const violation = false
+
+        describe('Creating new test', () => {
+          const oldContent = testModifications.emptyTestContainerWithImports
+          const newContent = testModifications.singleTestComplete
+
+          // Todo states that should not hinder the writing of a new test
+          const todoVariations = [
+            todos.empty,
+            todos.classInProgress,
+            todos.irrelevantInProgress,
+          ]
+
+          // Test result outputs that should not hinder the writing of a new test
+          const resultVariations = [testResults.empty, testResults.irrelevant]
+
+          todoVariations.forEach((todoData) => {
+            describe(`with ${todoData.description}`, () => {
+              resultVariations.forEach((resultData) => {
+                describe(`and ${resultData.description}`, () => {
+                  testOperations({
+                    filePath: testFile,
+                    oldContent,
+                    newContent,
+                    todos: todoData,
+                    testResult: resultData,
+                    violation,
+                  })
+                })
+              })
+            })
+          })
+        })
+
+        describe('Creating implementation to pass failing test', () => {
+          const oldContent = implementationModifications.methodStubReturning0
+          const newContent = implementationModifications.methodImplementation
+
+          // Todo states - any todo state is fine as long as test is failing appropriately
+          const todoVariations = [
+            todos.empty,
+            todos.classInProgress,
+            todos.irrelevantInProgress,
+          ]
+
+          // Test must be failing for the right reason to allow implementation
+          const validFailureResults = [testResults.assertionError]
+
+          todoVariations.forEach((todoData) => {
+            describe(`with ${todoData.description}`, () => {
+              validFailureResults.forEach((resultData) => {
+                describe(`and ${resultData.description}`, () => {
+                  testOperations(
+                    {
+                      filePath: implementationFile,
+                      oldContent,
+                      newContent,
+                      todos: todoData,
+                      testResult: resultData,
+                      violation,
+                    },
+                    ['Edit']
+                  )
+                })
+              })
+            })
+          })
+        })
+
+        describe('Refactoring existing tests regardless of todo as long as relevant tests are passing', () => {
+          const oldContent = testModifications.multipleTests
+          const newContent = testModifications.refactoredTests
+
+          // Test refactoring should be allowed with various todo states
+          const todoVariations = [
+            todos.empty,
+            todos.methodInProgress,
+            todos.irrelevantInProgress,
+          ]
+
+          // Test refactoring should be allowed only when relevant tests are passing
+          const resultVariations = [testResults.passing]
+
+          todoVariations.forEach((todoData) => {
+            resultVariations.forEach((resultData) => {
+              describe(`with ${todoData.description} and ${resultData.description}`, () => {
+                testOperations(
+                  {
+                    filePath: testFile,
+                    oldContent,
+                    newContent,
+                    todos: todoData,
+                    testResult: resultData,
+                    violation,
+                  },
+                  ['Edit']
+                )
+              })
+            })
+          })
+        })
+
+        describe('Edit operation with one existing test and one new test', () => {
+          const oldContent = testModifications.singleTest
+          const newContent = testModifications.multipleTests // Contains both the existing test and a new one
+
+          // Various todo states - should be allowed regardless
+          const todoVariations = [todos.empty, todos.methodInProgress]
+
+          todoVariations.forEach((todoData) => {
+            describe(`with ${todoData.description}`, () => {
+              testOperations(
+                {
+                  filePath: testFile,
+                  oldContent,
+                  newContent,
+                  todos: todoData,
+                  testResult: testResults.passing,
+                  violation,
+                },
+                ['Edit']
+              )
+            })
+          })
+        })
+
+        describe('Refactoring implementation code', () => {
+          describe('Allowed when tests have been run and are passing', () => {
+            const oldContent = refactoringImplementation.beforeRefactor
+            const newContent = refactoringImplementation.afterRefactor
+
+            const todoVariations = [
+              todos.empty,
+              todos.irrelevantInProgress,
+              todos.refactoring,
+            ]
+
+            const resultVariations = [
+              refactoringTestResults.passing, // Tests must be passing
+            ]
+
+            todoVariations.forEach((todoData) => {
+              resultVariations.forEach((resultData) => {
+                describe(`with ${todoData.description} and ${resultData.description}`, () => {
+                  testOperations(
+                    {
+                      filePath: implementationFile,
+                      oldContent,
+                      newContent,
+                      todos: todoData,
+                      testResult: resultData,
+                      violation: false,
+                    },
+                    ['Edit']
+                  )
+                })
+              })
+            })
+          })
+
+          describe('Not allowed when no relevant tests are passing', () => {
+            const oldContent = refactoringImplementation.beforeRefactor
+            const newContent = refactoringImplementation.afterRefactor
+
+            const todoVariations = [
+              todos.empty,
+              todos.methodInProgress,
+              todos.irrelevantInProgress,
+              todos.refactoring,
+            ]
+
+            const resultVariations = [
+              testResults.irrelevant,
+              refactoringTestResults.failing,
+              testResults.empty,
+            ]
+
+            todoVariations.forEach((todoData) => {
+              resultVariations.forEach((resultData) => {
+                describe(`with ${todoData.description} and ${resultData.description}`, () => {
+                  testOperations(
+                    {
+                      filePath: implementationFile,
+                      oldContent,
+                      newContent,
+                      todos: todoData,
+                      testResult: resultData,
+                      violation: true,
+                    },
+                    ['Edit']
+                  )
+                })
+              })
+            })
+          })
+        })
+
+        describe('Refactoring test code', () => {
+          describe('Allowed when relevant tests are passing', () => {
+            const oldContent = refactoringTests.beforeRefactor
+            const newContent = refactoringTests.afterRefactor
+
+            const todoVariations = [
+              todos.empty,
+              todos.irrelevantInProgress,
+              todos.refactoring,
+            ]
+
+            const resultVariations = [refactoringTestResults.passing]
+
+            todoVariations.forEach((todoData) => {
+              resultVariations.forEach((resultData) => {
+                describe(`with ${todoData.description} and ${resultData.description}`, () => {
+                  testOperations(
+                    {
+                      filePath: testFile,
+                      oldContent,
+                      newContent,
+                      todos: todoData,
+                      testResult: resultData,
+                      violation: false,
+                    },
+                    ['Edit']
+                  )
+                })
+              })
+            })
+          })
+
+          describe('Not allowed when no passing tests', () => {
+            const oldContent = refactoringTests.beforeRefactor
+            const newContent = refactoringTests.afterRefactor
+
+            const todoVariations = [
+              todos.empty,
+              todos.methodInProgress,
+              todos.irrelevantInProgress,
+            ]
+
+            const resultVariations = [
+              refactoringTestResults.failing,
+              testResults.irrelevant,
+              testResults.empty,
+            ]
+
+            todoVariations.forEach((todoData) => {
+              resultVariations.forEach((resultData) => {
+                describe(`with ${todoData.description} and ${resultData.description}`, () => {
+                  testOperations(
+                    {
+                      filePath: testFile,
+                      oldContent,
+                      newContent,
+                      todos: todoData,
+                      testResult: resultData,
+                      violation: true,
+                    },
+                    ['Edit']
+                  )
+                })
+              })
+            })
+          })
+        })
+      })
+
+      describe('TDD Violations', () => {
+        const violation = true
+
+        describe('Adding multiple tests at once', () => {
+          const oldContent = testModifications.emptyTestContainerWithImports
+          const newContent = testModifications.multipleTestsWithImports
+
+          // Todo states - violation occurs regardless of todo state
+          const todoVariations = [
+            todos.empty,
+            todos.classInProgress,
+            todos.refactoring,
+            todos.irrelevantInProgress,
+          ]
+
+          // Test results - violation occurs regardless of test output
+          const resultVariations = [
+            testResults.empty,
+            testResults.passing,
+            testResults.assertionError,
+            testResults.irrelevant,
+          ]
+
+          todoVariations.forEach((todoData) => {
+            describe(`with ${todoData.description}`, () => {
+              resultVariations.forEach((resultData) => {
+                describe(`and ${resultData.description}`, () => {
+                  testOperations({
+                    filePath: testFile,
+                    oldContent,
+                    newContent,
+                    todos: todoData,
+                    testResult: resultData,
+                    violation,
+                  })
+                })
+              })
+            })
+          })
+        })
+
+        describe('Implementing without proper test failure', () => {
+          const oldContent = implementationModifications.empty
+          const newContent = implementationModifications.methodImplementation
+
+          // Todo states - violation occurs regardless of todo state
+          const todoVariations = [
+            todos.empty,
+            todos.classInProgress,
+            todos.irrelevantInProgress,
+          ]
+
+          // Invalid test results that should block implementation
+          const invalidTestResults = [
+            testResults.empty, // No test has been run
+            testResults.irrelevant, // Test output is for something else
+            testResults.notAConstructor, // Failing for wrong reason
+            testResults.notDefined, // Failing for wrong reason
+          ]
+
+          todoVariations.forEach((todoData) => {
+            describe(`with ${todoData.description}`, () => {
+              invalidTestResults.forEach((resultData) => {
+                describe(`and ${resultData.description}`, () => {
+                  testOperations({
+                    filePath: implementationFile,
+                    oldContent,
+                    newContent,
+                    todos: todoData,
+                    testResult: resultData,
+                    violation,
+                  })
+                })
+              })
+            })
+          })
+        })
+
+        describe('Implementing entire class when only one method test is failing', () => {
+          const oldContent = implementationModifications.empty
+          const newContent = implementationModifications.completeClass // Full class with multiple methods
+
+          // Test is only for add method, but implementation adds everything
+          testOperations({
+            filePath: implementationFile,
+            oldContent,
+            newContent,
+            todos: todos.methodInProgress,
+            testResult: testResults.notDefined, // Single method test failing
+            violation,
+          })
+        })
+
+        describe('Excessive implementation beyond test requirements', () => {
+          const filePath = implementationFile
+          const oldContent = implementationModifications.methodStub
+          const newContent = implementationModifications.overEngineered // Complex implementation with validation, etc.
+
+          // Test only checks basic addition, but implementation adds validation and error handling
+          testOperations({
+            filePath,
+            oldContent,
+            newContent,
+            todos: todos.methodInProgress,
+            testResult: testResults.assertionError, // Simple assertion failure
+            violation,
+          })
+        })
+      })
+
+      function testOperations(
+        scenario: Scenario,
+        operations: OperationType[] = defaultOperations
+      ): void {
+        operations.forEach((operation) => {
+          test(`${operation} should ${scenario.violation ? 'block' : 'allow'}`, async () => {
+            const context = createContext(scenario, operation)
+            const result = await validator(context, model)
+            expectDecision(result, scenario.violation ? 'block' : undefined)
+          })
+        })
+      }
+    })
+  })
+})
+
+// Convert scenario to context for a specific operation type
+function createContext(
+  scenario: Scenario,
+  operationType: OperationType
+): Context {
+  const modificationString = createModificationString(scenario, operationType)
+  validateModification(modificationString)
+
+  return {
+    modifications: modificationString,
+    todo: formatTodos(scenario.todos.content),
+    test: scenario.testResult.content,
+  }
+}
+
+function createModificationString(
+  scenario: Scenario,
+  operationType: OperationType
+): string {
+  const newString = scenario.newContent.content
+  const oldString = scenario.oldContent?.content ?? ''
+
+  const operationCreators: Record<OperationType, () => string> = {
+    Write: () => createWriteOperation(scenario.filePath, newString),
+    Edit: () => createEditOperation(scenario.filePath, oldString, newString),
+    MultiEdit: () =>
+      createMultiEditOperation(scenario.filePath, [
+        {
+          old_string: oldString,
+          new_string: newString,
+          replace_all: false,
+        },
+      ]),
+  }
+
+  return operationCreators[operationType]()
+}
+
+function validateModification(modificationString: string): void {
+  const validationResult = FileModificationSchema.safeParse(
+    JSON.parse(modificationString)
+  )
+
+  if (!validationResult.success) {
+    throw new Error(
+      `Invalid file modification operation: ${validationResult.error.message}`
+    )
+  }
+}
+
+function formatTodos(todoList: unknown[]): string | undefined {
+  return todoList.length > 0 ? JSON.stringify(todoList) : undefined
+}

package/project-skills/tdd-guard/test/utils/assertions.ts

@@ -0,0 +1,29 @@
+/**
+ * Test assertion helpers for linter tests
+ */
+
+import type { LintIssue } from '../../src/contracts/schemas/lintSchemas'
+
+/**
+ * Check if issues contain a specific rule
+ */
+export const hasRule = (issues: LintIssue[], rule: string): boolean => {
+  return issues.some((issue) => issue.rule === rule)
+}
+
+/**
+ * Check if issues contain all specified rules
+ */
+export const hasRules = (issues: LintIssue[], rules: string[]): boolean[] => {
+  return rules.map((rule) => hasRule(issues, rule))
+}
+
+/**
+ * Filter issues from a specific file
+ */
+export const issuesFromFile = (
+  issues: LintIssue[],
+  filename: string
+): LintIssue[] => {
+  return issues.filter((issue) => issue.file.includes(filename))
+}