@howlil/ez-agents 3.4.2 → 4.0.0

package/ez-agents/tests/gates/gate-05-validator.test.cjs

@@ -0,0 +1,145 @@
+/**
+ * Gate 5 Validator Tests
+ * Tests for the testing coverage gate validator
+ */
+
+import { describe, it, beforeEach, afterEach } from 'vitest';
+import { strict as assert } from 'assert';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Import the validator
+const { validateCoverage, getArchetypeThresholds } = await import(path.join(__dirname, '../../../.planning/gates/gate-05-testing/validator.cjs'));
+
+describe('Gate 5 Validator', () => {
+  describe('getArchetypeThresholds', () => {
+    it('should return MVP thresholds', () => {
+      const thresholds = getArchetypeThresholds('mvp');
+      assert.strictEqual(thresholds.lines, 60);
+      assert.strictEqual(thresholds.branches, 40);
+      assert.strictEqual(thresholds.functions, 50);
+    });
+    
+    it('should return Medium thresholds', () => {
+      const thresholds = getArchetypeThresholds('medium');
+      assert.strictEqual(thresholds.lines, 80);
+      assert.strictEqual(thresholds.branches, 60);
+      assert.strictEqual(thresholds.functions, 70);
+    });
+    
+    it('should return Enterprise thresholds', () => {
+      const thresholds = getArchetypeThresholds('enterprise');
+      assert.strictEqual(thresholds.lines, 95);
+      assert.strictEqual(thresholds.branches, 80);
+      assert.strictEqual(thresholds.functions, 90);
+    });
+    
+    it('should throw for unknown archetype', () => {
+      assert.throws(
+        () => getArchetypeThresholds('invalid'),
+        /Unknown archetype/
+      );
+    });
+  });
+  
+  describe('validateCoverage', () => {
+    let tempDir;
+    
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gate5-test-'));
+    });
+    
+    afterEach(() => {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    });
+    
+    it('should return failure when coverage report missing', () => {
+      const result = validateCoverage(tempDir, 'mvp');
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.failures.some(f => f.includes('Coverage execution failed')));
+    });
+    
+    it('should return failure when coverage below threshold', () => {
+      // Create a mock coverage report with low coverage
+      const coverageDir = path.join(tempDir, 'coverage');
+      fs.mkdirSync(coverageDir);
+      
+      const mockCoverage = {
+        totals: {
+          lines: { pct: 30 },
+          branches: { pct: 20 },
+          functions: { pct: 25 }
+        }
+      };
+      
+      fs.writeFileSync(
+        path.join(coverageDir, 'coverage-summary.json'),
+        JSON.stringify(mockCoverage)
+      );
+      
+      const result = validateCoverage(tempDir, 'mvp');
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.failures.length > 0);
+      assert.ok(result.failures.some(f => f.includes('Lines coverage')));
+    });
+    
+    it('should return success when coverage meets threshold', () => {
+      // Create a mock coverage report with good coverage
+      const coverageDir = path.join(tempDir, 'coverage');
+      fs.mkdirSync(coverageDir);
+      
+      const mockCoverage = {
+        totals: {
+          lines: { pct: 70 },
+          branches: { pct: 50 },
+          functions: { pct: 60 }
+        }
+      };
+      
+      fs.writeFileSync(
+        path.join(coverageDir, 'coverage-summary.json'),
+        JSON.stringify(mockCoverage)
+      );
+      
+      const result = validateCoverage(tempDir, 'mvp');
+      assert.strictEqual(result.pass, true);
+      assert.strictEqual(result.failures.length, 0);
+      assert.strictEqual(result.report.lines, 70);
+    });
+    
+    it('should use correct thresholds for medium archetype', () => {
+      const coverageDir = path.join(tempDir, 'coverage');
+      fs.mkdirSync(coverageDir);
+      
+      const mockCoverage = {
+        totals: {
+          lines: { pct: 75 }, // Below medium (80%) but above mvp (60%)
+          branches: { pct: 55 },
+          functions: { pct: 65 }
+        }
+      };
+      
+      fs.writeFileSync(
+        path.join(coverageDir, 'coverage-summary.json'),
+        JSON.stringify(mockCoverage)
+      );
+      
+      // Should fail for medium
+      const mediumResult = validateCoverage(tempDir, 'medium');
+      assert.strictEqual(mediumResult.pass, false);
+      
+      // Should pass for mvp
+      const mvpResult = validateCoverage(tempDir, 'mvp');
+      assert.strictEqual(mvpResult.pass, true);
+    });
+  });
+});

