jettypod 4.1.2 → 4.1.4

package/lib/production-scenario-appender.test.js

@@ -1,235 +0,0 @@
-const {
-  appendScenarios,
-  formatScenarioForAppend,
-  generateTitleFromStandard,
-  extractScenarioTitles,
-  extractScenarioTitle,
-  deduplicateScenarios
-} = require('./production-scenario-appender');
-const fs = require('fs');
-const path = require('path');
-
-describe('production-scenario-appender', () => {
-  let testDir;
-
-  beforeEach(() => {
-    testDir = path.join(__dirname, '../test-tmp', `scenario-appender-${Date.now()}`);
-    fs.mkdirSync(testDir, { recursive: true });
-    process.chdir(testDir);
-  });
-
-  afterEach(() => {
-    if (testDir && fs.existsSync(testDir)) {
-      fs.rmSync(testDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('generateTitleFromStandard', () => {
-    test('converts snake_case to Title Case', () => {
-      const standard = {
-        id: 'tls_enforced',
-        domain: 'security'
-      };
-
-      const title = generateTitleFromStandard(standard);
-      expect(title).toBe('Security - Tls Enforced (production mode)');
-    });
-
-    test('handles multi-word IDs', () => {
-      const standard = {
-        id: 'performance_budgets_enforced',
-        domain: 'performance'
-      };
-
-      const title = generateTitleFromStandard(standard);
-      expect(title).toBe('Performance - Performance Budgets Enforced (production mode)');
-    });
-  });
-
-  describe('formatScenarioForAppend', () => {
-    test('formats security standard as scenario', () => {
-      const standard = {
-        id: 'tls_enforced',
-        domain: 'security',
-        acceptance: 'HSTS ≥ 6mo; TLS ≥1.2'
-      };
-
-      const scenario = formatScenarioForAppend(standard);
-
-      expect(scenario).toContain('Scenario: Security - Tls Enforced');
-      expect(scenario).toContain('Given the system is deployed to production');
-      expect(scenario).toContain('Then HSTS ≥ 6mo; TLS ≥1.2');
-    });
-
-    test('formats performance standard as scenario', () => {
-      const standard = {
-        id: 'performance_budgets',
-        domain: 'performance',
-        acceptance: 'p95 < 2s'
-      };
-
-      const scenario = formatScenarioForAppend(standard);
-
-      expect(scenario).toContain('Scenario: Performance - Performance Budgets');
-      expect(scenario).toContain('Given the system is under production load');
-      expect(scenario).toContain('Then p95 < 2s');
-    });
-  });
-
-  describe('extractScenarioTitles', () => {
-    test('extracts titles from content', () => {
-      const content = `Feature: Test
-
-Scenario: User logs in
-  Given credentials
-  When submitting
-  Then success
-
-Scenario: Password reset
-  Given forgot password
-  When requesting reset
-  Then email sent`;
-
-      const titles = extractScenarioTitles(content);
-
-      expect(titles).toHaveLength(2);
-      expect(titles).toContain('user logs in');
-      expect(titles).toContain('password reset');
-    });
-
-    test('returns empty array for no scenarios', () => {
-      const content = 'Feature: Test\n\nNo scenarios here';
-
-      const titles = extractScenarioTitles(content);
-      expect(titles).toEqual([]);
-    });
-  });
-
-  describe('extractScenarioTitle', () => {
-    test('extracts title from scenario string', () => {
-      const scenario = `Scenario: User logs in
-  Given credentials
-  Then success`;
-
-      const title = extractScenarioTitle(scenario);
-      expect(title).toBe('User logs in');
-    });
-
-    test('returns null for invalid scenario', () => {
-      const scenario = 'Not a scenario';
-
-      const title = extractScenarioTitle(scenario);
-      expect(title).toBeNull();
-    });
-  });
-
-  describe('appendScenarios', () => {
-    test('throws error when file not found', async () => {
-      await expect(appendScenarios('nonexistent.feature', []))
-        .rejects.toThrow('Scenario file not found');
-    });
-
-    test('adds production mode header if not present', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, 'Feature: Test\n\nScenario: Happy path\n  Given test\n');
-
-      const newScenarios = ['Scenario: New scenario\n  Given production\n  Then test'];
-
-      await appendScenarios('test.feature', newScenarios);
-
-      const content = fs.readFileSync(scenarioFile, 'utf8');
-      expect(content).toContain('# PRODUCTION MODE SCENARIOS');
-      expect(content).toContain('Scenario: New scenario');
-    });
-
-    test('does not duplicate production mode header', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, `Feature: Test
-
-# PRODUCTION MODE SCENARIOS
-
-Scenario: Existing production scenario
-  Given test
-`);
-
-      const newScenarios = ['Scenario: New scenario\n  Given production\n  Then test'];
-
-      await appendScenarios('test.feature', newScenarios);
-
-      const content = fs.readFileSync(scenarioFile, 'utf8');
-      const headerCount = (content.match(/# PRODUCTION MODE SCENARIOS/g) || []).length;
-      expect(headerCount).toBe(1);
-    });
-
-    test('deduplicates scenarios by title', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, `Feature: Test
-
-Scenario: Existing scenario
-  Given test
-`);
-
-      const newScenarios = [
-        'Scenario: Existing scenario\n  Given duplicate\n  Then skip',
-        'Scenario: New scenario\n  Given production\n  Then test'
-      ];
-
-      const result = await appendScenarios('test.feature', newScenarios);
-
-      expect(result.added).toBe(1);
-      expect(result.skipped).toBe(1);
-
-      const content = fs.readFileSync(scenarioFile, 'utf8');
-      expect(content).toContain('Scenario: New scenario');
-      expect(content.match(/Scenario: Existing scenario/g)).toHaveLength(1);
-    });
-  });
-
-  describe('deduplicateScenarios', () => {
-    test('removes duplicate scenarios', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, `Feature: Test
-
-Scenario: Test scenario
-  Given test1
-  Then success
-
-Scenario: Another scenario
-  Given test2
-  Then success
-
-Scenario: Test scenario
-  Given duplicate
-  Then success
-`);
-
-      const result = await deduplicateScenarios('test.feature');
-
-      expect(result.duplicatesRemoved).toBe(1);
-
-      const content = fs.readFileSync(scenarioFile, 'utf8');
-      expect(content.match(/Scenario: Test scenario/g)).toHaveLength(1);
-      expect(content.match(/Scenario: Another scenario/g)).toHaveLength(1);
-    });
-
-    test('preserves first occurrence of duplicate', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, `Feature: Test
-
-Scenario: Test scenario
-  Given test1
-  Then success
-
-Scenario: Test scenario
-  Given test2
-  Then success
-`);
-
-      await deduplicateScenarios('test.feature');
-
-      const content = fs.readFileSync(scenarioFile, 'utf8');
-      expect(content).toContain('Given test1');
-      expect(content).not.toContain('Given test2');
-    });
-  });
-});

