@northflare/runner 0.0.1

package/tests/sdk-integration.test.ts

@@ -0,0 +1,329 @@
+/**
+ * SDK Integration Test
+ * 
+ * This test validates the core functionality of the new SDK-native implementation
+ * focusing on basic conversation operations that should work with the current code structure.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ClaudeManager } from '../src/components/claude-sdk-manager';
+import { RunnerApp } from '../src/runner-sse';
+import { EnhancedRepositoryManager } from '../src/components/enhanced-repository-manager';
+import type { ConversationConfig, ConversationContext, Message } from '../src/types';
+import type { IRunnerApp } from '../src/types/runner-interface';
+
+// Mock the Claude SDKs
+vi.mock("@anthropic-ai/claude-code", () => ({
+  query: vi.fn(),
+}));
+
+// Test configuration constants
+const TEST_CONFIG = {
+  MESSAGE_TIMEOUT_MS: 1000,
+} as const;
+
+// Mock data
+const mockSessionId = 'session_integration_test_12345';
+const mockConversationId = 'conv_integration_test_67890';
+const mockWorkspacePath = '/tmp/test-workspace-integration';
+const mockApiKey = 'sk-test-integration-key-12345';
+
+const mockConversationData = {
+  id: mockConversationId,
+  objectType: 'Task',
+  objectId: 'task_integration_123',
+  model: 'claude-3-5-sonnet-20241022',
+  globalInstructions: 'You are a test assistant.',
+  workspaceInstructions: 'This is a integration test workspace.',
+  permissionsMode: 'all',
+  agentSessionId: mockSessionId,
+};
+
+const mockConfig: ConversationConfig = {
+  anthropicApiKey: mockApiKey,
+  workspaceId: 'workspace_integration_123',
+  runnerRepoPath: mockWorkspacePath,
+};
+
+// Mock runner app
+const createMockRunner = (): IRunnerApp => ({
+  activeConversations_: new Map<string, ConversationContext>(),
+  config_: {
+    orchestratorUrl: 'http://localhost:4000',
+    dataDir: '/tmp/test-data',
+    heartbeatInterval: 30000,
+    retryStrategy: 'exponential' as const,
+    retryIntervalSecs: 5,
+    retryDurationSecs: 300,
+  },
+  getRunnerUid: vi.fn().mockReturnValue('runner_integration_test_uid'),
+  getConversationContext: vi.fn(),
+  notify: vi.fn().mockResolvedValue(undefined),
+  sendToOrchestrator: vi.fn().mockResolvedValue({ result: {} }),
+});
+
+// Mock repository manager
+const createMockRepositoryManager = (): EnhancedRepositoryManager => ({
+  checkoutRepository: vi.fn().mockResolvedValue(mockWorkspacePath),
+  getWorkspacePath: vi.fn().mockResolvedValue(mockWorkspacePath),
+  createTaskWorktree: vi.fn().mockResolvedValue({
+    worktreePath: mockWorkspacePath,
+    cleanup: vi.fn(),
+  }),
+  createLocalTaskHandle: vi.fn().mockResolvedValue({
+    path: mockWorkspacePath,
+    cleanup: vi.fn(),
+  }),
+} as any);
+
+describe('SDK Integration Tests', () => {
+  let mockRunner: IRunnerApp;
+  let mockRepositoryManager: EnhancedRepositoryManager;
+  let claudeManager: ClaudeManager;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    
+    mockRunner = createMockRunner();
+    mockRepositoryManager = createMockRepositoryManager();
+    claudeManager = new ClaudeManager(mockRunner, mockRepositoryManager);
+
+    // Mock the getConversationContext method
+    mockRunner.getConversationContext = vi.fn().mockImplementation((id) => 
+      mockRunner.activeConversations_.get(id)
+    );
+  });
+
+  afterEach(() => {
+    // Clean up any active conversations
+    mockRunner.activeConversations_.clear();
+  });
+
+  describe('1. Basic SDK Manager Initialization', () => {
+    it('should create ClaudeManager instance successfully', () => {
+      expect(claudeManager).toBeInstanceOf(ClaudeManager);
+    });
+
+    it('should have required dependencies injected', () => {
+      expect(claudeManager).toHaveProperty('runner');
+      expect(claudeManager).toHaveProperty('repositoryManager');
+    });
+  });
+
+  describe('2. Conversation Lifecycle Management', () => {
+    it('should start a conversation with valid configuration', async () => {
+      // Mock SDK query to return a conversation-like object
+      const mockSdkQuery = vi.fn().mockImplementation(() => {
+        // Return an async iterable that simulates a conversation
+        return {
+          [Symbol.asyncIterator]: async function* () {
+            yield {
+              type: 'system',
+              message: { role: 'system', content: 'Session started' },
+              session_id: mockSessionId,
+            };
+          }
+        };
+      });
+
+      const mockModule = await import('@anthropic-ai/claude-code');
+      vi.mocked(mockModule.query).mockImplementation(mockSdkQuery);
+
+      // Start a conversation
+      const result = await claudeManager.startConversation(
+        'Task',
+        'task_integration_123',
+        mockConfig,
+        [{ content: 'Hello, this is a test message.' }],
+        mockConversationData
+      );
+
+      expect(result).toBeDefined();
+      expect(result.conversationId).toBe(mockConversationId);
+      expect(result.status).toBe('starting');
+      expect(result.conversationObjectType).toBe('Task');
+      expect(result.conversationObjectId).toBe('task_integration_123');
+    });
+
+    it('should throw error when starting conversation without conversationData.id', async () => {
+      await expect(
+        claudeManager.startConversation(
+          'Task',
+          'task_123',
+          mockConfig,
+          [{ content: 'Test message' }],
+          // Missing conversationData
+        )
+      ).rejects.toThrow('startConversation requires conversationData with a valid conversation.id');
+    });
+  });
+
+  describe('3. Message Sending Functionality', () => {
+    it('should handle sendUserMessage gracefully', async () => {
+      // Create a mock conversation context
+      const mockConversation = {
+        send: vi.fn().mockResolvedValue(undefined),
+        end: vi.fn().mockResolvedValue(undefined),
+      };
+
+      const context: ConversationContext = {
+        conversationId: mockConversationId,
+        agentSessionId: mockSessionId,
+        conversationObjectType: 'Task',
+        conversationObjectId: 'task_123',
+        status: 'active',
+        config: mockConfig,
+        startedAt: new Date(),
+        lastActivityAt: new Date(),
+        conversation: mockConversation as any,
+        model: 'claude-3-5-sonnet-20241022',
+        globalInstructions: '',
+        workspaceInstructions: '',
+        permissionsMode: 'all',
+      };
+
+      mockRunner.activeConversations_.set(mockConversationId, context);
+
+      // Test sending a message
+      await claudeManager.sendUserMessage(mockConversationId, 'Test message');
+
+      expect(mockConversation.send).toHaveBeenCalledWith({
+        type: 'text',
+        text: 'Test message',
+      });
+    });
+
+    it('should throw error for non-existent conversation', async () => {
+      // Try to send message to non-existent conversation
+      await expect(
+        claudeManager.sendUserMessage('non_existent_id', 'Test message')
+      ).rejects.toThrow('No active or fetchable conversation found for non_existent_id');
+    });
+  });
+
+  describe('4. Error Handling', () => {
+    it('should validate required conversationData', async () => {
+      // Test with missing conversationData
+      await expect(
+        claudeManager.startConversation(
+          'Task',
+          'task_123',
+          mockConfig,
+          [{ content: 'Test message' }],
+          undefined // Missing conversationData
+        )
+      ).rejects.toThrow('startConversation requires conversationData with a valid conversation.id');
+    });
+
+    it('should handle repository manager errors during task handle creation', async () => {
+      // Mock repository manager to throw error on createLocalTaskHandle
+      const errorRepo = createMockRepositoryManager();
+      vi.mocked(errorRepo.createLocalTaskHandle).mockRejectedValue(new Error('Repository not found'));
+
+      const errorManager = new ClaudeManager(mockRunner, errorRepo);
+
+      await expect(
+        errorManager.startConversation(
+          'Task',
+          'task_123',
+          mockConfig,
+          [{ content: 'Test message' }],
+          mockConversationData
+        )
+      ).rejects.toThrow('Repository not found');
+    });
+  });
+
+  describe('5. State Management', () => {
+    it('should track active conversations correctly', async () => {
+      // Initial state should have no conversations
+      expect(mockRunner.activeConversations_.size).toBe(0);
+
+      // Mock SDK query for conversation start
+      const mockSdkQuery = vi.fn().mockImplementation(() => ({
+        [Symbol.asyncIterator]: async function* () {
+          yield {
+            type: 'system',
+            message: { role: 'system', content: 'Session started' },
+            session_id: mockSessionId,
+          };
+        }
+      }));
+
+      const mockModule = await import('@anthropic-ai/claude-code');
+      vi.mocked(mockModule.query).mockImplementation(mockSdkQuery);
+
+      // Start a conversation
+      await claudeManager.startConversation(
+        'Task',
+        'task_state_123',
+        mockConfig,
+        [{ content: 'State test message' }],
+        { ...mockConversationData, objectId: 'task_state_123' }
+      );
+
+      // Should now have one active conversation
+      expect(mockRunner.activeConversations_.size).toBe(1);
+      
+      const context = mockRunner.activeConversations_.get(mockConversationId);
+      expect(context).toBeDefined();
+      expect(context?.conversationObjectId).toBe('task_state_123');
+    });
+
+    it('should update conversation status appropriately', async () => {
+      // Create conversation context
+      const context: ConversationContext = {
+        conversationId: mockConversationId,
+        agentSessionId: mockSessionId,
+        conversationObjectType: 'Task',
+        conversationObjectId: 'task_123',
+        status: 'starting', // Initial status
+        config: mockConfig,
+        startedAt: new Date(),
+        lastActivityAt: new Date(),
+        model: 'claude-3-5-sonnet-20241022',
+        globalInstructions: '',
+        workspaceInstructions: '',
+        permissionsMode: 'all',
+      };
+
+      mockRunner.activeConversations_.set(mockConversationId, context);
+
+      // Verify initial status
+      expect(context.status).toBe('starting');
+
+      // Status should be updated during conversation operations
+      // This is tested implicitly through the conversation lifecycle
+    });
+  });
+
+  describe('6. Integration with Repository Manager', () => {
+    it('should use repository manager for task handle creation', async () => {
+      // Mock SDK query
+      const mockSdkQuery = vi.fn().mockImplementation(() => ({
+        [Symbol.asyncIterator]: async function* () {
+          yield {
+            type: 'system',
+            message: { role: 'system', content: 'Session started' },
+            session_id: mockSessionId,
+          };
+        }
+      }));
+
+      const mockModule = await import('@anthropic-ai/claude-code');
+      vi.mocked(mockModule.query).mockImplementation(mockSdkQuery);
+
+      // Start conversation (should call repository manager)
+      await claudeManager.startConversation(
+        'Task',
+        'task_repo_123',
+        mockConfig,
+        [{ content: 'Repository test message' }],
+        { ...mockConversationData, objectId: 'task_repo_123' }
+      );
+
+      // Verify repository manager was called for creating task handle
+      expect(mockRepositoryManager.createLocalTaskHandle).toHaveBeenCalled();
+    });
+  });
+});