@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/tests/unit/rule-evaluator.test.ts

@@ -0,0 +1,318 @@
+/**
+ * Unit Tests for RuleEvaluator
+ * Tests code evaluation, violation detection, and reporting
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { RuleEvaluator } from '../../src/rule-evaluator';
+import { RuleRegistry } from '../../src/registry';
+import { ConfigurationManager } from '../../src/config-manager';
+
+describe('RuleEvaluator', () => {
+  let tempDir: string;
+  let rulesPath: string;
+  let configPath: string;
+  let registry: RuleRegistry;
+  let configManager: ConfigurationManager;
+  let evaluator: RuleEvaluator;
+
+  beforeEach(async () => {
+    // Create temporary directories
+    tempDir = path.join(__dirname, '../fixtures/temp-evaluator');
+    rulesPath = path.join(tempDir, 'rules');
+    configPath = tempDir;
+    
+    await fs.mkdir(path.join(rulesPath, 'universal'), { recursive: true });
+    await fs.mkdir(path.join(configPath, '.augment'), { recursive: true });
+    
+    // Create sample rules
+    await createSampleRules();
+    
+    // Initialize components
+    registry = new RuleRegistry(rulesPath);
+    await registry.loadRules();
+    
+    configManager = new ConfigurationManager(configPath);
+    await configManager.load();
+    
+    evaluator = new RuleEvaluator(registry, configManager);
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+
+  async function createSampleRules() {
+    const namingRule = `# Rule: Naming Conventions
+
+## Metadata
+- **ID**: universal-naming
+- **Category**: universal
+- **Severity**: ERROR
+
+## Description
+Use snake_case for functions and variables.
+
+## Pattern
+Functions and variables must use snake_case: ^[a-z][a-z0-9_]*$
+
+## Examples
+
+### Bad Example
+\`\`\`c
+int myFunction() { return 0; }
+int MyVariable = 5;
+\`\`\`
+
+### Good Example
+\`\`\`c
+int my_function() { return 0; }
+int my_variable = 5;
+\`\`\`
+`;
+
+    await fs.writeFile(path.join(rulesPath, 'universal/naming.md'), namingRule);
+  }
+
+  describe('evaluate()', () => {
+    it('should detect naming violations', async () => {
+      const code = `
+int myFunction() {
+    int MyVariable = 5;
+    return MyVariable;
+}
+`;
+      
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming']
+      });
+      
+      expect(violations.length).toBeGreaterThan(0);
+      expect(violations[0].ruleId).toBe('universal-naming');
+      expect(violations[0].severity).toBe('ERROR');
+    });
+
+    it('should not report violations for compliant code', async () => {
+      const code = `
+int my_function() {
+    int my_variable = 5;
+    return my_variable;
+}
+`;
+      
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming']
+      });
+      
+      expect(violations.length).toBe(0);
+    });
+
+    it('should include line numbers in violations', async () => {
+      const code = `
+int myFunction() {
+    return 0;
+}
+`;
+      
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming']
+      });
+      
+      if (violations.length > 0) {
+        expect(violations[0].line).toBeDefined();
+        expect(violations[0].line).toBeGreaterThan(0);
+      }
+    });
+
+    it('should include suggestions for fixes', async () => {
+      const code = `
+int myFunction() {
+    return 0;
+}
+`;
+      
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming']
+      });
+      
+      if (violations.length > 0) {
+        expect(violations[0].suggestion).toBeDefined();
+        expect(violations[0].suggestion.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should filter by severity', async () => {
+      const code = `int myFunction() { return 0; }`;
+      
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming'],
+        minSeverity: 'WARNING'
+      });
+      
+      expect(violations.every(v => v.severity === 'ERROR' || v.severity === 'WARNING')).toBe(true);
+    });
+  });
+
+  describe('applyRule()', () => {
+    it('should apply single rule to code', async () => {
+      const code = `int myFunction() { return 0; }`;
+      const rule = registry.getRule('universal-naming');
+
+      if (rule) {
+        const violations = await evaluator.applyRule(code, rule);
+        expect(Array.isArray(violations)).toBe(true);
+      }
+    });
+
+    it('should return empty array for compliant code', async () => {
+      const code = `int my_function() { return 0; }`;
+      const rule = registry.getRule('universal-naming');
+
+      if (rule) {
+        const violations = await evaluator.applyRule(code, rule);
+        expect(violations.length).toBe(0);
+      }
+    });
+  });
+
+  describe('evaluateBatch()', () => {
+    it('should evaluate multiple files', async () => {
+      const files = [
+        {
+          path: '/project/src/file1.c',
+          content: 'int myFunction() { return 0; }'
+        },
+        {
+          path: '/project/src/file2.c',
+          content: 'int my_function() { return 0; }'
+        }
+      ];
+
+      const results = await evaluator.evaluateBatch(files, {
+        rules: ['universal-naming']
+      });
+
+      expect(results.length).toBe(2);
+      expect(results[0].filePath).toBe('/project/src/file1.c');
+      expect(results[1].filePath).toBe('/project/src/file2.c');
+    });
+
+    it('should report violations per file', async () => {
+      const files = [
+        {
+          path: '/project/src/file1.c',
+          content: 'int myFunction() { return 0; }'
+        }
+      ];
+
+      const results = await evaluator.evaluateBatch(files, {
+        rules: ['universal-naming']
+      });
+
+      expect(results[0].violations).toBeDefined();
+      expect(Array.isArray(results[0].violations)).toBe(true);
+    });
+  });
+
+  describe('generateReport()', () => {
+    it('should generate text report', async () => {
+      const code = `int myFunction() { return 0; }`;
+
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming']
+      });
+
+      const report = evaluator.generateReport(violations, { format: 'text' });
+
+      expect(report).toBeDefined();
+      expect(typeof report).toBe('string');
+      expect(report.length).toBeGreaterThan(0);
+    });
+
+    it('should generate JSON report', async () => {
+      const code = `int myFunction() { return 0; }`;
+
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming']
+      });
+
+      const report = evaluator.generateReport(violations, { format: 'json' });
+
+      expect(report).toBeDefined();
+      expect(() => JSON.parse(report)).not.toThrow();
+    });
+
+    it('should include summary statistics', async () => {
+      const code = `int myFunction() { return 0; }`;
+
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming']
+      });
+
+      const report = evaluator.generateReport(violations, {
+        format: 'json',
+        includeSummary: true
+      });
+
+      const parsed = JSON.parse(report);
+      expect(parsed.summary).toBeDefined();
+      expect(parsed.summary.total).toBeDefined();
+    });
+  });
+
+  describe('getViolationsByFile()', () => {
+    it('should group violations by file', async () => {
+      const files = [
+        {
+          path: '/project/src/file1.c',
+          content: 'int myFunction() { return 0; }'
+        },
+        {
+          path: '/project/src/file2.c',
+          content: 'int anotherBadName() { return 0; }'
+        }
+      ];
+
+      const results = await evaluator.evaluateBatch(files, {
+        rules: ['universal-naming']
+      });
+
+      const grouped = evaluator.getViolationsByFile(results);
+
+      expect(Object.keys(grouped).length).toBeGreaterThan(0);
+      expect(grouped['/project/src/file1.c']).toBeDefined();
+    });
+  });
+
+  describe('getViolationsBySeverity()', () => {
+    it('should group violations by severity', async () => {
+      const code = `int myFunction() { return 0; }`;
+
+      const violations = await evaluator.evaluate(code, {
+        filePath: '/project/src/main.c',
+        rules: ['universal-naming']
+      });
+
+      const grouped = evaluator.getViolationsBySeverity(violations);
+
+      expect(grouped).toBeDefined();
+      if (violations.length > 0) {
+        expect(grouped.ERROR || grouped.WARNING).toBeDefined();
+      }
+    });
+  });
+});
+

package/augment-extensions/coding-standards/c/tests/unit/rule-override.test.ts

@@ -0,0 +1,326 @@
+/**
+ * Unit Tests for RuleOverrideSystem
+ * Tests rule override application, validation, and management
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { RuleOverrideSystem } from '../../src/rule-override';
+import { RuleRegistry } from '../../src/registry';
+import { ConfigurationManager } from '../../src/config-manager';
+
+describe('RuleOverrideSystem', () => {
+  let tempDir: string;
+  let rulesPath: string;
+  let configPath: string;
+  let registry: RuleRegistry;
+  let configManager: ConfigurationManager;
+  let overrideSystem: RuleOverrideSystem;
+
+  beforeEach(async () => {
+    // Create temporary directories
+    tempDir = path.join(__dirname, '../fixtures/temp-overrides');
+    rulesPath = path.join(tempDir, 'rules');
+    configPath = tempDir;
+    
+    await fs.mkdir(path.join(rulesPath, 'universal'), { recursive: true });
+    await fs.mkdir(path.join(configPath, '.augment'), { recursive: true });
+    
+    // Create sample rules
+    await createSampleRules();
+    
+    // Initialize components
+    registry = new RuleRegistry(rulesPath);
+    await registry.loadRules();
+    
+    configManager = new ConfigurationManager(configPath);
+    await configManager.load();
+    
+    overrideSystem = new RuleOverrideSystem(registry, configManager);
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+
+  async function createSampleRules() {
+    const namingRule = `# Rule: Naming Conventions
+
+## Metadata
+- **ID**: universal-naming
+- **Category**: universal
+- **Severity**: ERROR
+
+## Description
+Use snake_case for functions and variables.
+`;
+
+    await fs.writeFile(path.join(rulesPath, 'universal/naming.md'), namingRule);
+  }
+
+  describe('applyOverride()', () => {
+    it('should apply severity override', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+      
+      const rule = registry.getRule('universal-naming');
+      expect(rule?.severity).toBe('WARNING');
+    });
+
+    it('should apply enabled override', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        enabled: false
+      });
+      
+      const rule = registry.getRule('universal-naming');
+      expect(rule?.enabled).toBe(false);
+    });
+
+    it('should apply multiple overrides', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING',
+        enabled: false
+      });
+      
+      const rule = registry.getRule('universal-naming');
+      expect(rule?.severity).toBe('WARNING');
+      expect(rule?.enabled).toBe(false);
+    });
+
+    it('should throw error for non-existent rule', () => {
+      expect(() => {
+        overrideSystem.applyOverride('nonexistent-rule', {
+          severity: 'WARNING'
+        });
+      }).toThrow('Rule not found');
+    });
+  });
+
+  describe('removeOverride()', () => {
+    it('should remove override and restore original', () => {
+      const originalRule = registry.getRule('universal-naming');
+      const originalSeverity = originalRule?.severity;
+      
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+      
+      overrideSystem.removeOverride('universal-naming');
+      
+      const rule = registry.getRule('universal-naming');
+      expect(rule?.severity).toBe(originalSeverity);
+    });
+
+    it('should handle removing non-existent override', () => {
+      expect(() => {
+        overrideSystem.removeOverride('universal-naming');
+      }).not.toThrow();
+    });
+  });
+
+  describe('getOverride()', () => {
+    it('should return override for rule', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+      
+      const override = overrideSystem.getOverride('universal-naming');
+      
+      expect(override).toBeDefined();
+      expect(override?.severity).toBe('WARNING');
+    });
+
+    it('should return undefined for non-overridden rule', () => {
+      const override = overrideSystem.getOverride('universal-naming');
+      expect(override).toBeUndefined();
+    });
+  });
+
+  describe('getAllOverrides()', () => {
+    it('should return all active overrides', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+      
+      const overrides = overrideSystem.getAllOverrides();
+      
+      expect(Object.keys(overrides).length).toBeGreaterThan(0);
+      expect(overrides['universal-naming']).toBeDefined();
+    });
+
+    it('should return empty object when no overrides', () => {
+      const overrides = overrideSystem.getAllOverrides();
+      expect(Object.keys(overrides).length).toBe(0);
+    });
+  });
+
+  describe('validateOverride()', () => {
+    it('should validate correct override', () => {
+      const result = overrideSystem.validateOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+      
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should reject invalid severity', () => {
+      const result = overrideSystem.validateOverride('universal-naming', {
+        severity: 'INVALID' as any
+      });
+      
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('should reject override for non-existent rule', () => {
+      const result = overrideSystem.validateOverride('nonexistent-rule', {
+        severity: 'WARNING'
+      });
+      
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe('applyBatchOverrides()', () => {
+    it('should apply multiple overrides at once', () => {
+      const overrides = {
+        'universal-naming': {
+          severity: 'WARNING' as const
+        }
+      };
+
+      overrideSystem.applyBatchOverrides(overrides);
+
+      const rule = registry.getRule('universal-naming');
+      expect(rule?.severity).toBe('WARNING');
+    });
+
+    it('should validate all overrides before applying', () => {
+      const overrides = {
+        'universal-naming': {
+          severity: 'INVALID' as any
+        }
+      };
+
+      expect(() => {
+        overrideSystem.applyBatchOverrides(overrides);
+      }).toThrow();
+    });
+  });
+
+  describe('clearAllOverrides()', () => {
+    it('should clear all overrides', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+
+      overrideSystem.clearAllOverrides();
+
+      const overrides = overrideSystem.getAllOverrides();
+      expect(Object.keys(overrides).length).toBe(0);
+    });
+
+    it('should restore original rule values', () => {
+      const originalRule = registry.getRule('universal-naming');
+      const originalSeverity = originalRule?.severity;
+
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+
+      overrideSystem.clearAllOverrides();
+
+      const rule = registry.getRule('universal-naming');
+      expect(rule?.severity).toBe(originalSeverity);
+    });
+  });
+
+  describe('exportOverrides()', () => {
+    it('should export overrides to JSON', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+
+      const json = overrideSystem.exportOverrides('json');
+
+      expect(json).toBeDefined();
+      expect(() => JSON.parse(json)).not.toThrow();
+    });
+
+    it('should export overrides to YAML', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+
+      const yaml = overrideSystem.exportOverrides('yaml');
+
+      expect(yaml).toBeDefined();
+      expect(yaml.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('importOverrides()', () => {
+    it('should import overrides from JSON', () => {
+      const json = JSON.stringify({
+        'universal-naming': {
+          severity: 'WARNING'
+        }
+      });
+
+      overrideSystem.importOverrides(json, 'json');
+
+      const rule = registry.getRule('universal-naming');
+      expect(rule?.severity).toBe('WARNING');
+    });
+
+    it('should validate imported overrides', () => {
+      const invalidJson = JSON.stringify({
+        'universal-naming': {
+          severity: 'INVALID'
+        }
+      });
+
+      expect(() => {
+        overrideSystem.importOverrides(invalidJson, 'json');
+      }).toThrow();
+    });
+  });
+
+  describe('hasOverride()', () => {
+    it('should return true for overridden rule', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+
+      expect(overrideSystem.hasOverride('universal-naming')).toBe(true);
+    });
+
+    it('should return false for non-overridden rule', () => {
+      expect(overrideSystem.hasOverride('universal-naming')).toBe(false);
+    });
+  });
+
+  describe('getOverrideHistory()', () => {
+    it('should track override history', () => {
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'WARNING'
+      });
+
+      overrideSystem.applyOverride('universal-naming', {
+        severity: 'ERROR'
+      });
+
+      const history = overrideSystem.getOverrideHistory('universal-naming');
+
+      expect(history).toBeDefined();
+      expect(history.length).toBeGreaterThan(0);
+    });
+  });
+});
+