xtrm-tools 2.0.0

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

@@ -0,0 +1,58 @@
+import { describe, test, expect } from 'vitest'
+import { GuardConfigSchema } from './guardSchemas'
+
+describe('GuardConfigSchema', () => {
+  test.each([
+    {
+      description: 'valid config with all fields',
+      config: {
+        guardEnabled: true,
+        ignorePatterns: ['*.md', '**/*.test.ts', 'dist/**'],
+      },
+      expectedSuccess: true,
+    },
+    {
+      description: 'config with only guardEnabled',
+      config: {
+        guardEnabled: false,
+      },
+      expectedSuccess: true,
+    },
+    {
+      description: 'config with only ignorePatterns',
+      config: {
+        ignorePatterns: ['*.log', 'node_modules/**'],
+      },
+      expectedSuccess: true,
+    },
+    {
+      description: 'empty config object',
+      config: {},
+      expectedSuccess: true,
+    },
+    {
+      description: 'invalid guardEnabled type (string)',
+      config: {
+        guardEnabled: 'true',
+      },
+      expectedSuccess: false,
+    },
+    {
+      description: 'invalid ignorePatterns type (string)',
+      config: {
+        ignorePatterns: '*.md',
+      },
+      expectedSuccess: false,
+    },
+    {
+      description: 'non-string items in ignorePatterns array',
+      config: {
+        ignorePatterns: ['*.md', 123, true],
+      },
+      expectedSuccess: false,
+    },
+  ])('$description', ({ config, expectedSuccess }) => {
+    const result = GuardConfigSchema.safeParse(config)
+    expect(result.success).toBe(expectedSuccess)
+  })
+})

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

@@ -0,0 +1,8 @@
+import { z } from 'zod'
+
+export const GuardConfigSchema = z.object({
+  guardEnabled: z.boolean().optional(),
+  ignorePatterns: z.array(z.string()).optional(),
+})
+
+export type GuardConfig = z.infer<typeof GuardConfigSchema>

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

