agentic-orchestrator 0.1.2 → 0.1.4

package/apps/control-plane/test/spec-ingestion.spec.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+  stableHash: vi.fn(() => 'abc123'),
+  ensureDir: vi.fn(async () => {}),
+  callCliTool: vi.fn(async (_client: unknown, _runId: string, toolName: string) => {
+    if (toolName === 'feature.state_get') {
+      return { data: { front_matter: { version: 1 } } };
+    }
+    return { data: {} };
+  }),
+  readFile: vi.fn(async () => 'spec content'),
+  writeFile: vi.fn(async () => {}),
+  canonicalFeatureIdFromPath: vi.fn(() => 'derived-feature'),
+  isCanonicalSpecPath: vi.fn((): string | null => null),
+  isLegacyCanonicalSpecPath: vi.fn((): string | null => null)
+}));
+
+vi.mock('../src/core/fs.js', () => ({
+  stableHash: mocks.stableHash,
+  ensureDir: mocks.ensureDir
+}));
+
+vi.mock('../src/cli/tooling.js', () => ({
+  callCliTool: mocks.callCliTool
+}));
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: mocks.readFile,
+    writeFile: mocks.writeFile
+  }
+}));
+
+vi.mock('../src/cli/spec-utils.js', () => ({
+  canonicalFeatureIdFromPath: mocks.canonicalFeatureIdFromPath,
+  isCanonicalSpecPath: mocks.isCanonicalSpecPath,
+  isLegacyCanonicalSpecPath: mocks.isLegacyCanonicalSpecPath
+}));
+
+import { SpecIngestionService } from '../src/cli/spec-ingestion-service.js';
+
+const REPO_ROOT = '/repo';
+const TOOL_CLIENT = {} as never;
+const RUN_ID = 'run:test';
+
+function makeService() {
+  return new SpecIngestionService(REPO_ROOT, TOOL_CLIENT, RUN_ID);
+}
+
+describe('SpecIngestionService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.callCliTool.mockImplementation(async (_client: unknown, _runId: string, toolName: string) => {
+      if (toolName === 'feature.state_get') {
+        return { data: { front_matter: { version: 1 } } };
+      }
+      return { data: {} };
+    });
+    mocks.isCanonicalSpecPath.mockReturnValue(null);
+    mocks.isLegacyCanonicalSpecPath.mockReturnValue(null);
+    mocks.canonicalFeatureIdFromPath.mockReturnValue('derived-feature');
+    mocks.readFile.mockResolvedValue('spec content');
+    mocks.writeFile.mockResolvedValue(undefined);
+    mocks.ensureDir.mockResolvedValue(undefined);
+    mocks.stableHash.mockReturnValue('abc123');
+  });
+
+  describe('ingest - canonical path', () => {
+    it('GIVEN_canonical_spec_path_WHEN_ingest_called_THEN_uses_canonical_feature_id_and_skips_file_copy', async () => {
+      mocks.isCanonicalSpecPath.mockReturnValue('my-feature');
+      const service = makeService();
+
+      const result = await service.ingest(['/repo/.aop/features/my-feature/spec.md']);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].feature_id).toBe('my-feature');
+      expect(mocks.ensureDir).not.toHaveBeenCalled();
+      expect(mocks.writeFile).not.toHaveBeenCalled();
+    });
+
+    it('GIVEN_canonical_path_WHEN_ingest_called_THEN_calls_feature_init_state_get_and_state_patch', async () => {
+      mocks.isCanonicalSpecPath.mockReturnValue('my-feature');
+      const service = makeService();
+
+      await service.ingest(['/repo/.aop/features/my-feature/spec.md']);
+
+      const toolNames = mocks.callCliTool.mock.calls.map((c: unknown[]) => c[2]);
+      expect(toolNames).toContain('feature.init');
+      expect(toolNames).toContain('feature.state_get');
+      expect(toolNames).toContain('feature.state_patch');
+    });
+  });
+
+  describe('ingest - legacy canonical path', () => {
+    it('GIVEN_legacy_canonical_path_WHEN_ingest_called_THEN_copies_file_to_canonical_location', async () => {
+      mocks.isCanonicalSpecPath.mockReturnValue(null);
+      mocks.isLegacyCanonicalSpecPath.mockReturnValue('legacy-feature');
+      const service = makeService();
+
+      const result = await service.ingest(['/repo/agentic/features/legacy-feature/spec.md']);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].feature_id).toBe('legacy-feature');
+      expect(mocks.ensureDir).toHaveBeenCalled();
+      expect(mocks.writeFile).toHaveBeenCalled();
+    });
+
+    it('GIVEN_legacy_canonical_path_WHEN_ingest_called_THEN_target_path_is_under_aop_features', async () => {
+      mocks.isCanonicalSpecPath.mockReturnValue(null);
+      mocks.isLegacyCanonicalSpecPath.mockReturnValue('legacy-feature');
+      const service = makeService();
+
+      await service.ingest(['/repo/agentic/features/legacy-feature/spec.md']);
+
+      const writeArgs = mocks.writeFile.mock.calls[0] as unknown[];
+      expect(String(writeArgs[0])).toContain('.aop');
+      expect(String(writeArgs[0])).toContain('legacy-feature');
+    });
+  });
+
+  describe('ingest - default path', () => {
+    it('GIVEN_arbitrary_path_WHEN_ingest_called_THEN_uses_canonicalFeatureIdFromPath_and_copies_file', async () => {
+      mocks.isCanonicalSpecPath.mockReturnValue(null);
+      mocks.isLegacyCanonicalSpecPath.mockReturnValue(null);
+      mocks.canonicalFeatureIdFromPath.mockReturnValue('derived-feature');
+      const service = makeService();
+
+      const result = await service.ingest(['/somewhere/derived-feature.md']);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].feature_id).toBe('derived-feature');
+      expect(mocks.canonicalFeatureIdFromPath).toHaveBeenCalledWith('/somewhere/derived-feature.md');
+      expect(mocks.ensureDir).toHaveBeenCalled();
+      expect(mocks.writeFile).toHaveBeenCalled();
+    });
+  });
+
+  describe('ingest - duplicate feature id', () => {
+    it('GIVEN_two_paths_resolving_to_same_feature_id_WHEN_ingest_called_THEN_throws_FEATURE_SLUG_COLLISION', async () => {
+      mocks.isCanonicalSpecPath.mockReturnValue('my-feature');
+      const service = makeService();
+
+      await expect(
+        service.ingest([
+          '/repo/.aop/features/my-feature/spec.md',
+          '/repo/.aop/features/my-feature/spec.md'
+        ])
+      ).rejects.toMatchObject({ code: 'feature_slug_collision' });
+    });
+
+    it('GIVEN_collision_error_WHEN_thrown_THEN_includes_feature_id_in_details', async () => {
+      mocks.isCanonicalSpecPath.mockReturnValue('colliding-feature');
+      const service = makeService();
+
+      await expect(
+        service.ingest([
+          '/repo/.aop/features/colliding-feature/spec.md',
+          '/repo/.aop/features/colliding-feature/spec.md'
+        ])
+      ).rejects.toMatchObject({ details: { feature_id: 'colliding-feature' } });
+    });
+  });
+
+  describe('ingest - multiple paths', () => {
+    it('GIVEN_multiple_distinct_canonical_paths_WHEN_ingest_called_THEN_returns_item_for_each', async () => {
+      mocks.isCanonicalSpecPath
+        .mockReturnValueOnce('feature-a')
+        .mockReturnValueOnce('feature-b');
+      const service = makeService();
+
+      const result = await service.ingest([
+        '/repo/.aop/features/feature-a/spec.md',
+        '/repo/.aop/features/feature-b/spec.md'
+      ]);
+
+      expect(result).toHaveLength(2);
+      expect(result[0].feature_id).toBe('feature-a');
+      expect(result[1].feature_id).toBe('feature-b');
+    });
+
+    it('GIVEN_empty_paths_array_WHEN_ingest_called_THEN_returns_empty_array', async () => {
+      const service = makeService();
+
+      const result = await service.ingest([]);
+
+      expect(result).toHaveLength(0);
+    });
+  });
+});