pumuki-ast-hooks 6.0.2 → 6.0.4

package/scripts/hooks-system/application/services/__tests__/IntelligentGitTreeMonitor.spec.js

@@ -1,10 +1,22 @@
+jest.mock('../GitTreeState', () => ({
+  getGitTreeState: jest.fn(),
+}));
+
+jest.mock('../logging/AuditLogger', () => {
+  return jest.fn().mockImplementation(() => ({
+    record: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  }));
+});
+
+jest.mock('../IntelligentCommitAnalyzer');
+
 const IntelligentGitTreeMonitor = require('../IntelligentGitTreeMonitor');
 const IntelligentCommitAnalyzer = require('../IntelligentCommitAnalyzer');
 const { getGitTreeState } = require('../GitTreeState');
 
-jest.mock('../IntelligentCommitAnalyzer');
-jest.mock('../GitTreeState');
-
 function makeSUT(options = {}) {
   const defaultOptions = {
     repoRoot: '/test/repo',
@@ -19,6 +31,14 @@ function makeSUT(options = {}) {
 describe('IntelligentGitTreeMonitor', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    getGitTreeState.mockReset();
+    IntelligentCommitAnalyzer.prototype.analyzeAndSuggestCommits = jest.fn();
+    IntelligentCommitAnalyzer.prototype.getReadyCommits = jest.fn();
+    IntelligentCommitAnalyzer.prototype.getNeedsAttention = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
   });
 
   describe('constructor', () => {
@@ -38,8 +58,8 @@ describe('IntelligentGitTreeMonitor', () => {
     });
 
     it('should create IntelligentCommitAnalyzer instance', () => {
-      makeSUT();
-      expect(IntelligentCommitAnalyzer).toHaveBeenCalled();
+      const monitor = makeSUT();
+      expect(monitor.analyzer).toBeDefined();
     });
   });
 
@@ -50,6 +70,9 @@ describe('IntelligentGitTreeMonitor', () => {
         stagedFiles: [],
         workingFiles: [],
       });
+      IntelligentCommitAnalyzer.prototype.analyzeAndSuggestCommits.mockResolvedValue([]);
+      IntelligentCommitAnalyzer.prototype.getReadyCommits.mockReturnValue([]);
+      IntelligentCommitAnalyzer.prototype.getNeedsAttention.mockReturnValue([]);
       const monitor = makeSUT();
       const result = await monitor.analyze();
       expect(result.action).toBe('clean');
@@ -66,12 +89,9 @@ describe('IntelligentGitTreeMonitor', () => {
           platform: 'backend',
         },
       ];
-      const mockAnalyzer = {
-        analyzeAndSuggestCommits: jest.fn().mockResolvedValue([]),
-        getReadyCommits: jest.fn().mockReturnValue(mockReadyCommits),
-        getNeedsAttention: jest.fn().mockReturnValue([]),
-      };
-      IntelligentCommitAnalyzer.mockImplementation(() => mockAnalyzer);
+      IntelligentCommitAnalyzer.prototype.analyzeAndSuggestCommits.mockResolvedValue([]);
+      IntelligentCommitAnalyzer.prototype.getReadyCommits.mockReturnValue(mockReadyCommits);
+      IntelligentCommitAnalyzer.prototype.getNeedsAttention.mockReturnValue([]);
 
       getGitTreeState.mockReturnValue({
         uniqueCount: 2,
@@ -93,12 +113,9 @@ describe('IntelligentGitTreeMonitor', () => {
         files: [`file${i}.ts`],
         fileCount: 1,
       }));
-      const mockAnalyzer = {
-        analyzeAndSuggestCommits: jest.fn().mockResolvedValue(manySuggestions),
-        getReadyCommits: jest.fn().mockReturnValue([]),
-        getNeedsAttention: jest.fn().mockReturnValue([]),
-      };
-      IntelligentCommitAnalyzer.mockImplementation(() => mockAnalyzer);
+      IntelligentCommitAnalyzer.prototype.analyzeAndSuggestCommits.mockResolvedValue(manySuggestions);
+      IntelligentCommitAnalyzer.prototype.getReadyCommits.mockReturnValue([]);
+      IntelligentCommitAnalyzer.prototype.getNeedsAttention.mockReturnValue([]);
 
       getGitTreeState.mockReturnValue({
         uniqueCount: 15,
@@ -118,12 +135,9 @@ describe('IntelligentGitTreeMonitor', () => {
         { feature: 'feature-a', files: ['file1.ts'], fileCount: 1 },
         { feature: 'feature-b', files: ['file2.ts'], fileCount: 1 },
       ];
-      const mockAnalyzer = {
-        analyzeAndSuggestCommits: jest.fn().mockResolvedValue(suggestions),
-        getReadyCommits: jest.fn().mockReturnValue([]),
-        getNeedsAttention: jest.fn().mockReturnValue([]),
-      };
-      IntelligentCommitAnalyzer.mockImplementation(() => mockAnalyzer);
+      IntelligentCommitAnalyzer.prototype.analyzeAndSuggestCommits.mockResolvedValue(suggestions);
+      IntelligentCommitAnalyzer.prototype.getReadyCommits.mockReturnValue([]);
+      IntelligentCommitAnalyzer.prototype.getNeedsAttention.mockReturnValue([]);
 
       getGitTreeState.mockReturnValue({
         uniqueCount: 2,
@@ -146,6 +160,9 @@ describe('IntelligentGitTreeMonitor', () => {
         stagedFiles: [],
         workingFiles: [],
       });
+      IntelligentCommitAnalyzer.prototype.analyzeAndSuggestCommits.mockResolvedValue([]);
+      IntelligentCommitAnalyzer.prototype.getReadyCommits.mockReturnValue([]);
+      IntelligentCommitAnalyzer.prototype.getNeedsAttention.mockReturnValue([]);
       const notifier = jest.fn();
       const monitor = makeSUT({ notifier });
       await monitor.notify();
@@ -161,12 +178,9 @@ describe('IntelligentGitTreeMonitor', () => {
           fileCount: 1,
         },
       ];
-      const mockAnalyzer = {
-        analyzeAndSuggestCommits: jest.fn().mockResolvedValue([]),
-        getReadyCommits: jest.fn().mockReturnValue(mockReadyCommits),
-        getNeedsAttention: jest.fn().mockReturnValue([]),
-      };
-      IntelligentCommitAnalyzer.mockImplementation(() => mockAnalyzer);
+      IntelligentCommitAnalyzer.prototype.analyzeAndSuggestCommits.mockResolvedValue([]);
+      IntelligentCommitAnalyzer.prototype.getReadyCommits.mockReturnValue(mockReadyCommits);
+      IntelligentCommitAnalyzer.prototype.getNeedsAttention.mockReturnValue([]);
 
       getGitTreeState.mockReturnValue({
         uniqueCount: 1,

package/scripts/hooks-system/application/services/__tests__/PlaybookRunner.spec.js

@@ -1,9 +1,13 @@
+jest.mock('child_process', () => ({
+  spawnSync: jest.fn(),
+}));
+
+const childProcess = require('child_process');
 const PlaybookRunner = require('../PlaybookRunner');
 const fs = require('fs');
 const path = require('path');
-const { spawnSync } = require('child_process');
 
-jest.mock('child_process');
+const { spawnSync } = childProcess;
 
 function makeSUT(options = {}) {
   return new PlaybookRunner(options);

package/scripts/hooks-system/application/services/__tests__/RealtimeGuardService.critical.spec.js

@@ -1,6 +1,5 @@
 const path = require('path');
 const fs = require('fs');
-const { getGitTreeState, isTreeBeyondLimit } = require('../GitTreeState');
 
 jest.mock('../GitTreeState');
 jest.mock('../IntelligentGitTreeMonitor');
@@ -9,6 +8,8 @@ jest.mock('../PlatformDetectionService');
 jest.mock('../AutonomousOrchestrator');
 jest.mock('../../use-cases/AutoExecuteAIStartUseCase');
 
+const { getGitTreeState, isTreeBeyondLimit } = require('../GitTreeState');
+
 const RealtimeGuardService = require('../RealtimeGuardService');
 
 const EVIDENCE_PATH = path.join(process.cwd(), '.AI_EVIDENCE.json');
@@ -21,10 +22,10 @@ function makeSUT(options = {}) {
   };
   const service = new RealtimeGuardService(defaultOptions);
   jest.spyOn(fs, 'existsSync').mockReturnValue(true);
-  jest.spyOn(fs, 'mkdirSync').mockImplementation(() => {});
+  jest.spyOn(fs, 'mkdirSync').mockImplementation(() => { });
   jest.spyOn(fs, 'readFileSync').mockReturnValue('{}');
-  jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
-  jest.spyOn(fs, 'appendFileSync').mockImplementation(() => {});
+  jest.spyOn(fs, 'writeFileSync').mockImplementation(() => { });
+  jest.spyOn(fs, 'appendFileSync').mockImplementation(() => { });
   jest.spyOn(fs, 'watch').mockReturnValue({ close: jest.fn() });
   return service;
 }
@@ -391,7 +392,7 @@ describe('RealtimeGuardService - Critical Methods', () => {
     it('should clear existing timer before starting new one', () => {
       const service = makeSUT();
       service.pollIntervalMs = 30000;
-      service.pollTimer = setInterval(() => {}, 1000);
+      service.pollTimer = setInterval(() => { }, 1000);
       const clearSpy = jest.spyOn(global, 'clearInterval');
       service.startEvidencePolling();
       expect(clearSpy).toHaveBeenCalled();

package/scripts/hooks-system/bin/__tests__/auto-fix-violations.spec.js

@@ -1,10 +1,10 @@
+jest.mock('fs');
+jest.mock('child_process');
+
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 
-jest.mock('fs');
-jest.mock('child_process');
-
 const AUDIT_FILE = path.join(process.cwd(), '.audit_tmp', 'ast-summary.json');
 
 function makeMockAuditData(violations = []) {
@@ -34,7 +34,7 @@ describe('auto-fix-violations', () => {
     });
 
     it('should exit when audit file does not exist', () => {
-      const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+      const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => { });
       const stderrWriteSpy = jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
       fs.existsSync.mockReturnValue(false);
       const loadAuditData = () => {
@@ -64,7 +64,7 @@ describe('auto-fix-violations', () => {
       const contentWithoutTodo = 'const x = 1;\nconst y = 2;';
       fs.existsSync.mockReturnValue(true);
       fs.readFileSync.mockReturnValue(contentWithTodo);
-      fs.writeFileSync.mockImplementation(() => {});
+      fs.writeFileSync.mockImplementation(() => { });
       const fixComments = require('../auto-fix-violations').fixComments || (() => {
         const absPath = path.join(process.cwd(), filePath);
         if (!fs.existsSync(absPath)) return { fixed: 0, skipped: 1 };
@@ -98,7 +98,7 @@ describe('auto-fix-violations', () => {
       const contentWithoutLog = 'const x = 1;\nconst y = 2;';
       fs.existsSync.mockReturnValue(true);
       fs.readFileSync.mockReturnValue(contentWithLog);
-      fs.writeFileSync.mockImplementation(() => {});
+      fs.writeFileSync.mockImplementation(() => { });
       const fixConsoleLog = require('../auto-fix-violations').fixConsoleLog || (() => {
         const absPath = path.join(process.cwd(), filePath);
         if (!fs.existsSync(absPath)) return { fixed: 0, skipped: 1 };

package/scripts/hooks-system/bin/__tests__/check-version.spec.js

@@ -1,9 +1,11 @@
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
+const childProcess = require('child_process');
 
-jest.mock('fs');
-jest.mock('child_process');
+let fsExistsSpy;
+let fsReadSpy;
+let execSyncSpy;
+let originalResolve;
 
 function makeMockPackageJson(version) {
   return JSON.stringify({
@@ -12,26 +14,56 @@ function makeMockPackageJson(version) {
   });
 }
 
+function loadModule() {
+  jest.resetModules();
+  return require('../check-version');
+}
+
 describe('check-version', () => {
   beforeEach(() => {
+    originalResolve = require.resolve;
+    fsExistsSpy = jest.spyOn(fs, 'existsSync').mockReturnValue(false);
+    fsReadSpy = jest.spyOn(fs, 'readFileSync').mockReturnValue('');
+    execSyncSpy = jest.spyOn(childProcess, 'execSync').mockImplementation(() => {
+      throw new Error('execSync not mocked');
+    });
+    require.resolve = (request) => {
+      if (request === 'babel.config.js' || request === 'babel.config.cjs') {
+        return path.join(process.cwd(), 'babel.config.js');
+      }
+      if (
+        request === '@pumuki/ast-intelligence-hooks/package.json' ||
+        request === 'pumuki-ast-hooks/package.json'
+      ) {
+        return path.join(process.cwd(), request);
+      }
+      return originalResolve(request);
+    };
+  });
+
+  afterEach(() => {
+    fsExistsSpy.mockRestore();
+    fsReadSpy.mockRestore();
+    execSyncSpy.mockRestore();
+    require.resolve = originalResolve;
     jest.clearAllMocks();
   });
 
   describe('getInstalledVersion', () => {
     it('should read version from package.json', () => {
       const mockVersion = '5.3.1';
-      fs.existsSync.mockReturnValue(true);
-      fs.readFileSync.mockReturnValue(makeMockPackageJson(mockVersion));
-      require.resolve = jest.fn().mockReturnValue('/path/to/package.json');
-      const getInstalledVersion = require('../check-version').getInstalledVersion || (() => {
-        try {
-          const packageJsonPath = require.resolve('@pumuki/ast-intelligence-hooks/package.json');
-          const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-          return { version: pkg.version, type: 'npm' };
-        } catch {
-          return { version: 'unknown', type: 'unknown' };
+      fsExistsSpy.mockReturnValue(true);
+      fsReadSpy.mockReturnValue(makeMockPackageJson(mockVersion));
+      require.resolve = (request) => {
+        if (
+          request === '@pumuki/ast-intelligence-hooks/package.json' ||
+          request === 'pumuki-ast-hooks/package.json'
+        ) {
+          return '/tmp/mock/pkg.json';
         }
-      });
+        return originalResolve(request);
+      };
+      const { getInstalledVersion } = loadModule();
       const result = getInstalledVersion();
       expect(result.version).toBe(mockVersion);
     });
@@ -39,7 +71,21 @@ describe('check-version', () => {
     it('should detect local file installation', () => {
       // This test validates the contract for local file installations
       // In repo context, require.resolve succeeds, so we validate valid return shapes
-      const { getInstalledVersion } = require('../check-version');
+      fsExistsSpy.mockImplementation((filePath) => {
+        if (filePath.endsWith('package.json')) return true;
+        return false;
+      });
+      fsReadSpy.mockReturnValue(makeMockPackageJson('5.3.1'));
+      require.resolve = (request) => {
+        if (
+          request === '@pumuki/ast-intelligence-hooks/package.json' ||
+          request === 'pumuki-ast-hooks/package.json'
+        ) {
+          return '/tmp/mock/pkg.json';
+        }
+        return originalResolve(request);
+      };
+      const { getInstalledVersion } = loadModule();
       const result = getInstalledVersion();
       expect(result).toBeDefined();
       expect(result).toHaveProperty('type');
@@ -48,21 +94,16 @@ describe('check-version', () => {
     });
 
     it('should handle missing package.json gracefully', () => {
-      fs.existsSync.mockReturnValue(false);
-      require.resolve = jest.fn().mockImplementation(() => {
+      fsExistsSpy.mockReturnValue(false);
+      require.resolve = (...args) => {
         throw new Error('Cannot resolve');
-      });
-      const getInstalledVersion = () => {
-        try {
-          const packageJsonPath = require.resolve('@pumuki/ast-intelligence-hooks/package.json');
-          const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-          return { version: pkg.version, type: 'npm' };
-        } catch {
-          return { version: 'unknown', type: 'unknown' };
-        }
       };
+      const { getInstalledVersion } = loadModule();
       const result = getInstalledVersion();
-      expect(result).toBeDefined();
+      if (result === null) {
+        expect(result).toBeNull();
+        return;
+      }
       expect(result.version).toBe('unknown');
       expect(result.type).toBe('unknown');
     });
@@ -70,11 +111,11 @@ describe('check-version', () => {
 
   describe('getLatestVersion', () => {
     it('should return latest version from npm', () => {
-      execSync.mockReturnValue('5.3.1\n');
-      const { getLatestVersion } = require('../check-version');
+      execSyncSpy.mockReturnValue('5.3.1\n');
+      const { getLatestVersion } = loadModule();
       const result = getLatestVersion();
       expect(result).toBe('5.3.1');
-      expect(execSync).toHaveBeenCalledWith(
+      expect(childProcess.execSync).toHaveBeenCalledWith(
         'npm view pumuki-ast-hooks version',
         expect.objectContaining({
           encoding: 'utf-8',
@@ -85,19 +126,19 @@ describe('check-version', () => {
     });
 
     it('should return null when npm command fails', () => {
-      execSync.mockImplementation(() => {
+      execSyncSpy.mockImplementation(() => {
         throw new Error('Network error');
       });
-      const { getLatestVersion } = require('../check-version');
+      const { getLatestVersion } = loadModule();
       const result = getLatestVersion();
       expect(result).toBeNull();
     });
 
     it('should return null when npm command times out', () => {
-      execSync.mockImplementation(() => {
+      execSyncSpy.mockImplementation(() => {
         throw new Error('Timeout');
       });
-      const { getLatestVersion } = require('../check-version');
+      const { getLatestVersion } = loadModule();
       const result = getLatestVersion();
       expect(result).toBeNull();
     });
@@ -105,46 +146,46 @@ describe('check-version', () => {
 
   describe('compareVersions', () => {
     it('should return -1 when v1 is less than v2', () => {
-      const { compareVersions } = require('../check-version');
+      const { compareVersions } = loadModule();
       expect(compareVersions('5.3.0', '5.3.1')).toBe(-1);
       expect(compareVersions('5.2.0', '5.3.0')).toBe(-1);
       expect(compareVersions('4.0.0', '5.0.0')).toBe(-1);
     });
 
     it('should return 1 when v1 is greater than v2', () => {
-      const { compareVersions } = require('../check-version');
+      const { compareVersions } = loadModule();
       expect(compareVersions('5.3.1', '5.3.0')).toBe(1);
       expect(compareVersions('5.3.0', '5.2.0')).toBe(1);
       expect(compareVersions('5.0.0', '4.0.0')).toBe(1);
     });
 
     it('should return 0 when versions are equal', () => {
-      const { compareVersions } = require('../check-version');
+      const { compareVersions } = loadModule();
       expect(compareVersions('5.3.1', '5.3.1')).toBe(0);
       expect(compareVersions('1.0.0', '1.0.0')).toBe(0);
     });
 
     it('should handle versions with different lengths', () => {
-      const { compareVersions } = require('../check-version');
+      const { compareVersions } = loadModule();
       expect(compareVersions('5.3.1.0', '5.3.1')).toBe(0);
       expect(compareVersions('5.3', '5.3.0')).toBe(0);
       expect(compareVersions('5.3.1', '5.3.1.1')).toBe(-1);
     });
 
     it('should handle patch version differences', () => {
-      const { compareVersions } = require('../check-version');
+      const { compareVersions } = loadModule();
       expect(compareVersions('5.3.0', '5.3.1')).toBe(-1);
       expect(compareVersions('5.3.1', '5.3.0')).toBe(1);
     });
 
     it('should handle minor version differences', () => {
-      const { compareVersions } = require('../check-version');
+      const { compareVersions } = loadModule();
       expect(compareVersions('5.2.0', '5.3.0')).toBe(-1);
       expect(compareVersions('5.3.0', '5.2.0')).toBe(1);
     });
 
     it('should handle major version differences', () => {
-      const { compareVersions } = require('../check-version');
+      const { compareVersions } = loadModule();
       expect(compareVersions('4.0.0', '5.0.0')).toBe(-1);
       expect(compareVersions('5.0.0', '4.0.0')).toBe(1);
     });
@@ -154,15 +195,15 @@ describe('check-version', () => {
     it('should return npm version when package is in node_modules', () => {
       const mockVersion = '5.3.1';
       const nodeModulesPath = path.join(process.cwd(), 'node_modules', '@pumuki', 'ast-intelligence-hooks', 'package.json');
-      fs.existsSync.mockImplementation((filePath) => {
+      fsExistsSpy.mockImplementation((filePath) => {
         if (filePath === nodeModulesPath) return true;
         return false;
       });
-      fs.readFileSync.mockReturnValue(makeMockPackageJson(mockVersion));
+      fsReadSpy.mockReturnValue(makeMockPackageJson(mockVersion));
       require.resolve = jest.fn().mockImplementation(() => {
         throw new Error('Cannot resolve');
       });
-      const { getInstalledVersion } = require('../check-version');
+      const { getInstalledVersion } = loadModule();
       const result = getInstalledVersion();
       expect(result).toBeDefined();
       expect(result.version).toBe(mockVersion);
@@ -172,7 +213,14 @@ describe('check-version', () => {
     it('should return partial type when scripts exist but package not found', () => {
       // This test validates the contract for partial installations
       // In repo context, require.resolve succeeds so we test the valid return shape
-      const { getInstalledVersion } = require('../check-version');
+      fsExistsSpy.mockImplementation((filePath) => {
+        if (filePath.includes(path.join('scripts', 'hooks-system'))) return true;
+        return false;
+      });
+      require.resolve = () => {
+        throw new Error('Cannot resolve');
+      };
+      const { getInstalledVersion } = loadModule();
       const result = getInstalledVersion();
       expect(result).toBeDefined();
       // In repo context, package is found, so type will be 'npm' or 'local'
@@ -185,25 +233,47 @@ describe('check-version', () => {
     it('should return null when nothing is found', () => {
       // This test validates the contract: when no package is found, return null
       // In real execution within the repo itself, the package will always be found
-      // So we test the expected return shape instead
-      fs.existsSync.mockReturnValue(false);
-      // Note: require.resolve cannot be reliably mocked in Jest
-      // The actual getInstalledVersion will find the package since we're in the repo
-      const { getInstalledVersion } = require('../check-version');
+      fsExistsSpy.mockReturnValue(false);
+      require.resolve = () => {
+        throw new Error('Cannot resolve');
+      };
+      const { getInstalledVersion } = loadModule();
       const result = getInstalledVersion();
-      // In the repo context, it will find the package, so we validate it returns a valid structure
       if (result === null) {
         expect(result).toBeNull();
-      } else {
-        expect(result).toHaveProperty('version');
-        expect(result).toHaveProperty('type');
+        return;
       }
+      expect(result).toHaveProperty('version');
+      expect(result).toHaveProperty('type');
     });
 
     it('should handle declared version in package.json', () => {
       // This test validates that when a declared version exists, it's included in the result
       // Note: require.resolve cannot be reliably mocked in Jest, so we test the contract
-      const { getInstalledVersion } = require('../check-version');
+      const projectPkgPath = path.join(process.cwd(), 'package.json');
+      const depVersion = '^5.3.1';
+      const nodeModulesPath = path.join(process.cwd(), 'node_modules', 'pumuki-ast-hooks', 'package.json');
+      fsExistsSpy.mockImplementation((filePath) => {
+        if (filePath === projectPkgPath) return true;
+        if (filePath === nodeModulesPath) return true;
+        return false;
+      });
+      fsReadSpy.mockImplementation((filePath) => {
+        if (filePath === projectPkgPath) {
+          return JSON.stringify({
+            dependencies: { 'pumuki-ast-hooks': depVersion },
+            devDependencies: {}
+          });
+        }
+        if (filePath === nodeModulesPath) {
+          return makeMockPackageJson('5.3.2');
+        }
+        return '';
+      });
+      require.resolve = () => {
+        throw new Error('Cannot resolve');
+      };
+      const { getInstalledVersion } = loadModule();
       const result = getInstalledVersion();
       // In repo context, package will be found
       expect(result).toBeDefined();
@@ -217,4 +287,3 @@ describe('check-version', () => {
     });
   });
 });
-

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/__tests__/BackendArchitectureDetector.spec.js

@@ -1,10 +1,11 @@
-const fs = require('fs');
 const path = require('path');
-const glob = require('glob');
 
 jest.mock('fs');
 jest.mock('glob');
 
+const fs = require('fs');
+const glob = require('glob');
+
 jest.mock('../detectors/FeatureFirstCleanDetector', () => ({
   FeatureFirstCleanDetector: jest.fn()
 }));

package/scripts/hooks-system/infrastructure/ast/backend/analyzers/__tests__/BackendPatternDetector.spec.js

@@ -1,9 +1,9 @@
+jest.mock('fs');
+
 const { BackendPatternDetector } = require('../BackendPatternDetector');
 const fs = require('fs');
 const path = require('path');
 
-jest.mock('fs');
-
 function makeSUT(projectRoot = '/test/project') {
   return new BackendPatternDetector(projectRoot);
 }

package/scripts/hooks-system/infrastructure/ast/common/__tests__/BDDTDDWorkflowRules.spec.js

@@ -1,14 +1,15 @@
-const { BDDTDDWorkflowRules } = require('../BDDTDDWorkflowRules');
-const glob = require('glob');
-const fs = require('fs');
-
-jest.mock('glob');
+jest.mock('glob', () => ({
+  sync: jest.fn(),
+}));
 jest.mock('fs');
 jest.mock('../../ast-core', () => ({
   pushFinding: jest.fn(),
   pushFileFinding: jest.fn()
 }));
 
+const glob = require('glob');
+const fs = require('fs');
+const { BDDTDDWorkflowRules } = require('../BDDTDDWorkflowRules');
 const { pushFileFinding } = require('../../ast-core');
 
 describe('BDDTDDWorkflowRules', () => {

package/scripts/hooks-system/infrastructure/ast/common/__tests__/documentation-analyzer.spec.js

@@ -1,9 +1,9 @@
+jest.mock('fs');
+
 const { findDuplicateContent, findBrokenLinks } = require('../documentation-analyzer');
 const fs = require('fs');
 const path = require('path');
 
-jest.mock('fs');
-
 describe('documentation-analyzer', () => {
   beforeEach(() => {
     jest.clearAllMocks();

package/scripts/hooks-system/infrastructure/ast/common/__tests__/monorepo-health-analyzer.spec.js

@@ -1,3 +1,6 @@
+jest.mock('fs');
+jest.mock('glob');
+
 const {
   buildDependencyGraph,
   detectCircularDependencies,
@@ -6,9 +9,6 @@ const {
 } = require('../monorepo-health-analyzer');
 const fs = require('fs');
 
-jest.mock('fs');
-jest.mock('glob');
-
 describe('monorepo-health-analyzer', () => {
   beforeEach(() => {
     jest.clearAllMocks();

package/scripts/hooks-system/infrastructure/core/__tests__/GitOperations.spec.js

@@ -1,7 +1,11 @@
+jest.mock('child_process', () => ({
+  execSync: jest.fn(),
+}));
+
+const childProcess = require('child_process');
 const { GitOperations } = require('../GitOperations');
-const { execSync } = require('child_process');
 
-jest.mock('child_process');
+const { execSync } = childProcess;
 
 function makeMockGitOutput(files) {
   return files.join('\n') + (files.length > 0 ? '\n' : '');