@@ -0,0 +1,347 @@
+import { describe, test, expect } from 'vitest'
+import {
+  LintIssueSchema,
+  LintResultSchema,
+  LintDataSchema,
+  ESLintMessageSchema,
+  ESLintResultSchema,
+  GolangciLintPositionSchema,
+  GolangciLintIssueSchema,
+  GolangciLintResultSchema,
+} from './lintSchemas'
+import { testData } from '@testUtils'
+
+describe('LintIssueSchema', () => {
+  test.each([
+    {
+      description: 'valid lint issue with all fields',
+      issue: testData.lintIssue(),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid lint issue without optional rule',
+      issue: testData.lintIssueWithout(['rule']),
+      expectedSuccess: true,
+    },
+    {
+      description: 'without file',
+      issue: testData.lintIssueWithout(['file']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without line',
+      issue: testData.lintIssueWithout(['line']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without column',
+      issue: testData.lintIssueWithout(['column']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without severity',
+      issue: testData.lintIssueWithout(['severity']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without message',
+      issue: testData.lintIssueWithout(['message']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'with invalid severity',
+      issue: {
+        ...testData.lintIssue(),
+        severity: 'info',
+      },
+      expectedSuccess: false,
+    },
+  ])('$description', ({ issue, expectedSuccess }) => {
+    const result = LintIssueSchema.safeParse(issue)
+    expect(result.success).toBe(expectedSuccess)
+  })
+})
+
+describe('LintResultSchema', () => {
+  test.each([
+    {
+      description: 'valid lint result with no issues',
+      lintResult: testData.lintResult({
+        issues: [],
+        errorCount: 0,
+        warningCount: 0,
+      }),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid lint result with issues',
+      lintResult: testData.lintResult(),
+      expectedSuccess: true,
+    },
+    {
+      description: 'without timestamp',
+      lintResult: testData.lintResultWithout(['timestamp']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without files',
+      lintResult: testData.lintResultWithout(['files']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without issues',
+      lintResult: testData.lintResultWithout(['issues']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without errorCount',
+      lintResult: testData.lintResultWithout(['errorCount']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without warningCount',
+      lintResult: testData.lintResultWithout(['warningCount']),
+      expectedSuccess: false,
+    },
+  ])('$description', ({ lintResult, expectedSuccess }) => {
+    const result = LintResultSchema.safeParse(lintResult)
+    expect(result.success).toBe(expectedSuccess)
+  })
+})
+
+describe('LintDataSchema', () => {
+  test.each([
+    {
+      description: 'valid lint data with notification flag false',
+      lintData: testData.lintData({
+        hasNotifiedAboutLintIssues: false,
+      }),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid lint data with notification flag true',
+      lintData: testData.lintData({
+        hasNotifiedAboutLintIssues: true,
+      }),
+      expectedSuccess: true,
+    },
+    {
+      description: 'without hasNotifiedAboutLintIssues',
+      lintData: testData.lintDataWithout(['hasNotifiedAboutLintIssues']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'extends LintResultSchema - valid with all base fields',
+      lintData: testData.lintData(),
+      expectedSuccess: true,
+    },
+    {
+      description: 'extends LintResultSchema - invalid without base timestamp',
+      lintData: testData.lintDataWithout(['timestamp']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'extends LintResultSchema - invalid without base files',
+      lintData: testData.lintDataWithout(['files']),
+      expectedSuccess: false,
+    },
+  ])('$description', ({ lintData, expectedSuccess }) => {
+    const result = LintDataSchema.safeParse(lintData)
+    expect(result.success).toBe(expectedSuccess)
+  })
+})
+
+describe('ESLintMessageSchema', () => {
+  test.each([
+    {
+      description: 'valid ESLint message with all fields',
+      message: testData.eslintMessage(),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid without optional line',
+      message: testData.eslintMessageWithout(['line']),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid without optional column',
+      message: testData.eslintMessageWithout(['column']),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid without optional ruleId',
+      message: testData.eslintMessageWithout(['ruleId']),
+      expectedSuccess: true,
+    },
+    {
+      description: 'without required severity',
+      message: testData.eslintMessageWithout(['severity']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without required message',
+      message: testData.eslintMessageWithout(['message']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'with invalid severity type',
+      message: {
+        ...testData.eslintMessage(),
+        severity: 'error',
+      },
+      expectedSuccess: false,
+    },
+  ])('$description', ({ message, expectedSuccess }) => {
+    const result = ESLintMessageSchema.safeParse(message)
+    expect(result.success).toBe(expectedSuccess)
+  })
+})
+
+describe('ESLintResultSchema', () => {
+  test.each([
+    {
+      description: 'valid ESLint result with messages',
+      result: testData.eslintResult(),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid without optional messages',
+      result: testData.eslintResultWithout(['messages']),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid with empty messages array',
+      result: testData.eslintResult({ messages: [] }),
+      expectedSuccess: true,
+    },
+    {
+      description: 'without required filePath',
+      result: testData.eslintResultWithout(['filePath']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'with invalid messages type',
+      result: {
+        ...testData.eslintResult(),
+        messages: 'not-an-array',
+      },
+      expectedSuccess: false,
+    },
+  ])('$description', ({ result, expectedSuccess }) => {
+    const parseResult = ESLintResultSchema.safeParse(result)
+    expect(parseResult.success).toBe(expectedSuccess)
+  })
+})
+
+describe('GolangciLintPositionSchema', () => {
+  test.each([
+    {
+      description: 'valid position with all fields',
+      position: testData.golangciLintPosition(),
+      expectedSuccess: true,
+    },
+    {
+      description: 'without required Filename',
+      position: testData.golangciLintPositionWithout(['Filename']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without required Line',
+      position: testData.golangciLintPositionWithout(['Line']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without required Column',
+      position: testData.golangciLintPositionWithout(['Column']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'with invalid Line type',
+      position: {
+        ...testData.golangciLintPosition(),
+        Line: '10',
+      },
+      expectedSuccess: false,
+    },
+  ])('$description', ({ position, expectedSuccess }) => {
+    const result = GolangciLintPositionSchema.safeParse(position)
+    expect(result.success).toBe(expectedSuccess)
+  })
+})
+
+describe('GolangciLintIssueSchema', () => {
+  test.each([
+    {
+      description: 'valid issue with all fields',
+      issue: testData.golangciLintIssue(),
+      expectedSuccess: true,
+    },
+    {
+      description: 'without required FromLinter',
+      issue: testData.golangciLintIssueWithout(['FromLinter']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without required Text',
+      issue: testData.golangciLintIssueWithout(['Text']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'without required Pos',
+      issue: testData.golangciLintIssueWithout(['Pos']),
+      expectedSuccess: false,
+    },
+    {
+      description: 'with invalid Pos structure',
+      issue: {
+        ...testData.golangciLintIssue(),
+        Pos: {
+          ...testData.golangciLintPosition(),
+          Line: 'invalid',
+        },
+      },
+      expectedSuccess: false,
+    },
+  ])('$description', ({ issue, expectedSuccess }) => {
+    const result = GolangciLintIssueSchema.safeParse(issue)
+    expect(result.success).toBe(expectedSuccess)
+  })
+})
+
+describe('GolangciLintResultSchema', () => {
+  test.each([
+    {
+      description: 'valid result with Issues array',
+      result: testData.golangciLintResult(),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid result with empty Issues array',
+      result: testData.golangciLintResult({ Issues: [] }),
+      expectedSuccess: true,
+    },
+    {
+      description: 'valid result without Issues (undefined)',
+      result: testData.golangciLintResultWithout(['Issues']),
+      expectedSuccess: true,
+    },
+    {
+      description: 'invalid result with malformed issue in Issues array',
+      result: testData.golangciLintResult({
+        Issues: [testData.golangciLintIssueWithout(['Text'])],
+      }),
+      expectedSuccess: false,
+    },
+    {
+      description: 'invalid result with non-array Issues',
+      result: {
+        ...testData.golangciLintResult(),
+        Issues: 'not-an-array',
+      },
+      expectedSuccess: false,
+    },
+  ])('$description', ({ result, expectedSuccess }) => {
+    const parseResult = GolangciLintResultSchema.safeParse(result)
+    expect(parseResult.success).toBe(expectedSuccess)
+  })
+})

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

@@ -0,0 +1,61 @@
+import { z } from 'zod'
+
+export const ESLintMessageSchema = z.object({
+  line: z.number().optional(),
+  column: z.number().optional(),
+  severity: z.number(),
+  message: z.string(),
+  ruleId: z.string().optional(),
+})
+
+export const ESLintResultSchema = z.object({
+  filePath: z.string(),
+  messages: z.array(ESLintMessageSchema).optional(),
+})
+
+export const GolangciLintPositionSchema = z.object({
+  Filename: z.string(),
+  Line: z.number(),
+  Column: z.number(),
+})
+
+export const GolangciLintIssueSchema = z.object({
+  FromLinter: z.string(),
+  Text: z.string(),
+  Severity: z.string(),
+  Pos: GolangciLintPositionSchema,
+})
+
+export const GolangciLintResultSchema = z.object({
+  Issues: z.array(GolangciLintIssueSchema).optional(),
+})
+
+export const LintIssueSchema = z.object({
+  file: z.string(),
+  line: z.number(),
+  column: z.number(),
+  severity: z.enum(['error', 'warning']),
+  message: z.string(),
+  rule: z.string().optional(),
+})
+
+export const LintResultSchema = z.object({
+  timestamp: z.string(),
+  files: z.array(z.string()),
+  issues: z.array(LintIssueSchema),
+  errorCount: z.number(),
+  warningCount: z.number(),
+})
+
+export const LintDataSchema = LintResultSchema.extend({
+  hasNotifiedAboutLintIssues: z.boolean(),
+})
+
+export type ESLintMessage = z.infer<typeof ESLintMessageSchema>
+export type ESLintResult = z.infer<typeof ESLintResultSchema>
+export type GolangciLintPosition = z.infer<typeof GolangciLintPositionSchema>
+export type GolangciLintIssue = z.infer<typeof GolangciLintIssueSchema>
+export type GolangciLintResult = z.infer<typeof GolangciLintResultSchema>
+export type LintData = z.infer<typeof LintDataSchema>
+export type LintIssue = z.infer<typeof LintIssueSchema>
+export type LintResult = z.infer<typeof LintResultSchema>

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

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest'
+import { PytestResultSchema } from './pytestSchemas'
+
+describe('PytestResultSchema', () => {
+  it('should validate pytest test result format', () => {
+    const pytestResult = {
+      testModules: [
+        {
+          moduleId: 'test_example.py',
+          tests: [
+            {
+              name: 'test_passing',
+              fullName: 'test_example.py::test_passing',
+              state: 'passed' as const,
+            },
+          ],
+        },
+      ],
+    }
+
+    const result = PytestResultSchema.safeParse(pytestResult)
+    expect(result.success).toBe(true)
+  })
+})

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

@@ -0,0 +1,7 @@
+import { z } from 'zod'
+import { TestModuleSchema } from './reporterSchemas'
+
+// Pytest uses same structure as Vitest
+export const PytestResultSchema = z.object({
+  testModules: z.array(TestModuleSchema),
+})