xtrm-tools 2.2.0 → 2.4.0

package/project-skills/tdd-guard/src/contracts/schemas/reporterSchemas.test.ts

@@ -1,377 +0,0 @@
-import { describe, test, expect } from 'vitest'
-import {
-  TestErrorSchema,
-  TestSchema,
-  TestModuleSchema,
-  TestResultSchema,
-  UnhandledErrorSchema,
-  isTestModule,
-  isTestCase,
-  isFailingTest,
-  isPassingTest,
-  isTestPassing,
-} from './reporterSchemas'
-import { testData } from '@testUtils'
-
-describe('Reporter schemas', () => {
-  describe('UnhandledErrorSchema', () => {
-    test.each([
-      {
-        description: 'without name',
-        unhandledError: testData.createUnhandledErrorWithout(['name']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without message',
-        unhandledError: testData.createUnhandledErrorWithout(['message']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'with all required fields',
-        unhandledError: testData.createUnhandledError(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with name and message only',
-        unhandledError: testData.createUnhandledError({ stack: undefined }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with custom error name',
-        unhandledError: testData.createUnhandledError({
-          name: 'TypeError',
-          message: 'Cannot read property of undefined',
-        }),
-        expectedSuccess: true,
-      },
-    ])('$description', ({ unhandledError, expectedSuccess }) => {
-      const result = UnhandledErrorSchema.safeParse(unhandledError)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(unhandledError)
-      }
-    })
-  })
-
-  describe('TestErrorSchema', () => {
-    test.each([
-      {
-        description: 'without message',
-        testError: testData.createTestError({ message: undefined }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'with message only',
-        testError: testData.createTestError({ message: 'test error' }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with message and stack',
-        testError: testData.createTestError({
-          message: 'test error',
-          stack: 'Error: test error\n    at test.ts:1:1',
-        }),
-        expectedSuccess: true,
-      },
-    ])('$description', ({ testError, expectedSuccess }) => {
-      const result = TestErrorSchema.safeParse(testError)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(testError)
-      }
-    })
-  })
-
-  describe('TestSchema', () => {
-    test.each([
-      {
-        description: 'without name',
-        test: testData.createTest({ name: undefined }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without fullName',
-        test: testData.createTest({ fullName: undefined }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without state',
-        test: testData.createTest({ state: undefined }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'with passed state',
-        test: testData.createTest({ state: 'passed' }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with failed state and errors',
-        test: testData.createTest({
-          state: 'failed',
-          errors: [testData.createTestError()],
-        }),
-        expectedSuccess: true,
-      },
-    ])('$description', ({ test: testCase, expectedSuccess }) => {
-      const result = TestSchema.safeParse(testCase)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(testCase)
-      }
-    })
-  })
-
-  describe('TestModuleSchema', () => {
-    test.each([
-      {
-        description: 'without moduleId',
-        testModule: testData.createTestModule({ moduleId: undefined }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without tests',
-        testModule: testData.createTestModule({ tests: undefined }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'with valid module',
-        testModule: testData.createTestModule({
-          moduleId: '/src/test.ts',
-          tests: [testData.createTest()],
-        }),
-        expectedSuccess: true,
-      },
-    ])('$description', ({ testModule, expectedSuccess }) => {
-      const result = TestModuleSchema.safeParse(testModule)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(testModule)
-      }
-    })
-  })
-
-  describe('TestResultSchema', () => {
-    test.each([
-      {
-        description: 'without testModules',
-        jsonTestResult: { someOtherField: 'value' },
-        expectedSuccess: false,
-      },
-      {
-        description: 'with empty testModules array',
-        jsonTestResult: testData.createTestResults({ testModules: [] }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with valid test result',
-        jsonTestResult: testData.createTestResults({
-          testModules: [testData.createTestModule()],
-        }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with unhandledErrors field',
-        jsonTestResult: {
-          testModules: [],
-          unhandledErrors: [testData.createUnhandledError()],
-        },
-        expectedSuccess: true,
-      },
-      {
-        description: 'with reason field as "passed"',
-        jsonTestResult: {
-          testModules: [],
-          reason: 'passed',
-        },
-        expectedSuccess: true,
-      },
-      {
-        description: 'with reason field as "failed"',
-        jsonTestResult: {
-          testModules: [],
-          reason: 'failed',
-        },
-        expectedSuccess: true,
-      },
-      {
-        description: 'with reason field as "interrupted"',
-        jsonTestResult: {
-          testModules: [],
-          reason: 'interrupted',
-        },
-        expectedSuccess: true,
-      },
-      {
-        description: 'with invalid reason value',
-        jsonTestResult: {
-          testModules: [],
-          reason: 'invalid',
-        },
-        expectedSuccess: false,
-      },
-    ])('$description', ({ jsonTestResult, expectedSuccess }) => {
-      const result = TestResultSchema.safeParse(jsonTestResult)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(jsonTestResult)
-      }
-    })
-  })
-
-  describe('isTestModule', () => {
-    test('returns true for valid test module', () => {
-      const validModule = testData.createTestModule()
-      expect(isTestModule(validModule)).toBe(true)
-    })
-
-    test('returns false for object missing moduleId', () => {
-      const invalidModule = { tests: [] }
-      expect(isTestModule(invalidModule)).toBe(false)
-    })
-
-    test('returns false for object missing tests array', () => {
-      const invalidModule = { moduleId: '/src/test.ts' }
-      expect(isTestModule(invalidModule)).toBe(false)
-    })
-
-    test('returns false for primitive values', () => {
-      expect(isTestModule('string')).toBe(false)
-      expect(isTestModule(123)).toBe(false)
-      expect(isTestModule(null)).toBe(false)
-      expect(isTestModule(undefined)).toBe(false)
-    })
-  })
-
-  describe('isTestCase', () => {
-    test('returns true for valid test case', () => {
-      const validTest = testData.createTest()
-      expect(isTestCase(validTest)).toBe(true)
-    })
-
-    test('returns false for object missing name', () => {
-      const invalidTest = { fullName: 'test', state: 'passed' }
-      expect(isTestCase(invalidTest)).toBe(false)
-    })
-
-    test('returns false for object with invalid state', () => {
-      const invalidTest = { name: 'test', fullName: 'test', state: 'invalid' }
-      expect(isTestCase(invalidTest)).toBe(false)
-    })
-
-    test('returns false for primitive values', () => {
-      expect(isTestCase('string')).toBe(false)
-      expect(isTestCase(null)).toBe(false)
-    })
-  })
-
-  describe('isFailingTest', () => {
-    test('returns true for test with failed state', () => {
-      const failedTest = testData.createTest({ state: 'failed' })
-      expect(isFailingTest(failedTest)).toBe(true)
-    })
-
-    test('returns false for test with passed state', () => {
-      const passedTest = testData.createTest({ state: 'passed' })
-      expect(isFailingTest(passedTest)).toBe(false)
-    })
-
-    test('returns false for test with skipped state', () => {
-      const skippedTest = testData.createTest({ state: 'skipped' })
-      expect(isFailingTest(skippedTest)).toBe(false)
-    })
-
-    test('returns false for invalid test object', () => {
-      const invalidTest = { name: 'test', state: 'failed' }
-      expect(isFailingTest(invalidTest)).toBe(false)
-    })
-
-    test('returns false for non-test values', () => {
-      expect(isFailingTest('string')).toBe(false)
-      expect(isFailingTest(null)).toBe(false)
-    })
-  })
-
-  describe('isPassingTest', () => {
-    test('returns true for test with passed state', () => {
-      const passedTest = testData.createTest({ state: 'passed' })
-      expect(isPassingTest(passedTest)).toBe(true)
-    })
-
-    test('returns false for test with failed state', () => {
-      const failedTest = testData.createTest({ state: 'failed' })
-      expect(isPassingTest(failedTest)).toBe(false)
-    })
-
-    test('returns false for test with skipped state', () => {
-      const skippedTest = testData.createTest({ state: 'skipped' })
-      expect(isPassingTest(skippedTest)).toBe(false)
-    })
-
-    test('returns false for invalid test object', () => {
-      const invalidTest = { name: 'test', state: 'passed' }
-      expect(isPassingTest(invalidTest)).toBe(false)
-    })
-
-    test('returns false for non-test values', () => {
-      expect(isPassingTest('string')).toBe(false)
-      expect(isPassingTest(null)).toBe(false)
-    })
-  })
-
-  describe('isTestPassing', () => {
-    describe('with test arrays', () => {
-      const passingTest = testData.createTest({ state: 'passed' })
-      const failingTest = testData.createTest({ state: 'failed' })
-
-      test.each([
-        {
-          description: 'returns true when all tests pass',
-          tests: [passingTest, passingTest],
-          expected: true,
-        },
-        {
-          description: 'returns false when any test fails',
-          tests: [passingTest, failingTest],
-          expected: false,
-        },
-        {
-          description: 'returns true when single test passes',
-          tests: [passingTest],
-          expected: true,
-        },
-        {
-          description: 'returns false when single test fails',
-          tests: [failingTest],
-          expected: false,
-        },
-        {
-          description: 'returns false when multiple tests fail',
-          tests: [failingTest, failingTest],
-          expected: false,
-        },
-        {
-          description: 'returns false when test modules have no tests',
-          tests: [],
-          expected: false,
-        },
-      ])('$description', ({ tests, expected }) => {
-        const testResult = testData.createTestResults({
-          testModules: [testData.createTestModule({ tests })],
-        })
-        expect(isTestPassing(testResult)).toBe(expected)
-      })
-    })
-
-    test('returns false when there are no test modules', () => {
-      const testResult = testData.createTestResults({
-        testModules: [],
-      })
-      expect(isTestPassing(testResult)).toBe(false)
-    })
-  })
-})

package/project-skills/tdd-guard/src/contracts/schemas/reporterSchemas.ts

@@ -1,75 +0,0 @@
-import { z } from 'zod'
-
-export const TestErrorSchema = z.object({
-  message: z.string(),
-  stack: z.string().optional(),
-})
-
-export const UnhandledErrorSchema = z.object({
-  name: z.string(),
-  message: z.string(),
-  stack: z.string().optional(),
-})
-
-export const TestSchema = z.object({
-  name: z.string(),
-  fullName: z.string(),
-  state: z.enum(['passed', 'failed', 'skipped']),
-  errors: z.array(TestErrorSchema).optional(),
-})
-
-export const TestModuleSchema = z.object({
-  moduleId: z.string(),
-  tests: z.array(TestSchema),
-})
-
-export const TestResultSchema = z.object({
-  testModules: z.array(TestModuleSchema),
-  unhandledErrors: z.array(UnhandledErrorSchema).optional(),
-  reason: z.enum(['passed', 'failed', 'interrupted']).optional(),
-})
-
-export type TestError = z.infer<typeof TestErrorSchema>
-export type UnhandledError = z.infer<typeof UnhandledErrorSchema>
-export type Test = z.infer<typeof TestSchema>
-export type TestModule = z.infer<typeof TestModuleSchema>
-export type TestResult = z.infer<typeof TestResultSchema>
-
-export function isTestModule(value: unknown): value is TestModule {
-  return TestModuleSchema.safeParse(value).success
-}
-
-export function isTestCase(value: unknown): value is Test {
-  return TestSchema.safeParse(value).success
-}
-
-export function isFailingTest(
-  value: unknown
-): value is Test & { state: 'failed' } {
-  return isTestCase(value) && value.state === 'failed'
-}
-
-export function isPassingTest(
-  value: unknown
-): value is Test & { state: 'passed' } {
-  return isTestCase(value) && value.state === 'passed'
-}
-
-export function isTestPassing(testResult: TestResult): boolean {
-  // No tests means the test suite is not passing
-  if (testResult.testModules.length === 0) {
-    return false
-  }
-
-  // Check if any tests exist
-  const hasTests = testResult.testModules.some(
-    (module) => module.tests.length > 0
-  )
-  if (!hasTests) {
-    return false
-  }
-
-  return testResult.testModules.every((module) =>
-    module.tests.every((test) => test.state !== 'failed')
-  )
-}