package/lib/production-scenario-validator.test.js

@@ -1,246 +0,0 @@
-const {
-  validateScenarios,
-  parseScenarios,
-  matchStandardToScenario,
-  generateKeywords
-} = require('./production-scenario-validator');
-const fs = require('fs');
-const path = require('path');
-
-describe('production-scenario-validator', () => {
-  let testDir;
-
-  beforeEach(() => {
-    testDir = path.join(__dirname, '../test-tmp', `scenario-validator-${Date.now()}`);
-    fs.mkdirSync(testDir, { recursive: true });
-    process.chdir(testDir);
-  });
-
-  afterEach(() => {
-    if (testDir && fs.existsSync(testDir)) {
-      fs.rmSync(testDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('parseScenarios', () => {
-    test('parses single scenario', () => {
-      const content = `Feature: Test
-
-Scenario: User logs in
-  Given I am on the login page
-  When I enter credentials
-  Then I am logged in`;
-
-      const scenarios = parseScenarios(content);
-
-      expect(scenarios).toHaveLength(1);
-      expect(scenarios[0].title).toBe('User logs in');
-      expect(scenarios[0].content).toContain('Given I am on the login page');
-    });
-
-    test('parses multiple scenarios', () => {
-      const content = `Feature: Test
-
-Scenario: Happy path
-  Given initial state
-  When action
-  Then success
-
-Scenario: Error case
-  Given error state
-  When action
-  Then error`;
-
-      const scenarios = parseScenarios(content);
-
-      expect(scenarios).toHaveLength(2);
-      expect(scenarios[0].title).toBe('Happy path');
-      expect(scenarios[1].title).toBe('Error case');
-    });
-
-    test('returns empty array for no scenarios', () => {
-      const content = 'Feature: Test\n\nNo scenarios here';
-
-      const scenarios = parseScenarios(content);
-
-      expect(scenarios).toHaveLength(0);
-    });
-  });
-
-  describe('generateKeywords', () => {
-    test('generates keywords from standard ID', () => {
-      const standard = {
-        id: 'tls_enforced',
-        domain: 'security',
-        acceptance: 'TLS 1.2 required'
-      };
-
-      const keywords = generateKeywords(standard);
-
-      expect(keywords).toContain('tls');
-      expect(keywords).toContain('enforced');
-    });
-
-    test('includes domain-specific keywords', () => {
-      const standard = {
-        id: 'test_security',
-        domain: 'security',
-        acceptance: 'test'
-      };
-
-      const keywords = generateKeywords(standard);
-
-      expect(keywords).toContain('authentication');
-      expect(keywords).toContain('encryption');
-      expect(keywords).toContain('rate limiting');
-    });
-
-    test('includes keywords from acceptance criteria', () => {
-      const standard = {
-        id: 'test',
-        domain: 'performance',
-        acceptance: 'p95 latency < 2s; load testing required'
-      };
-
-      const keywords = generateKeywords(standard);
-
-      expect(keywords).toContain('latency');
-      expect(keywords).toContain('load');
-      expect(keywords).toContain('testing');
-      expect(keywords).toContain('required');
-    });
-  });
-
-  describe('matchStandardToScenario', () => {
-    test('returns false when no scenarios match', () => {
-      const standard = {
-        id: 'tls_enforced',
-        domain: 'security',
-        acceptance: 'TLS 1.2 required'
-      };
-
-      const scenarios = [
-        {
-          title: 'User login',
-          content: 'Given I am logged in'
-        }
-      ];
-
-      const result = matchStandardToScenario(standard, scenarios);
-      expect(result).toBe(false);
-    });
-
-    test('returns true when scenario matches standard', () => {
-      const standard = {
-        id: 'tls_enforced',
-        domain: 'security',
-        acceptance: 'TLS 1.2 required'
-      };
-
-      const scenarios = [
-        {
-          title: 'TLS encryption is enforced',
-          content: 'Given HTTPS is enabled\nWhen connecting\nThen TLS 1.2 is required'
-        }
-      ];
-
-      const result = matchStandardToScenario(standard, scenarios);
-      expect(result).toBe(true);
-    });
-
-    test('matches on domain keywords', () => {
-      const standard = {
-        id: 'auth_required',
-        domain: 'security',
-        acceptance: 'Authentication required for all endpoints'
-      };
-
-      const scenarios = [
-        {
-          title: 'User authentication',
-          content: 'Given user has valid credentials\nWhen accessing API\nThen authentication succeeds'
-        }
-      ];
-
-      const result = matchStandardToScenario(standard, scenarios);
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('validateScenarios', () => {
-    test('throws error when scenario file not found', async () => {
-      const standards = {
-        standards: []
-      };
-
-      await expect(validateScenarios('nonexistent.feature', standards))
-        .rejects.toThrow('Scenario file not found');
-    });
-
-    test('returns all gaps when no scenarios exist', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, 'Feature: Test\n\n');
-
-      const standards = {
-        standards: [
-          {
-            id: 'tls_enforced',
-            domain: 'security',
-            acceptance: 'TLS 1.2',
-            reasoning: 'Security requirement'
-          },
-          {
-            id: 'performance_budgets',
-            domain: 'performance',
-            acceptance: 'p95 < 2s',
-            reasoning: 'Performance requirement'
-          }
-        ]
-      };
-
-      const result = await validateScenarios('test.feature', standards);
-
-      expect(result.covered).toBe(0);
-      expect(result.total).toBe(2);
-      expect(result.gaps).toHaveLength(2);
-      expect(result.hasGaps).toBe(true);
-    });
-
-    test('returns no gaps when all standards are covered', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, `Feature: Test
-
-Scenario: TLS encryption
-  Given HTTPS enabled
-  When connecting
-  Then TLS 1.2 required
-
-Scenario: Performance testing
-  Given system under load
-  When measuring latency
-  Then p95 < 2s`);
-
-      const standards = {
-        standards: [
-          {
-            id: 'tls_enforced',
-            domain: 'security',
-            acceptance: 'TLS 1.2'
-          },
-          {
-            id: 'performance_budgets',
-            domain: 'performance',
-            acceptance: 'p95 < 2s'
-          }
-        ]
-      };
-
-      const result = await validateScenarios('test.feature', standards);
-
-      expect(result.covered).toBe(2);
-      expect(result.total).toBe(2);
-      expect(result.gaps).toHaveLength(0);
-      expect(result.hasGaps).toBe(false);
-    });
-  });
-});