@boyingliu01/xp-gate 0.8.9 → 0.8.11

package/mock-policy/__tests__/mock-decision-engine.test.ts

@@ -0,0 +1,231 @@
+import { describe, it, expect } from 'vitest';
+import MockDecisionEngine from '../mock-decision-engine';
+import type { ProjectScope, MockPolicyConfig, TestLayer } from '../types';
+
+/**
+ * @test MockDecisionEngine decision logic
+ * @intent Verify all decision paths for unit, integration, and e2e layers
+ * @covers MockDecisionEngine.decide
+ */
+
+const baseScope: ProjectScope = {
+  implementedModules: ['src/utils/helper', 'src/core/service'],
+  unimplementedModules: ['src/feature/pending-module'],
+  externalPackages: ['lodash', 'express', 'axios'],
+  projectBoundary: ['src/**'],
+};
+
+const defaultConfig: MockPolicyConfig = {
+  version: 1,
+  layers: {
+    unit: {
+      mockPolicy: 'lenient',
+      requireRealForImplemented: false,
+      allowExternalMock: true,
+      requirePendingRemoval: false,
+      maxMockDensity: 100,
+    },
+    integration: {
+      mockPolicy: 'strict',
+      requireRealForImplemented: true,
+      allowExternalMock: true,
+      requirePendingRemoval: true,
+      maxMockDensity: 30,
+    },
+    e2e: {
+      mockPolicy: 'strict',
+      requireRealForImplemented: true,
+      allowExternalMock: false,
+      requirePendingRemoval: false,
+      maxMockDensity: 0,
+    },
+  },
+  projectBoundary: ['src/**'],
+  severity: 'warning',
+};
+
+describe('MockDecisionEngine', () => {
+  describe('e2e layer — always return real', () => {
+    it('returns real for any import in e2e', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('lodash', 'e2e');
+      expect(decision.strategy).toBe('real');
+      expect(decision.layer).toBe('e2e');
+      expect(decision.reason).toContain('E2E tests must use real dependencies');
+    });
+
+    it('returns real for internal imports in e2e', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('src/core/service', 'e2e');
+      expect(decision.strategy).toBe('real');
+      expect(decision.reason).toContain('E2E');
+    });
+
+    it('returns real for pending imports in e2e', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('src/feature/pending-module', 'e2e');
+      expect(decision.strategy).toBe('real');
+      expect(decision.reason).toContain('E2E');
+    });
+  });
+
+  describe('unit layer with lenient policy — always mock', () => {
+    it('returns mock for external dependencies', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('lodash', 'unit');
+      expect(decision.strategy).toBe('mock');
+      expect(decision.layer).toBe('unit');
+      expect(decision.reason).toContain('lenient policy');
+    });
+
+    it('returns mock for internal dependencies', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('src/utils/helper', 'unit');
+      expect(decision.strategy).toBe('mock');
+      expect(decision.reason).toContain('lenient policy');
+    });
+
+    it('returns mock for pending dependencies', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('src/feature/pending-module', 'unit');
+      expect(decision.strategy).toBe('mock');
+      expect(decision.reason).toContain('lenient policy');
+    });
+  });
+
+  describe('unit layer with strict policy — applies integration rules', () => {
+    const strictUnitConfig: MockPolicyConfig = {
+      ...defaultConfig,
+      layers: {
+        ...defaultConfig.layers,
+        unit: {
+          mockPolicy: 'strict',
+          requireRealForImplemented: true,
+          allowExternalMock: true,
+          requirePendingRemoval: true,
+          maxMockDensity: 50,
+        },
+      },
+    };
+
+    it('returns real for internal+implemented when requireRealForImplemented is true', () => {
+      const engine = new MockDecisionEngine(baseScope, strictUnitConfig);
+      const decision = engine.decide('src/utils/helper', 'unit');
+      expect(decision.strategy).toBe('real');
+      expect(decision.reason).toContain('real implementation');
+    });
+
+    it('returns mock for internal unimplemented when not matched as implemented', () => {
+      const engine = new MockDecisionEngine(baseScope, strictUnitConfig);
+      const decision = engine.decide('src/utils/unknown-module', 'unit');
+      // Falls through to default: unknown scope → mock for safety
+      expect(decision.strategy).toBe('mock');
+    });
+  });
+
+  describe('integration layer', () => {
+    it('returns real for internal+implemented when requireRealForImplemented is true', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('src/utils/helper', 'integration');
+      expect(decision.strategy).toBe('real');
+      expect(decision.layer).toBe('integration');
+      expect(decision.reason).toContain('real implementation');
+    });
+
+    it('returns real for internal+implemented (src/core/service)', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('src/core/service', 'integration');
+      expect(decision.strategy).toBe('real');
+      expect(decision.reason).toContain('real implementation');
+    });
+
+    it('returns mock for external dependencies when allowExternalMock is true', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('lodash', 'integration');
+      expect(decision.strategy).toBe('mock');
+      expect(decision.reason).toContain('External dependency');
+    });
+
+    it('returns mock for axios (external)', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('axios', 'integration');
+      expect(decision.strategy).toBe('mock');
+      expect(decision.reason).toContain('External dependency');
+    });
+
+    it('returns mock for express (external)', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('express', 'integration');
+      expect(decision.strategy).toBe('mock');
+    });
+
+    it('returns mock with pendingRemoval for pending dependencies when requirePendingRemoval is true', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('src/feature/pending-module', 'integration');
+      expect(decision.strategy).toBe('mock');
+      expect(decision.pendingRemoval).toBeDefined();
+      expect(decision.pendingRemoval!.ticket).toBe('src/feature/pending-module');
+      expect(decision.pendingRemoval!.reason).toContain('not yet implemented');
+    });
+
+    it('returns real for external when allowExternalMock is disabled', () => {
+      const noExternalMockConfig: MockPolicyConfig = {
+        ...defaultConfig,
+        layers: {
+          ...defaultConfig.layers,
+          integration: {
+            ...defaultConfig.layers.integration,
+            allowExternalMock: false,
+          },
+        },
+      };
+      const engine = new MockDecisionEngine(baseScope, noExternalMockConfig);
+      const decision = engine.decide('lodash', 'integration');
+      expect(decision.strategy).toBe('real');
+      expect(decision.reason).toContain('allowExternalMock is disabled');
+    });
+
+    it('returns mock for unknown dependencies (falls to external)', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('some-unknown-package', 'integration');
+      expect(decision.strategy).toBe('mock');
+      expect(decision.reason).toContain('External dependency');
+    });
+  });
+
+  describe('unknown layer — falls back to unit behavior', () => {
+    it('treats unknown layer like unit — applies lenient mock for all deps', () => {
+      const engine = new MockDecisionEngine(baseScope, defaultConfig);
+      const decision = engine.decide('lodash', 'unknown' as TestLayer);
+      expect(decision.strategy).toBe('mock');
+      // Falls back to unit layer rules (lenient → all mocked per policy)
+      expect(decision.reason).toContain('should be mocked');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles empty implementedModules gracefully', () => {
+      const emptyImplementedScope: ProjectScope = {
+        ...baseScope,
+        implementedModules: [],
+      };
+      const engine = new MockDecisionEngine(emptyImplementedScope, defaultConfig);
+      const decision = engine.decide('src/utils/helper', 'integration');
+      // Not matched as implemented, external, or pending → falls to unknown → mock
+      expect(decision.strategy).toBe('mock');
+    });
+
+    it('handles empty externalPackages gracefully', () => {
+      const noExternalScope: ProjectScope = {
+        ...baseScope,
+        externalPackages: [],
+      };
+      const engine = new MockDecisionEngine(noExternalScope, defaultConfig);
+      const decision = engine.decide('lodash', 'integration');
+      // lodash is a bare import, classifyDependency routes to external via
+      // isExternalImport (not matched in externalPackages list), allowExternalMock=true → mock
+      expect(decision.strategy).toBe('mock');
+      expect(decision.reason).toContain('External dependency');
+    });
+  });
+});