cognitive-core 0.0.2 → 0.1.0

package/tests/runtime/mock-backend.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { MockBackend, createMockBackend } from '../../src/runtime/backends/mock.js';
+import { createTask } from '../../src/types/task.js';
+
+describe('MockBackend', () => {
+  let backend: MockBackend;
+
+  beforeEach(() => {
+    backend = new MockBackend();
+  });
+
+  describe('constructor and availability', () => {
+    it('should have correct name and supported types', () => {
+      expect(backend.name).toBe('mock');
+      expect(backend.supportedTypes).toContain('mock');
+      expect(backend.supportedTypes).toContain('test');
+    });
+
+    it('should always be available', async () => {
+      expect(await backend.isAvailable()).toBe(true);
+    });
+  });
+
+  describe('spawn', () => {
+    it('should spawn a session with default success behavior', async () => {
+      const task = createTask({
+        domain: 'test',
+        description: 'Test task',
+      });
+
+      const session = await backend.spawn({
+        agentType: 'mock',
+        task,
+      });
+
+      expect(session.id).toBeDefined();
+      expect(session.agentType).toBe('mock');
+      expect(session.task).toEqual(task);
+      expect(session.state).toBe('running');
+      expect(session.messages).toEqual([]);
+      expect(session.toolCalls).toEqual([]);
+
+      // Wait for completion
+      await new Promise(resolve => setTimeout(resolve, 150));
+
+      const updatedSession = await backend.getSession(session.id);
+      expect(updatedSession?.state).toBe('completed');
+      expect(updatedSession?.result).toBe('Mock result');
+    });
+
+    it('should use custom default behavior', async () => {
+      const customBackend = createMockBackend({
+        success: true,
+        result: { custom: 'result' },
+        durationMs: 50,
+      });
+
+      const task = createTask({ domain: 'test', description: 'Custom test' });
+      const session = await customBackend.spawn({ agentType: 'mock', task });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const updated = await customBackend.getSession(session.id);
+      expect(updated?.result).toEqual({ custom: 'result' });
+    });
+
+    it('should use task-specific behavior', async () => {
+      backend.setBehavior('Special task', {
+        success: true,
+        result: 'Special result',
+        durationMs: 50,
+      });
+
+      const task = createTask({ domain: 'test', description: 'Special task' });
+      const session = await backend.spawn({ agentType: 'mock', task });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const updated = await backend.getSession(session.id);
+      expect(updated?.result).toBe('Special result');
+    });
+
+    it('should handle failure behavior', async () => {
+      backend.setDefaultBehavior({
+        success: false,
+        error: 'Test error',
+        durationMs: 50,
+      });
+
+      const task = createTask({ domain: 'test', description: 'Failing task' });
+      const session = await backend.spawn({ agentType: 'mock', task });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const updated = await backend.getSession(session.id);
+      expect(updated?.state).toBe('failed');
+      expect(updated?.error).toBe('Test error');
+    });
+
+    it('should emit messages with callbacks', async () => {
+      const onMessage = vi.fn();
+
+      backend.setDefaultBehavior({
+        success: true,
+        messages: [
+          { role: 'assistant', content: 'Hello' },
+          { role: 'assistant', content: 'Working...' },
+        ],
+        durationMs: 50,
+      });
+
+      const task = createTask({ domain: 'test', description: 'Message task' });
+      await backend.spawn({
+        agentType: 'mock',
+        task,
+        onMessage,
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(onMessage).toHaveBeenCalledTimes(2);
+      expect(onMessage).toHaveBeenCalledWith(
+        expect.objectContaining({ role: 'assistant', content: 'Hello' })
+      );
+    });
+
+    it('should emit tool calls with callbacks', async () => {
+      const onToolCall = vi.fn();
+
+      backend.setDefaultBehavior({
+        success: true,
+        toolCalls: [
+          { name: 'read_file', input: { path: 'test.ts' }, output: 'content' },
+          { name: 'write_file', input: { path: 'out.ts' }, output: 'ok' },
+        ],
+        durationMs: 50,
+      });
+
+      const task = createTask({ domain: 'test', description: 'Tool task' });
+      await backend.spawn({
+        agentType: 'mock',
+        task,
+        onToolCall,
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      expect(onToolCall).toHaveBeenCalledTimes(2);
+      expect(onToolCall).toHaveBeenCalledWith(
+        expect.objectContaining({ name: 'read_file' })
+      );
+    });
+
+    it('should track injected knowledge in metadata', async () => {
+      const task = createTask({ domain: 'test', description: 'Knowledge task' });
+      const session = await backend.spawn({
+        agentType: 'mock',
+        task,
+        injectedKnowledge: { experiences: [], strategies: [] },
+        systemPromptAdditions: 'Additional context',
+      });
+
+      expect(session.metadata.injectedKnowledge).toBe(true);
+      expect(session.metadata.hasSystemPromptAdditions).toBe(true);
+    });
+  });
+
+  describe('getSession', () => {
+    it('should return session by id', async () => {
+      const task = createTask({ domain: 'test', description: 'Get session task' });
+      const session = await backend.spawn({ agentType: 'mock', task });
+
+      const retrieved = await backend.getSession(session.id);
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe(session.id);
+    });
+
+    it('should return undefined for non-existent session', async () => {
+      const result = await backend.getSession('non-existent');
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('sendMessage', () => {
+    it('should throw for non-existent session', async () => {
+      await expect(
+        backend.sendMessage('non-existent', 'hello')
+      ).rejects.toThrow('Session not found');
+    });
+
+    it('should not throw for existing session', async () => {
+      const task = createTask({ domain: 'test', description: 'test' });
+      const session = await backend.spawn({ agentType: 'mock', task });
+
+      await expect(
+        backend.sendMessage(session.id, 'hello')
+      ).resolves.not.toThrow();
+    });
+  });
+
+  describe('terminate', () => {
+    it('should terminate a running session', async () => {
+      backend.setDefaultBehavior({ success: true, durationMs: 500 });
+
+      const task = createTask({ domain: 'test', description: 'Long task' });
+      const session = await backend.spawn({ agentType: 'mock', task });
+
+      expect(session.state).toBe('running');
+
+      await backend.terminate(session.id);
+
+      const updated = await backend.getSession(session.id);
+      expect(updated?.state).toBe('failed');
+      expect(updated?.error).toBe('Terminated');
+    });
+
+    it('should handle non-existent session gracefully', async () => {
+      await expect(backend.terminate('non-existent')).resolves.not.toThrow();
+    });
+  });
+
+  describe('listSessions', () => {
+    it('should list all sessions', async () => {
+      const task1 = createTask({ domain: 'test', description: 'Task 1' });
+      const task2 = createTask({ domain: 'test', description: 'Task 2' });
+
+      await backend.spawn({ agentType: 'mock', task: task1 });
+      await backend.spawn({ agentType: 'mock', task: task2 });
+
+      const sessions = await backend.listSessions();
+      expect(sessions).toHaveLength(2);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all sessions and behaviors', async () => {
+      backend.setBehavior('Special', { success: true });
+      const task = createTask({ domain: 'test', description: 'Task' });
+      await backend.spawn({ agentType: 'mock', task });
+
+      expect((await backend.listSessions()).length).toBe(1);
+
+      backend.clear();
+
+      expect((await backend.listSessions()).length).toBe(0);
+    });
+  });
+});