@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/tests/unit/config-manager.test.ts

@@ -0,0 +1,345 @@
+/**
+ * Unit Tests for ConfigurationManager
+ * Tests configuration loading, validation, merging, and hot-reload
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ConfigurationManager } from '../../src/config-manager';
+import { Configuration } from '../../src/types';
+
+describe('ConfigurationManager', () => {
+  let tempDir: string;
+  let configManager: ConfigurationManager;
+
+  beforeEach(async () => {
+    // Create temporary directory for tests
+    tempDir = path.join(__dirname, '../fixtures/temp-config');
+    await fs.mkdir(tempDir, { recursive: true });
+    await fs.mkdir(path.join(tempDir, '.augment'), { recursive: true });
+    
+    configManager = new ConfigurationManager(tempDir);
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directory
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('load()', () => {
+    it('should load default configuration when no user config exists', async () => {
+      const config = await configManager.load();
+      
+      expect(config).toBeDefined();
+      expect(config.c_standards).toBeDefined();
+      expect(config.c_standards.version).toBe('1.0.0');
+      expect(config.c_standards.categories).toContain('systems');
+    });
+
+    it('should load and merge JSON configuration', async () => {
+      const userConfig: Configuration = {
+        c_standards: {
+          version: '1.0.0',
+          categories: ['embedded', 'realtime'],
+          c_standard: 'c99',
+          universal_rules: {
+            naming: 'enabled',
+            memory_safety: 'enabled',
+            error_handling: 'warning',
+            documentation: 'enabled',
+            header_guards: 'enabled',
+            const_correctness: 'warning'
+          },
+          category_overrides: {
+            embedded: {
+              allow_dynamic_allocation: false
+            }
+          },
+          static_analysis: {
+            clang_tidy: true,
+            cppcheck: true,
+            valgrind: false
+          },
+          custom_rules: {
+            enabled: false,
+            path: '.augment/c-standards/custom-rules/'
+          }
+        }
+      };
+
+      await fs.writeFile(
+        path.join(tempDir, '.augment/c-standards.json'),
+        JSON.stringify(userConfig, null, 2)
+      );
+
+      const config = await configManager.load();
+      
+      expect(config.c_standards.categories).toEqual(['embedded', 'realtime']);
+      expect(config.c_standards.c_standard).toBe('c99');
+      expect(config.c_standards.universal_rules?.error_handling).toBe('warning');
+    });
+
+    it('should load and merge YAML configuration', async () => {
+      const yamlConfig = `
+c_standards:
+  version: "1.0.0"
+  categories:
+    - kernel
+    - drivers
+  c_standard: c11
+  universal_rules:
+    naming: enabled
+    memory_safety: enabled
+    error_handling: enabled
+    documentation: warning
+    header_guards: enabled
+    const_correctness: enabled
+`;
+
+      await fs.writeFile(
+        path.join(tempDir, '.augment/c-standards.yaml'),
+        yamlConfig
+      );
+
+      const config = await configManager.load();
+      
+      expect(config.c_standards.categories).toEqual(['kernel', 'drivers']);
+      expect(config.c_standards.c_standard).toBe('c11');
+    });
+
+    it('should throw error for invalid JSON', async () => {
+      await fs.writeFile(
+        path.join(tempDir, '.augment/c-standards.json'),
+        '{ invalid json }'
+      );
+
+      await expect(configManager.load()).rejects.toThrow('Failed to parse JSON configuration');
+    });
+
+    it('should throw error for invalid schema', async () => {
+      const invalidConfig = {
+        c_standards: {
+          version: '1.0.0',
+          categories: 'not-an-array', // Should be array
+          c_standard: 'c11'
+        }
+      };
+
+      await fs.writeFile(
+        path.join(tempDir, '.augment/c-standards.json'),
+        JSON.stringify(invalidConfig)
+      );
+
+      await expect(configManager.load()).rejects.toThrow('Invalid configuration');
+    });
+  });
+
+  describe('validateConfiguration()', () => {
+    it('should validate correct configuration', async () => {
+      await configManager.load();
+      const config = configManager.getConfiguration();
+      const result = configManager.validateConfiguration(config);
+      
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should warn about inactive category overrides', async () => {
+      const config: Configuration = {
+        c_standards: {
+          version: '1.0.0',
+          categories: ['systems'],
+          c_standard: 'c11',
+          universal_rules: {
+            naming: 'enabled',
+            memory_safety: 'enabled',
+            error_handling: 'enabled',
+            documentation: 'enabled',
+            header_guards: 'enabled',
+            const_correctness: 'enabled'
+          },
+          category_overrides: {
+            embedded: { // Not in active categories
+              allow_dynamic_allocation: false
+            }
+          },
+          static_analysis: {
+            clang_tidy: false,
+            cppcheck: false,
+            valgrind: false
+          },
+          custom_rules: {
+            enabled: false,
+            path: '.augment/c-standards/custom-rules/'
+          }
+        }
+      };
+
+      await configManager.load();
+      const result = configManager.validateConfiguration(config);
+      
+      expect(result.warnings.length).toBeGreaterThan(0);
+      expect(result.warnings[0]).toContain('embedded');
+    });
+  });
+
+  describe('getConfiguration()', () => {
+    it('should return loaded configuration', async () => {
+      await configManager.load();
+      const config = configManager.getConfiguration();
+
+      expect(config).toBeDefined();
+      expect(config.c_standards).toBeDefined();
+    });
+
+    it('should throw error if configuration not loaded', () => {
+      const newManager = new ConfigurationManager(tempDir);
+      expect(() => newManager.getConfiguration()).toThrow('Configuration not loaded');
+    });
+  });
+
+  describe('isRuleEnabled()', () => {
+    beforeEach(async () => {
+      await configManager.load();
+    });
+
+    it('should return true for enabled rules', () => {
+      expect(configManager.isRuleEnabled('universal-naming')).toBe(true);
+      expect(configManager.isRuleEnabled('universal-memory_safety')).toBe(true);
+    });
+
+    it('should return true for warning rules', async () => {
+      const config: Configuration = {
+        c_standards: {
+          version: '1.0.0',
+          categories: ['systems'],
+          c_standard: 'c11',
+          universal_rules: {
+            naming: 'warning',
+            memory_safety: 'enabled',
+            error_handling: 'enabled',
+            documentation: 'enabled',
+            header_guards: 'enabled',
+            const_correctness: 'enabled'
+          },
+          category_overrides: {},
+          static_analysis: { clang_tidy: false, cppcheck: false, valgrind: false },
+          custom_rules: { enabled: false, path: '' }
+        }
+      };
+
+      await fs.writeFile(
+        path.join(tempDir, '.augment/c-standards.json'),
+        JSON.stringify(config)
+      );
+
+      await configManager.load();
+      expect(configManager.isRuleEnabled('universal-naming')).toBe(true);
+    });
+  });
+
+  describe('getRuleSeverity()', () => {
+    beforeEach(async () => {
+      await configManager.load();
+    });
+
+    it('should return ERROR for enabled rules', () => {
+      expect(configManager.getRuleSeverity('universal-naming')).toBe('ERROR');
+    });
+
+    it('should return WARNING for warning rules', async () => {
+      const config: Configuration = {
+        c_standards: {
+          version: '1.0.0',
+          categories: ['systems'],
+          c_standard: 'c11',
+          universal_rules: {
+            naming: 'warning',
+            memory_safety: 'enabled',
+            error_handling: 'enabled',
+            documentation: 'enabled',
+            header_guards: 'enabled',
+            const_correctness: 'enabled'
+          },
+          category_overrides: {},
+          static_analysis: { clang_tidy: false, cppcheck: false, valgrind: false },
+          custom_rules: { enabled: false, path: '' }
+        }
+      };
+
+      await fs.writeFile(
+        path.join(tempDir, '.augment/c-standards.json'),
+        JSON.stringify(config)
+      );
+
+      await configManager.load();
+      expect(configManager.getRuleSeverity('universal-naming')).toBe('WARNING');
+    });
+  });
+
+  describe('reload()', () => {
+    it('should reload configuration', async () => {
+      await configManager.load();
+      const config1 = configManager.getConfiguration();
+
+      // Modify configuration file
+      const newConfig: Configuration = {
+        c_standards: {
+          ...config1.c_standards,
+          categories: ['networking']
+        }
+      };
+
+      await fs.writeFile(
+        path.join(tempDir, '.augment/c-standards.json'),
+        JSON.stringify(newConfig)
+      );
+
+      await configManager.reload();
+      const config2 = configManager.getConfiguration();
+
+      expect(config2.c_standards.categories).toEqual(['networking']);
+    });
+
+    it('should notify watchers on reload', async () => {
+      await configManager.load();
+
+      let notified = false;
+      configManager.watch((config) => {
+        notified = true;
+      });
+
+      await configManager.reload();
+      expect(notified).toBe(true);
+    });
+  });
+
+  describe('watch()', () => {
+    it('should register watcher callback', async () => {
+      await configManager.load();
+
+      const callback = jest.fn();
+      configManager.watch(callback);
+
+      await configManager.reload();
+      expect(callback).toHaveBeenCalled();
+    });
+  });
+
+  describe('dispose()', () => {
+    it('should clean up resources', async () => {
+      await configManager.load();
+      configManager.watch(() => {});
+
+      configManager.dispose();
+
+      // Should not throw
+      expect(() => configManager.dispose()).not.toThrow();
+    });
+  });
+});
+

package/augment-extensions/coding-standards/c/tests/unit/conflict-detector.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Unit Tests for ConflictDetector
+ * Tests rule conflict detection and resolution suggestions
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ConflictDetector } from '../../src/conflict-detector';
+import { RuleRegistry } from '../../src/registry';
+import { Rule } from '../../src/types';
+
+describe('ConflictDetector', () => {
+  let tempDir: string;
+  let rulesPath: string;
+  let registry: RuleRegistry;
+  let detector: ConflictDetector;
+
+  beforeEach(async () => {
+    // Create temporary directories
+    tempDir = path.join(__dirname, '../fixtures/temp-conflicts');
+    rulesPath = path.join(tempDir, 'rules');
+    
+    await fs.mkdir(path.join(rulesPath, 'universal'), { recursive: true });
+    await fs.mkdir(path.join(rulesPath, 'categories'), { recursive: true });
+    
+    // Create sample rules with potential conflicts
+    await createConflictingRules();
+    
+    // Initialize components
+    registry = new RuleRegistry(rulesPath);
+    await registry.loadRules();
+    
+    detector = new ConflictDetector(registry);
+  });
+
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+
+  async function createConflictingRules() {
+    // Rule 1: Requires dynamic allocation
+    const rule1 = `# Rule: Dynamic Memory Required
+
+## Metadata
+- **ID**: systems-dynamic-memory
+- **Category**: systems
+- **Severity**: ERROR
+
+## Description
+Use dynamic memory allocation for flexible data structures.
+
+## Conflicts
+- embedded-no-dynamic-memory
+`;
+
+    await fs.writeFile(path.join(rulesPath, 'categories/systems-dynamic.md'), rule1);
+
+    // Rule 2: Prohibits dynamic allocation
+    const rule2 = `# Rule: No Dynamic Memory
+
+## Metadata
+- **ID**: embedded-no-dynamic-memory
+- **Category**: embedded
+- **Severity**: ERROR
+
+## Description
+Avoid dynamic memory allocation in embedded systems.
+
+## Conflicts
+- systems-dynamic-memory
+`;
+
+    await fs.writeFile(path.join(rulesPath, 'categories/embedded-no-dynamic.md'), rule2);
+
+    // Rule 3: Compatible rule
+    const rule3 = `# 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'), rule3);
+  }
+
+  describe('detectConflicts()', () => {
+    it('should detect conflicting rules', async () => {
+      const conflicts = await detector.detectConflicts();
+      
+      expect(conflicts.length).toBeGreaterThan(0);
+    });
+
+    it('should identify specific conflicting rule pairs', async () => {
+      const conflicts = await detector.detectConflicts();
+      
+      const hasConflict = conflicts.some(c => 
+        (c.rule1.id === 'systems-dynamic-memory' && c.rule2.id === 'embedded-no-dynamic-memory') ||
+        (c.rule1.id === 'embedded-no-dynamic-memory' && c.rule2.id === 'systems-dynamic-memory')
+      );
+      
+      expect(hasConflict).toBe(true);
+    });
+
+    it('should not report false positives', async () => {
+      const conflicts = await detector.detectConflicts();
+      
+      const falsePositive = conflicts.some(c => 
+        c.rule1.id === 'universal-naming' || c.rule2.id === 'universal-naming'
+      );
+      
+      expect(falsePositive).toBe(false);
+    });
+
+    it('should include conflict descriptions', async () => {
+      const conflicts = await detector.detectConflicts();
+      
+      if (conflicts.length > 0) {
+        expect(conflicts[0].description).toBeDefined();
+        expect(conflicts[0].description.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('detectConflictsForRules()', () => {
+    it('should detect conflicts for specific rule set', async () => {
+      const ruleIds = ['systems-dynamic-memory', 'embedded-no-dynamic-memory'];
+      
+      const conflicts = await detector.detectConflictsForRules(ruleIds);
+      
+      expect(conflicts.length).toBeGreaterThan(0);
+    });
+
+    it('should return empty array for non-conflicting rules', async () => {
+      const ruleIds = ['universal-naming'];
+      
+      const conflicts = await detector.detectConflictsForRules(ruleIds);
+      
+      expect(conflicts.length).toBe(0);
+    });
+  });
+
+  describe('suggestResolution()', () => {
+    it('should suggest resolution for conflicts', async () => {
+      const conflicts = await detector.detectConflicts();
+      
+      if (conflicts.length > 0) {
+        const suggestions = detector.suggestResolution(conflicts[0]);
+        
+        expect(suggestions).toBeDefined();
+        expect(Array.isArray(suggestions)).toBe(true);
+        expect(suggestions.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should suggest disabling one rule', async () => {
+      const conflicts = await detector.detectConflicts();
+      
+      if (conflicts.length > 0) {
+        const suggestions = detector.suggestResolution(conflicts[0]);
+        
+        const hasDisableSuggestion = suggestions.some(s => 
+          s.type === 'disable' && (s.ruleId === conflicts[0].rule1.id || s.ruleId === conflicts[0].rule2.id)
+        );
+        
+        expect(hasDisableSuggestion).toBe(true);
+      }
+    });
+
+    it('should suggest category-based resolution', async () => {
+      const conflicts = await detector.detectConflicts();
+      
+      if (conflicts.length > 0) {
+        const suggestions = detector.suggestResolution(conflicts[0]);
+        
+        const hasCategorySuggestion = suggestions.some(s => s.type === 'category');
+        
+        expect(hasCategorySuggestion).toBe(true);
+      }
+    });
+  });
+
+  describe('analyzeConflictSeverity()', () => {
+    it('should analyze conflict severity', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      if (conflicts.length > 0) {
+        const severity = detector.analyzeConflictSeverity(conflicts[0]);
+
+        expect(severity).toBeDefined();
+        expect(['HIGH', 'MEDIUM', 'LOW']).toContain(severity);
+      }
+    });
+
+    it('should rate ERROR-ERROR conflicts as HIGH', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      const errorConflict = conflicts.find(c =>
+        c.rule1.severity === 'ERROR' && c.rule2.severity === 'ERROR'
+      );
+
+      if (errorConflict) {
+        const severity = detector.analyzeConflictSeverity(errorConflict);
+        expect(severity).toBe('HIGH');
+      }
+    });
+  });
+
+  describe('generateConflictReport()', () => {
+    it('should generate text report', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      const report = detector.generateConflictReport(conflicts, { format: 'text' });
+
+      expect(report).toBeDefined();
+      expect(typeof report).toBe('string');
+      expect(report.length).toBeGreaterThan(0);
+    });
+
+    it('should generate JSON report', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      const report = detector.generateConflictReport(conflicts, { format: 'json' });
+
+      expect(report).toBeDefined();
+      expect(() => JSON.parse(report)).not.toThrow();
+    });
+
+    it('should include resolution suggestions in report', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      const report = detector.generateConflictReport(conflicts, {
+        format: 'json',
+        includeSuggestions: true
+      });
+
+      const parsed = JSON.parse(report);
+      if (parsed.conflicts && parsed.conflicts.length > 0) {
+        expect(parsed.conflicts[0].suggestions).toBeDefined();
+      }
+    });
+  });
+
+  describe('isConflictResolved()', () => {
+    it('should check if conflict is resolved', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      if (conflicts.length > 0) {
+        const isResolved = detector.isConflictResolved(conflicts[0]);
+        expect(typeof isResolved).toBe('boolean');
+      }
+    });
+
+    it('should return true when one rule is disabled', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      if (conflicts.length > 0) {
+        registry.setRuleEnabled(conflicts[0].rule1.id, false);
+        const isResolved = detector.isConflictResolved(conflicts[0]);
+        expect(isResolved).toBe(true);
+      }
+    });
+  });
+
+  describe('getConflictsByCategory()', () => {
+    it('should group conflicts by category', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      const grouped = detector.getConflictsByCategory(conflicts);
+
+      expect(grouped).toBeDefined();
+      expect(typeof grouped).toBe('object');
+    });
+
+    it('should include all relevant categories', async () => {
+      const conflicts = await detector.detectConflicts();
+
+      const grouped = detector.getConflictsByCategory(conflicts);
+
+      if (conflicts.length > 0) {
+        const categories = Object.keys(grouped);
+        expect(categories.length).toBeGreaterThan(0);
+      }
+    });
+  });
+});
+