package/ez-agents/tests/gates/gate-06-docs-validator.test.cjs

@@ -0,0 +1,244 @@
+/**
+ * Gate 6 Documentation Validator Tests
+ */
+
+import { describe, it, beforeEach, afterEach } from 'vitest';
+import { strict as assert } from 'assert';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Import the validator
+const { validateDocs, getRequiredDocs, validateSections } = await import(path.join(__dirname, '../../../.planning/gates/gate-06-docs/validator.cjs'));
+
+describe('Gate 6 Validator', () => {
+  describe('getRequiredDocs', () => {
+    it('should return MVP documentation requirements', () => {
+      const docs = getRequiredDocs('mvp');
+      assert.ok(Array.isArray(docs));
+      assert.ok(docs.some(d => d.path === 'README.md'));
+    });
+    
+    it('should return Medium documentation requirements', () => {
+      const docs = getRequiredDocs('medium');
+      assert.ok(docs.length >= 3);
+      assert.ok(docs.some(d => d.path === 'README.md'));
+      assert.ok(docs.some(d => d.path === 'docs/api.md'));
+      assert.ok(docs.some(d => d.path === 'docs/deployment.md'));
+    });
+    
+    it('should return Enterprise documentation requirements', () => {
+      const docs = getRequiredDocs('enterprise');
+      assert.ok(docs.length >= 5);
+      assert.ok(docs.some(d => d.path === 'docs/architecture.md'));
+      assert.ok(docs.some(d => d.path === 'docs/runbooks/'));
+    });
+    
+    it('should throw for unknown tier', () => {
+      assert.throws(
+        () => getRequiredDocs('invalid'),
+        /Unknown tier/
+      );
+    });
+  });
+  
+  describe('validateSections', () => {
+    let tempFile;
+    
+    beforeEach(() => {
+      tempFile = path.join(os.tmpdir(), `test-${Date.now()}.md`);
+    });
+    
+    afterEach(() => {
+      try {
+        fs.unlinkSync(tempFile);
+      } catch (e) {
+        // Ignore
+      }
+    });
+    
+    it('should return failure when document does not exist', () => {
+      const result = validateSections('/nonexistent/file.md', ['Section 1']);
+      assert.strictEqual(result.pass, false);
+      assert.strictEqual(result.exists, false);
+    });
+    
+    it('should return failure when document is too short', () => {
+      fs.writeFileSync(tempFile, 'too short');
+      const result = validateSections(tempFile, ['Section 1']);
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.missingSections.some(m => m.includes('too short')));
+    });
+    
+    it('should pass when all sections present', () => {
+      const content = `# Test Document
+
+## Section 1
+
+Content here.
+
+## Section 2
+
+More content.
+`;
+      fs.writeFileSync(tempFile, content);
+      const result = validateSections(tempFile, ['Section 1', 'Section 2']);
+      assert.strictEqual(result.pass, true);
+      assert.strictEqual(result.missingSections.length, 0);
+    });
+    
+    it('should fail when sections missing', () => {
+      const content = `# Test Document
+
+## Section 1
+
+This is some content here that makes the file longer than 50 bytes minimum requirement.
+`;
+      fs.writeFileSync(tempFile, content);
+      const result = validateSections(tempFile, ['Section 1', 'Section 2', 'Section 3']);
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.missingSections.some(m => m.includes('Section 2')));
+      assert.ok(result.missingSections.some(m => m.includes('Section 3')));
+    });
+  });
+  
+  describe('validateDocs', () => {
+    let tempDir;
+    
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gate6-test-'));
+    });
+    
+    afterEach(() => {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    });
+    
+    it('should fail when required documentation is missing', async () => {
+      const result = await validateDocs(tempDir, 'mvp');
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.failures.some(f => f.includes('Missing')));
+    });
+
+    it('should pass when MVP documentation exists with required sections', async () => {
+      // Create README.md with required sections
+      const readmeContent = `# Project
+
+Brief description of the project goes here to make the file longer.
+
+## Installation
+
+Install instructions with detailed content to meet minimum file size requirements.
+
+## Usage
+
+Usage instructions with detailed content to meet minimum file size requirements.
+
+## Configuration
+
+Config instructions with detailed content to meet minimum file size requirements.
+`;
+      fs.writeFileSync(path.join(tempDir, 'README.md'), readmeContent);
+
+      const result = await validateDocs(tempDir, 'mvp');
+      assert.strictEqual(result.pass, true);
+    });
+
+    it('should fail when sections are missing', async () => {
+      // Create README.md without all required sections
+      const readmeContent = `# Project
+
+## Installation
+
+Install instructions.
+`;
+      fs.writeFileSync(path.join(tempDir, 'README.md'), readmeContent);
+
+      const result = await validateDocs(tempDir, 'mvp');
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.failures.some(f => f.includes('Missing section')));
+    });
+    
+    it('should validate medium tier requirements', async () => {
+      // Create docs directory
+      const docsDir = path.join(tempDir, 'docs');
+      fs.mkdirSync(docsDir);
+
+      // Create README.md with sufficient content
+      fs.writeFileSync(path.join(tempDir, 'README.md'), `# Project
+
+Brief project description with enough content to meet minimum file size requirements.
+
+## Installation
+
+Installation instructions with detailed content to meet minimum file size requirements.
+
+## Usage
+
+Usage instructions with detailed content to meet minimum file size requirements.
+
+## Configuration
+
+Configuration instructions with detailed content to meet minimum file size requirements.
+
+## API Reference
+
+API reference overview with detailed content to meet minimum file size requirements.
+`);
+
+      // Create api.md with sufficient content
+      fs.writeFileSync(path.join(docsDir, 'api.md'), `# API Docs
+
+API documentation overview with enough content to meet minimum file size requirements.
+
+## Endpoints
+
+Endpoints section with detailed content to meet minimum file size requirements.
+
+## Request/Response
+
+Request/Response section with detailed content to meet minimum file size requirements.
+
+## Authentication
+
+Authentication section with detailed content to meet minimum file size requirements.
+
+## Error Codes
+
+Error Codes section with detailed content to meet minimum file size requirements.
+`);
+
+      // Create deployment.md with sufficient content
+      fs.writeFileSync(path.join(docsDir, 'deployment.md'), `# Deployment
+
+Deployment guide overview with enough content to meet minimum file size requirements.
+
+## Prerequisites
+
+Prerequisites section with detailed content to meet minimum file size requirements.
+
+## Environment Variables
+
+Environment Variables section with detailed content to meet minimum file size requirements.
+
+## Deploy Steps
+
+Deploy Steps section with detailed content to meet minimum file size requirements.
+
+## Rollback
+
+Rollback section with detailed content to meet minimum file size requirements.
+`);
+
+      const result = await validateDocs(tempDir, 'medium');
+      assert.strictEqual(result.pass, true);
+    });
+  });
+});

