pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/backend/__tests__/clean-architecture-analyzer.spec.js

@@ -0,0 +1,151 @@
+const { analyzeCleanArchitecture } = require('../clean-architecture-analyzer');
+
+function createMockSourceFile(config = {}) {
+  return {
+    getFilePath: () => config.path || '/app/src/domain/entities/user.ts',
+    getFullText: () => config.content || '',
+    getImportDeclarations: () => config.imports || []
+  };
+}
+
+function createMockImport(modulePath) {
+  return {
+    getModuleSpecifierValue: () => modulePath,
+    getStartLineNumber: () => 1
+  };
+}
+
+function createMockPushFinding() {
+  return jest.fn();
+}
+
+describe('clean-architecture-analyzer', () => {
+  describe('analyzeCleanArchitecture', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeCleanArchitecture).toBe('function');
+    });
+
+    it('should not flag domain file with valid imports', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/domain/entities/user.ts',
+        imports: [createMockImport('./value-objects/email')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeCleanArchitecture(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        'backend.clean.domain_dependency_violation',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should detect domain importing from infrastructure', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/domain/entities/user.ts',
+        imports: [createMockImport('../infrastructure/database')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeCleanArchitecture(sf, findings, pushFinding);
+
+      expect(pushFinding).toHaveBeenCalledWith(
+        'backend.clean.domain_dependency_violation',
+        'critical',
+        expect.anything(),
+        expect.anything(),
+        expect.stringContaining('Domain layer'),
+        expect.anything()
+      );
+    });
+
+    it('should detect domain importing NestJS', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/domain/repositories/user.repository.ts',
+        imports: [createMockImport('@nestjs/common')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeCleanArchitecture(sf, findings, pushFinding);
+
+      expect(pushFinding).toHaveBeenCalledWith(
+        'backend.clean.domain_dependency_violation',
+        'critical',
+        expect.anything(),
+        expect.anything(),
+        expect.stringContaining('Domain layer'),
+        expect.anything()
+      );
+    });
+
+    it('should not flag infrastructure file with any imports', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/infrastructure/database/repositories/user.repository.ts',
+        imports: [
+          createMockImport('@nestjs/common'),
+          createMockImport('../../domain/entities/user')
+        ]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeCleanArchitecture(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        'backend.clean.domain_dependency_violation',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should ignore files outside clean architecture layers', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/main.ts',
+        imports: [createMockImport('@nestjs/core')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeCleanArchitecture(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalled();
+    });
+
+    it('should detect domain importing TypeORM', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/domain/entities/order.ts',
+        imports: [createMockImport('typeorm')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeCleanArchitecture(sf, findings, pushFinding);
+
+      expect(pushFinding).toHaveBeenCalledWith(
+        'backend.clean.domain_dependency_violation',
+        'critical',
+        expect.anything(),
+        expect.anything(),
+        expect.stringContaining('Domain layer'),
+        expect.anything()
+      );
+    });
+  });
+
+  describe('exports', () => {
+    it('should export analyzeCleanArchitecture', () => {
+      const mod = require('../clean-architecture-analyzer');
+      expect(mod.analyzeCleanArchitecture).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/backend/__tests__/ddd-analyzer.spec.js

@@ -0,0 +1,124 @@
+const { analyzeDDD } = require('../ddd-analyzer');
+
+function createMockSourceFile(config = {}) {
+  return {
+    getFilePath: () => config.path || '/app/src/domain/entities/user.ts',
+    getFullText: () => config.content || '',
+    getClasses: () => config.classes || [],
+    getInterfaces: () => config.interfaces || [],
+    getImportDeclarations: () => config.imports || []
+  };
+}
+
+function createMockClass(config = {}) {
+  return {
+    getName: () => config.name || 'TestClass',
+    getMethods: () => config.methods || [],
+    getProperties: () => config.properties || [],
+    getDecorators: () => config.decorators || [],
+    getImplements: () => config.implements || []
+  };
+}
+
+function createMockPushFinding() {
+  return jest.fn();
+}
+
+describe('ddd-analyzer', () => {
+  describe('analyzeDDD', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeDDD).toBe('function');
+    });
+
+    it('should not throw for empty source file', () => {
+      const sf = createMockSourceFile();
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      expect(() => analyzeDDD(sf, findings, pushFinding, null)).not.toThrow();
+    });
+
+    it('should analyze repository pattern in domain layer', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/domain/repositories/user.repository.ts',
+        interfaces: [{
+          getName: () => 'IUserRepository',
+          getMethods: () => []
+        }]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeDDD(sf, findings, pushFinding, null);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        expect.stringContaining('ddd.repository'),
+        'critical',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should analyze use cases pattern', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/application/use-cases/create-user.use-case.ts',
+        classes: [createMockClass({ name: 'CreateUserUseCase' })]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeDDD(sf, findings, pushFinding, null);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        expect.stringContaining('ddd.usecase'),
+        'critical',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should analyze DTOs pattern', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/application/dtos/create-user.dto.ts',
+        classes: [createMockClass({ name: 'CreateUserDto' })]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeDDD(sf, findings, pushFinding, null);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        expect.stringContaining('ddd.dto'),
+        'critical',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should ignore non-DDD files', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/main.ts',
+        classes: []
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeDDD(sf, findings, pushFinding, null);
+
+      expect(pushFinding).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('exports', () => {
+    it('should export analyzeDDD', () => {
+      const mod = require('../ddd-analyzer');
+      expect(mod.analyzeDDD).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/backend/__tests__/feature-first-analyzer.spec.js

@@ -0,0 +1,128 @@
+const { analyzeFeatureFirst } = require('../feature-first-analyzer');
+
+function createMockSourceFile(config = {}) {
+  return {
+    getFilePath: () => config.path || '/app/src/features/users/users.service.ts',
+    getFullText: () => config.content || '',
+    getImportDeclarations: () => config.imports || []
+  };
+}
+
+function createMockImport(modulePath) {
+  return {
+    getModuleSpecifierValue: () => modulePath,
+    getStartLineNumber: () => 1
+  };
+}
+
+function createMockPushFinding() {
+  return jest.fn();
+}
+
+describe('feature-first-analyzer', () => {
+  describe('analyzeFeatureFirst', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeFeatureFirst).toBe('function');
+    });
+
+    it('should skip files not in a feature', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/main.ts',
+        imports: []
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeFeatureFirst(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalled();
+    });
+
+    it('should allow imports from core modules', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/features/users/users.service.ts',
+        imports: [createMockImport('../core/database')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeFeatureFirst(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        'backend.feature.cross_feature_import',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should allow imports from common modules', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/features/orders/orders.service.ts',
+        imports: [createMockImport('../common/utils')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeFeatureFirst(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        'backend.feature.cross_feature_import',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should allow imports from shared modules', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/features/products/products.service.ts',
+        imports: [createMockImport('../shared/types')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeFeatureFirst(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        'backend.feature.cross_feature_import',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('should allow same-feature imports', () => {
+      const sf = createMockSourceFile({
+        path: '/app/src/features/users/users.controller.ts',
+        imports: [createMockImport('./users.service')]
+      });
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeFeatureFirst(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        'backend.feature.cross_feature_import',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+  });
+
+  describe('exports', () => {
+    it('should export analyzeFeatureFirst', () => {
+      const mod = require('../feature-first-analyzer');
+      expect(mod.analyzeFeatureFirst).toBeDefined();
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/backend/__tests__/forbidden-literals-analyzer.spec.js

@@ -0,0 +1,95 @@
+const { analyzeForbiddenLiterals } = require('../forbidden-literals-analyzer');
+
+function createMockSourceFile(content, filePath = '/app/service.ts') {
+  const mockLiterals = [];
+  const mockNumericLiterals = [];
+
+  return {
+    getFilePath: () => filePath,
+    getFullText: () => content,
+    getDescendantsOfKind: (kind) => {
+      if (kind === 11) return mockLiterals;
+      if (kind === 9) return mockNumericLiterals;
+      return [];
+    }
+  };
+}
+
+function createMockPushFinding() {
+  return jest.fn();
+}
+
+describe('forbidden-literals-analyzer', () => {
+  describe('analyzeForbiddenLiterals', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeForbiddenLiterals).toBe('function');
+    });
+
+    it('should accept source file, findings array, and pushFinding function', () => {
+      const sf = createMockSourceFile('const x = 1;');
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      expect(() => analyzeForbiddenLiterals(sf, findings, pushFinding)).not.toThrow();
+    });
+
+    it('should not throw for empty source file', () => {
+      const sf = createMockSourceFile('');
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      expect(() => analyzeForbiddenLiterals(sf, findings, pushFinding)).not.toThrow();
+    });
+
+    it('should skip test files', () => {
+      const sf = createMockSourceFile('const status = "active";', '/app/service.spec.ts');
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeForbiddenLiterals(sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalled();
+    });
+
+    it('should handle source files with complex content', () => {
+      const content = `
+        import { Injectable } from '@nestjs/common';
+
+        @Injectable()
+        export class UserService {
+          async getUser(id: string) {
+            return this.repo.findOne(id);
+          }
+        }
+      `;
+      const sf = createMockSourceFile(content);
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      expect(() => analyzeForbiddenLiterals(sf, findings, pushFinding)).not.toThrow();
+    });
+  });
+
+  describe('FORBIDDEN_STRING_LITERALS constant', () => {
+    it('should include type-related forbidden values', () => {
+      const forbiddenModule = require('../forbidden-literals-analyzer');
+      expect(forbiddenModule).toBeDefined();
+    });
+  });
+
+  describe('integration', () => {
+    it('should process multiple source files without error', () => {
+      const files = [
+        createMockSourceFile('const a = 1;'),
+        createMockSourceFile('const b = 2;'),
+        createMockSourceFile('const c = 3;')
+      ];
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      files.forEach(sf => {
+        expect(() => analyzeForbiddenLiterals(sf, findings, pushFinding)).not.toThrow();
+      });
+    });
+  });
+});

package/scripts/hooks-system/infrastructure/ast/backend/__tests__/nestjs-patterns-analyzer.spec.js

@@ -0,0 +1,59 @@
+const { analyzeNestJSPatterns } = require('../nestjs-patterns-analyzer');
+
+function createMockPushFinding() {
+    return jest.fn();
+}
+
+describe('nestjs-patterns-analyzer', () => {
+    describe('analyzeNestJSPatterns', () => {
+        it('should be a function', () => {
+            expect(typeof analyzeNestJSPatterns).toBe('function');
+        });
+
+        it('should skip non-controller files by path', () => {
+            const sf = {
+                getFilePath: () => '/app/src/users/users.service.ts',
+                getFullText: () => '@Controller'
+            };
+            const findings = [];
+            const pushFinding = createMockPushFinding();
+
+            analyzeNestJSPatterns(sf, findings, pushFinding);
+
+            expect(pushFinding).not.toHaveBeenCalled();
+        });
+
+        it('should skip files without @Controller in content', () => {
+            const sf = {
+                getFilePath: () => '/app/src/users/users.controller.ts',
+                getFullText: () => 'class UsersController {}'
+            };
+            const findings = [];
+            const pushFinding = createMockPushFinding();
+
+            analyzeNestJSPatterns(sf, findings, pushFinding);
+
+            expect(pushFinding).not.toHaveBeenCalled();
+        });
+
+        it('should skip non-.ts controller files', () => {
+            const sf = {
+                getFilePath: () => '/app/src/users/users.controller.js',
+                getFullText: () => '@Controller'
+            };
+            const findings = [];
+            const pushFinding = createMockPushFinding();
+
+            analyzeNestJSPatterns(sf, findings, pushFinding);
+
+            expect(pushFinding).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('exports', () => {
+        it('should export analyzeNestJSPatterns', () => {
+            const mod = require('../nestjs-patterns-analyzer');
+            expect(mod.analyzeNestJSPatterns).toBeDefined();
+        });
+    });
+});

package/scripts/hooks-system/infrastructure/ast/backend/__tests__/solid-analyzer.spec.js

@@ -0,0 +1,114 @@
+const {
+  analyzeSRP,
+  analyzeOCP,
+  analyzeLSP,
+  analyzeISP,
+  analyzeDIP
+} = require('../solid-analyzer');
+
+function createMockClass(config = {}) {
+  return {
+    getName: () => config.name || 'TestClass',
+    getMethods: () => config.methods || [],
+    getProperties: () => config.properties || [],
+    getConstructors: () => config.constructors || [],
+    getImplements: () => config.implements || [],
+    getExtends: () => config.extends || null
+  };
+}
+
+function createMockSourceFile(config = {}) {
+  return {
+    getFilePath: () => config.path || '/app/service.ts',
+    getFullText: () => config.content || '',
+    getImportDeclarations: () => config.imports || []
+  };
+}
+
+function createMockPushFinding() {
+  return jest.fn();
+}
+
+describe('solid-analyzer', () => {
+  describe('analyzeSRP', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeSRP).toBe('function');
+    });
+
+    it('should not throw for class with no methods', () => {
+      const cls = createMockClass({ methods: [] });
+      const sf = createMockSourceFile();
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      expect(() => analyzeSRP(cls, sf, findings, pushFinding)).not.toThrow();
+    });
+
+    it('should not flag small cohesive class', () => {
+      const cls = createMockClass({
+        name: 'UserService',
+        methods: [{ getName: () => 'getUser' }],
+        properties: []
+      });
+      const sf = createMockSourceFile();
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      analyzeSRP(cls, sf, findings, pushFinding);
+
+      expect(pushFinding).not.toHaveBeenCalledWith(
+        'solid.srp.violation',
+        'critical',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything()
+      );
+    });
+  });
+
+  describe('analyzeOCP', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeOCP).toBe('function');
+    });
+
+    it('should not throw for empty class', () => {
+      const cls = createMockClass();
+      const sf = createMockSourceFile();
+      const findings = [];
+      const pushFinding = createMockPushFinding();
+
+      expect(() => analyzeOCP(cls, sf, findings, pushFinding)).not.toThrow();
+    });
+  });
+
+  describe('analyzeLSP', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeLSP).toBe('function');
+    });
+  });
+
+  describe('analyzeISP', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeISP).toBe('function');
+    });
+  });
+
+  describe('analyzeDIP', () => {
+    it('should be a function', () => {
+      expect(typeof analyzeDIP).toBe('function');
+    });
+  });
+
+  describe('exports', () => {
+    it('should export all SOLID analyzers', () => {
+      const solidModule = require('../solid-analyzer');
+
+      expect(solidModule.analyzeSRP).toBeDefined();
+      expect(solidModule.analyzeOCP).toBeDefined();
+      expect(solidModule.analyzeLSP).toBeDefined();
+      expect(solidModule.analyzeISP).toBeDefined();
+      expect(solidModule.analyzeDIP).toBeDefined();
+    });
+  });
+});