popeye-cli 1.6.0 → 1.8.0

package/tests/types/database-runtime.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Tests for database runtime types and schemas
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  SetupStepResultSchema,
+  SetupResultSchema,
+  ReadinessCheckSchema,
+  ReadinessResultSchema,
+} from '../../src/types/database-runtime.js';
+
+describe('SetupStepResultSchema', () => {
+  it('should accept a valid successful step result', () => {
+    const result = SetupStepResultSchema.safeParse({
+      step: 'check_connection',
+      success: true,
+      message: 'Database connection verified',
+      durationMs: 150,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept a failed step result with error', () => {
+    const result = SetupStepResultSchema.safeParse({
+      step: 'apply_migrations',
+      success: false,
+      message: 'Migration failed',
+      durationMs: 3000,
+      error: 'alembic upgrade head returned exit code 1',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid step names', () => {
+    const result = SetupStepResultSchema.safeParse({
+      step: 'invalid_step',
+      success: true,
+      message: 'ok',
+      durationMs: 0,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject missing required fields', () => {
+    const result = SetupStepResultSchema.safeParse({
+      step: 'check_connection',
+      success: true,
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('SetupResultSchema', () => {
+  it('should accept a successful pipeline result', () => {
+    const result = SetupResultSchema.safeParse({
+      success: true,
+      steps: [
+        { step: 'check_connection', success: true, message: 'ok', durationMs: 100 },
+        { step: 'apply_migrations', success: true, message: 'ok', durationMs: 200 },
+      ],
+      totalDurationMs: 300,
+      finalStatus: 'ready',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept a failed pipeline result with error', () => {
+    const result = SetupResultSchema.safeParse({
+      success: false,
+      steps: [
+        { step: 'check_connection', success: false, message: 'fail', durationMs: 50, error: 'timeout' },
+      ],
+      totalDurationMs: 50,
+      finalStatus: 'error',
+      error: 'timeout',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept empty steps array', () => {
+    const result = SetupResultSchema.safeParse({
+      success: false,
+      steps: [],
+      totalDurationMs: 0,
+      finalStatus: 'error',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid finalStatus', () => {
+    const result = SetupResultSchema.safeParse({
+      success: true,
+      steps: [],
+      totalDurationMs: 0,
+      finalStatus: 'complete',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('ReadinessCheckSchema', () => {
+  it('should accept all severity levels', () => {
+    for (const severity of ['critical', 'warning', 'info'] as const) {
+      const result = ReadinessCheckSchema.safeParse({
+        name: 'Test Check',
+        passed: true,
+        message: 'Check passed',
+        severity,
+      });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it('should reject invalid severity', () => {
+    const result = ReadinessCheckSchema.safeParse({
+      name: 'Test',
+      passed: true,
+      message: 'ok',
+      severity: 'error',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('ReadinessResultSchema', () => {
+  it('should accept a healthy result with checks', () => {
+    const result = ReadinessResultSchema.safeParse({
+      healthy: true,
+      checks: [
+        { name: 'DB Connection', passed: true, message: 'Connected', severity: 'critical' },
+        { name: 'pgvector', passed: true, message: 'Available', severity: 'warning' },
+      ],
+      timestamp: '2024-01-01T00:00:00Z',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept an unhealthy result', () => {
+    const result = ReadinessResultSchema.safeParse({
+      healthy: false,
+      checks: [
+        { name: 'DB Connection', passed: false, message: 'Cannot connect', severity: 'critical' },
+      ],
+      timestamp: '2024-01-01T00:00:00Z',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept empty checks array', () => {
+    const result = ReadinessResultSchema.safeParse({
+      healthy: true,
+      checks: [],
+      timestamp: '2024-01-01T00:00:00Z',
+    });
+    expect(result.success).toBe(true);
+  });
+});

package/tests/types/database.test.ts

@@ -0,0 +1,187 @@
+/**
+ * Tests for database types and schemas
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  DbStatusSchema,
+  DbModeSchema,
+  DbProviderSchema,
+  BackendOrmSchema,
+  DbSetupStepSchema,
+  DbConfigSchema,
+  DEFAULT_DB_CONFIG,
+} from '../../src/types/database.js';
+
+describe('DbStatusSchema', () => {
+  it('should accept all valid status values', () => {
+    const validStatuses = ['unconfigured', 'configured', 'applying', 'ready', 'error'];
+    for (const status of validStatuses) {
+      expect(DbStatusSchema.safeParse(status).success).toBe(true);
+    }
+  });
+
+  it('should reject invalid status values', () => {
+    expect(DbStatusSchema.safeParse('pending').success).toBe(false);
+    expect(DbStatusSchema.safeParse('active').success).toBe(false);
+    expect(DbStatusSchema.safeParse('').success).toBe(false);
+    expect(DbStatusSchema.safeParse(123).success).toBe(false);
+  });
+});
+
+describe('DbModeSchema', () => {
+  it('should accept valid modes', () => {
+    expect(DbModeSchema.safeParse('local_docker').success).toBe(true);
+    expect(DbModeSchema.safeParse('managed').success).toBe(true);
+  });
+
+  it('should reject unconfigured and unknown values', () => {
+    expect(DbModeSchema.safeParse('unconfigured').success).toBe(false);
+    expect(DbModeSchema.safeParse('cloud').success).toBe(false);
+    expect(DbModeSchema.safeParse('').success).toBe(false);
+  });
+});
+
+describe('DbProviderSchema', () => {
+  it('should accept valid providers', () => {
+    expect(DbProviderSchema.safeParse('neon').success).toBe(true);
+    expect(DbProviderSchema.safeParse('supabase').success).toBe(true);
+    expect(DbProviderSchema.safeParse('other').success).toBe(true);
+  });
+
+  it('should reject unknown providers', () => {
+    expect(DbProviderSchema.safeParse('aws').success).toBe(false);
+  });
+});
+
+describe('BackendOrmSchema', () => {
+  it('should accept valid ORM values', () => {
+    expect(BackendOrmSchema.safeParse('sqlalchemy').success).toBe(true);
+    expect(BackendOrmSchema.safeParse('prisma').success).toBe(true);
+    expect(BackendOrmSchema.safeParse('drizzle').success).toBe(true);
+  });
+
+  it('should reject unknown ORM values', () => {
+    expect(BackendOrmSchema.safeParse('typeorm').success).toBe(false);
+  });
+});
+
+describe('DbConfigSchema', () => {
+  it('should accept a full config with all fields', () => {
+    const config = {
+      designed: true,
+      mode: 'local_docker',
+      vectorRequired: true,
+      status: 'ready',
+      lastError: undefined,
+      migrationsApplied: 3,
+      readinessCheckedAt: '2024-01-01T00:00:00Z',
+    };
+    const result = DbConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept a minimal config without optional mode', () => {
+    const config = {
+      designed: true,
+      vectorRequired: true,
+      status: 'unconfigured',
+      migrationsApplied: 0,
+    };
+    const result = DbConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.mode).toBeUndefined();
+    }
+  });
+
+  it('should allow mode set with status unconfigured (valid during transitions)', () => {
+    const config = {
+      designed: true,
+      mode: 'managed',
+      vectorRequired: false,
+      status: 'unconfigured',
+      migrationsApplied: 0,
+    };
+    const result = DbConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject config with invalid status', () => {
+    const config = {
+      designed: true,
+      vectorRequired: true,
+      status: 'broken',
+      migrationsApplied: 0,
+    };
+    expect(DbConfigSchema.safeParse(config).success).toBe(false);
+  });
+
+  it('should reject config missing required fields', () => {
+    const config = { designed: true };
+    expect(DbConfigSchema.safeParse(config).success).toBe(false);
+  });
+});
+
+describe('DEFAULT_DB_CONFIG', () => {
+  it('should have correct initial values', () => {
+    expect(DEFAULT_DB_CONFIG.designed).toBe(true);
+    expect(DEFAULT_DB_CONFIG.status).toBe('unconfigured');
+    expect(DEFAULT_DB_CONFIG.vectorRequired).toBe(true);
+    expect(DEFAULT_DB_CONFIG.migrationsApplied).toBe(0);
+  });
+
+  it('should not have mode set (absent until user configures)', () => {
+    expect(DEFAULT_DB_CONFIG.mode).toBeUndefined();
+  });
+
+  it('should parse through DbConfigSchema successfully', () => {
+    const result = DbConfigSchema.safeParse(DEFAULT_DB_CONFIG);
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('DbSetupStepSchema', () => {
+  it('should accept all setup steps', () => {
+    const steps = [
+      'check_connection',
+      'ensure_extensions',
+      'apply_migrations',
+      'seed_minimal',
+      'readiness_tests',
+      'mark_ready',
+    ];
+    for (const step of steps) {
+      expect(DbSetupStepSchema.safeParse(step).success).toBe(true);
+    }
+  });
+});
+
+describe('ProjectStateSchema backward compatibility', () => {
+  it('should parse existing state without dbConfig field', async () => {
+    // Import ProjectStateSchema to verify backward compat
+    const { ProjectStateSchema } = await import('../../src/types/workflow.js');
+
+    const existingState = {
+      id: 'test-id',
+      name: 'test-project',
+      idea: 'Build something',
+      language: 'fullstack',
+      openaiModel: 'gpt-4o',
+      phase: 'plan',
+      status: 'pending',
+      milestones: [],
+      currentMilestone: null,
+      currentTask: null,
+      consensusHistory: [],
+      createdAt: '2024-01-01T00:00:00Z',
+      updatedAt: '2024-01-01T00:00:00Z',
+    };
+
+    const result = ProjectStateSchema.safeParse(existingState);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.dbConfig).toBeUndefined();
+    }
+  });
+});

package/tests/types/tester.test.ts

@@ -0,0 +1,174 @@
+/**
+ * Tests for Tester (QA) type schemas
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  TestVerdictSchema,
+  TestCommandSchema,
+  TestCaseSchema,
+  TestPlanOutputSchema,
+  TestRunReviewSchema,
+  FixStepSchema,
+  TestFixPlanSchema,
+} from '../../src/types/tester.js';
+
+describe('TestVerdictSchema', () => {
+  it('should accept valid verdicts', () => {
+    expect(TestVerdictSchema.parse('PASS')).toBe('PASS');
+    expect(TestVerdictSchema.parse('PASS_WITH_NOTES')).toBe('PASS_WITH_NOTES');
+    expect(TestVerdictSchema.parse('FAIL')).toBe('FAIL');
+  });
+
+  it('should reject invalid verdict strings', () => {
+    expect(() => TestVerdictSchema.parse('pass')).toThrow();
+    expect(() => TestVerdictSchema.parse('UNKNOWN')).toThrow();
+    expect(() => TestVerdictSchema.parse('')).toThrow();
+  });
+});
+
+describe('TestCommandSchema', () => {
+  it('should accept a valid command', () => {
+    const cmd = { command: 'npm test', purpose: 'Run unit tests', required: true };
+    expect(TestCommandSchema.parse(cmd)).toEqual(cmd);
+  });
+
+  it('should accept command with optional cwd', () => {
+    const cmd = { command: 'pytest', cwd: 'backend/', purpose: 'Run backend tests', required: false };
+    expect(TestCommandSchema.parse(cmd)).toEqual(cmd);
+  });
+
+  it('should reject empty command string', () => {
+    expect(() => TestCommandSchema.parse({ command: '', purpose: 'test', required: true })).toThrow();
+  });
+
+  it('should reject missing required fields', () => {
+    expect(() => TestCommandSchema.parse({ command: 'npm test' })).toThrow();
+    expect(() => TestCommandSchema.parse({ purpose: 'test', required: true })).toThrow();
+  });
+});
+
+describe('TestCaseSchema', () => {
+  const validCase = {
+    id: 'TC-1',
+    category: 'unit',
+    description: 'Test user login',
+    acceptanceCriteria: 'Returns 200 with valid credentials',
+    evidenceRequired: 'Test output showing assertion passed',
+    priority: 'critical' as const,
+  };
+
+  it('should accept a valid test case', () => {
+    expect(TestCaseSchema.parse(validCase)).toEqual(validCase);
+  });
+
+  it('should reject invalid priority values', () => {
+    expect(() => TestCaseSchema.parse({ ...validCase, priority: 'urgent' })).toThrow();
+  });
+
+  it('should reject empty id', () => {
+    expect(() => TestCaseSchema.parse({ ...validCase, id: '' })).toThrow();
+  });
+});
+
+describe('TestPlanOutputSchema', () => {
+  const validPlan = {
+    summary: 'Tests login feature risks',
+    scope: ['backend'] as const,
+    testMatrix: [{
+      id: 'TC-1', category: 'unit', description: 'Login test',
+      acceptanceCriteria: 'passes', evidenceRequired: 'output', priority: 'high' as const,
+    }],
+    commands: [{ command: 'pytest', purpose: 'Run tests', required: true }],
+    riskFocus: ['Authentication bypass'],
+    evidenceRequired: ['test output'],
+    minimumVerification: ['build check'],
+  };
+
+  it('should accept a valid test plan', () => {
+    const result = TestPlanOutputSchema.parse(validPlan);
+    expect(result.summary).toBe('Tests login feature risks');
+    expect(result.commands).toHaveLength(1);
+  });
+
+  it('should accept plan with noTestsRationale', () => {
+    const plan = { ...validPlan, noTestsRationale: 'Config-only change, no code logic' };
+    expect(TestPlanOutputSchema.parse(plan).noTestsRationale).toBe('Config-only change, no code logic');
+  });
+
+  it('should reject empty commands array', () => {
+    expect(() => TestPlanOutputSchema.parse({ ...validPlan, commands: [] })).toThrow();
+  });
+
+  it('should reject empty scope array', () => {
+    expect(() => TestPlanOutputSchema.parse({ ...validPlan, scope: [] })).toThrow();
+  });
+});
+
+describe('TestRunReviewSchema', () => {
+  const validReview = {
+    verdict: 'PASS' as const,
+    summary: 'All tests passed',
+    evidenceReviewed: ['test output'],
+    failures: [],
+    gaps: [],
+    recommendations: [],
+    requiresConsensus: false,
+  };
+
+  it('should accept a valid PASS review', () => {
+    expect(TestRunReviewSchema.parse(validReview).verdict).toBe('PASS');
+  });
+
+  it('should accept a FAIL review with failures', () => {
+    const review = {
+      ...validReview,
+      verdict: 'FAIL' as const,
+      failures: ['Login test failed'],
+      requiresConsensus: true,
+    };
+    expect(TestRunReviewSchema.parse(review).requiresConsensus).toBe(true);
+  });
+
+  it('should reject missing verdict', () => {
+    const { verdict, ...rest } = validReview;
+    expect(() => TestRunReviewSchema.parse(rest)).toThrow();
+  });
+
+  it('should reject empty evidenceReviewed', () => {
+    expect(() => TestRunReviewSchema.parse({ ...validReview, evidenceReviewed: [] })).toThrow();
+  });
+});
+
+describe('TestFixPlanSchema', () => {
+  const validFix = {
+    failedCriteria: ['Login returns 200'],
+    rootCauseAnalysis: 'Password hashing function is not async',
+    fixSteps: [{ file: 'src/auth.ts', change: 'Add await', reason: 'Async hash' }],
+    regressionRisks: ['May affect session handling'],
+    retestStrategy: 'Re-run login test suite',
+  };
+
+  it('should accept a valid fix plan', () => {
+    expect(TestFixPlanSchema.parse(validFix).rootCauseAnalysis).toContain('async');
+  });
+
+  it('should reject empty fixSteps', () => {
+    expect(() => TestFixPlanSchema.parse({ ...validFix, fixSteps: [] })).toThrow();
+  });
+
+  it('should reject empty failedCriteria', () => {
+    expect(() => TestFixPlanSchema.parse({ ...validFix, failedCriteria: [] })).toThrow();
+  });
+});
+
+describe('FixStepSchema', () => {
+  it('should accept valid fix step', () => {
+    const step = { file: 'src/index.ts', change: 'Fix import', reason: 'Missing module' };
+    expect(FixStepSchema.parse(step)).toEqual(step);
+  });
+
+  it('should reject empty file', () => {
+    expect(() => FixStepSchema.parse({ file: '', change: 'Fix', reason: 'Bug' })).toThrow();
+  });
+});