package/ez-agents/tests/gates/gate-07-release-validator.test.cjs

@@ -0,0 +1,219 @@
+/**
+ * Gate 7 Release Readiness Validator Tests
+ */
+
+import { describe, it, beforeEach, afterEach } from 'vitest';
+import { strict as assert } from 'assert';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Import the validator
+const {
+  validateReleaseReadiness,
+  getReleaseRequirements,
+  validateRollbackPlan
+} = await import(path.join(__dirname, '../../../.planning/gates/gate-07-release/validator.cjs'));
+
+describe('Gate 7 Validator', () => {
+  describe('getReleaseRequirements', () => {
+    it('should return MVP requirements', () => {
+      const reqs = getReleaseRequirements('mvp');
+      assert.ok(reqs.requirements.includes('smoke_tests'));
+      assert.ok(reqs.requirements.includes('rollback_plan'));
+    });
+    
+    it('should return Medium requirements', () => {
+      const reqs = getReleaseRequirements('medium');
+      assert.ok(reqs.requirements.includes('smoke_tests'));
+      assert.ok(reqs.requirements.includes('rollback_plan'));
+      assert.ok(reqs.requirements.includes('monitoring'));
+    });
+    
+    it('should return Enterprise requirements', () => {
+      const reqs = getReleaseRequirements('enterprise');
+      assert.ok(reqs.requirements.includes('smoke_tests'));
+      assert.ok(reqs.requirements.includes('rollback_plan'));
+      assert.ok(reqs.requirements.includes('monitoring'));
+      assert.ok(reqs.requirements.includes('runbooks'));
+    });
+    
+    it('should throw for unknown tier', () => {
+      assert.throws(
+        () => getReleaseRequirements('invalid'),
+        /Unknown tier/
+      );
+    });
+  });
+  
+  describe('validateRollbackPlan', () => {
+    let tempFile;
+    
+    beforeEach(() => {
+      tempFile = path.join(os.tmpdir(), `rollback-${Date.now()}.md`);
+    });
+    
+    afterEach(() => {
+      try {
+        fs.unlinkSync(tempFile);
+      } catch (e) {
+        // Ignore
+      }
+    });
+    
+    it('should return failure when rollback plan does not exist', () => {
+      const result = validateRollbackPlan('/nonexistent/rollback.md');
+      assert.strictEqual(result.pass, false);
+      assert.strictEqual(result.valid, false);
+    });
+    
+    it('should fail when rollback plan has too few steps', () => {
+      const content = `# Rollback Plan
+
+1. Stop the app
+2. Start the app
+`;
+      fs.writeFileSync(tempFile, content);
+      const result = validateRollbackPlan(tempFile);
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.issues.some(i => i.includes('too simple')));
+    });
+    
+    it('should pass when rollback plan is complete', () => {
+      const content = `# Rollback Plan
+
+## Backup Procedure
+1. Create database backup
+2. Backup current code
+
+## Revert Procedure  
+1. Stop the application
+2. Restore previous version
+3. Restore database from backup
+4. Restart application
+
+## Verification
+1. Check health endpoint
+2. Verify core functionality
+3. Monitor error rates
+`;
+      fs.writeFileSync(tempFile, content);
+      const result = validateRollbackPlan(tempFile);
+      assert.strictEqual(result.pass, true);
+      assert.ok(result.stepCount >= 3);
+    });
+    
+    it('should fail when missing backup procedure', () => {
+      const content = `# Rollback Plan
+
+1. Revert code
+2. Restart app
+`;
+      fs.writeFileSync(tempFile, content);
+      const result = validateRollbackPlan(tempFile);
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.issues.some(i => i.includes('backup')));
+    });
+  });
+  
+  describe('validateReleaseReadiness', () => {
+    let tempDir;
+    
+    beforeEach(() => {
+      tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'gate7-test-'));
+    });
+    
+    afterEach(() => {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    });
+    
+    it('should fail MVP when rollback plan missing', () => {
+      const result = validateReleaseReadiness(tempDir, 'mvp');
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.failures.some(f => f.includes('Rollback')));
+    });
+    
+    it('should pass MVP with valid rollback plan', () => {
+      // Create docs directory and rollback plan
+      const docsDir = path.join(tempDir, 'docs');
+      fs.mkdirSync(docsDir);
+      
+      const rollbackContent = `# Rollback Plan
+
+## Backup
+1. Backup database
+2. Backup code
+
+## Revert
+1. Stop application
+2. Restore previous version  
+3. Restore database
+4. Restart application
+
+## Verify
+1. Check health
+2. Test functionality
+`;
+      fs.writeFileSync(path.join(docsDir, 'rollback.md'), rollbackContent);
+      
+      const result = validateReleaseReadiness(tempDir, 'mvp');
+      assert.strictEqual(result.pass, true);
+      assert.strictEqual(result.rollback_valid, true);
+    });
+    
+    it('should fail medium tier without monitoring', () => {
+      // Create valid rollback
+      const docsDir = path.join(tempDir, 'docs');
+      fs.mkdirSync(docsDir);
+      fs.writeFileSync(path.join(docsDir, 'rollback.md'), `# Rollback
+
+## Backup
+1. Backup DB
+
+## Revert  
+1. Stop
+2. Restore
+3. Start
+
+## Verify
+1. Check
+`);
+      
+      const result = validateReleaseReadiness(tempDir, 'medium');
+      assert.strictEqual(result.pass, false);
+      assert.ok(result.failures.some(f => f.includes('Monitoring')));
+    });
+    
+    it('should pass medium tier with monitoring configured', () => {
+      // Create docs and monitoring
+      const docsDir = path.join(tempDir, 'docs');
+      fs.mkdirSync(docsDir);
+      fs.mkdirSync(path.join(tempDir, '.planning', 'observability'), { recursive: true });
+
+      fs.writeFileSync(path.join(docsDir, 'rollback.md'), `# Rollback
+
+## Backup
+1. Backup DB
+
+## Revert
+1. Stop
+2. Restore previous version
+3. Start
+
+## Verify
+1. Check
+`);
+
+      const result = validateReleaseReadiness(tempDir, 'medium');
+      assert.strictEqual(result.pass, true, `Expected pass but got failures: ${result.failures.join(', ')}`);
+    });
+  });
+});