Add unit tests for ChatStreamProvider and BaseChatProvider interfaces

workers/site/providers/__tests__/chat-stream-provider.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi } from 'vitest';
+import { BaseChatProvider, CommonProviderParams, ChatStreamProvider } from '../chat-stream-provider';
+import { OpenAI } from 'openai';
+
+// Create a concrete implementation of BaseChatProvider for testing
+class TestChatProvider extends BaseChatProvider {
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    return param.openai as OpenAI;
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+    return {
+      model: param.model,
+      messages: safeMessages,
+      stream: true,
+      max_tokens: param.maxTokens as number,
+    };
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    dataCallback({ type: 'chat', data: chunk });
+    return false;
+  }
+}
+
+// Mock dependencies
+vi.mock('../../lib/chat-sdk', () => ({
+  default: {
+    buildAssistantPrompt: vi.fn().mockReturnValue('Assistant prompt'),
+    buildMessageChain: vi.fn().mockReturnValue([
+      { role: 'system', content: 'System prompt' },
+      { role: 'user', content: 'User message' }
+    ])
+  }
+}));
+
+describe('ChatStreamProvider', () => {
+  it('should define the required interface', () => {
+    // Verify the interface has the required method
+    const mockProvider: ChatStreamProvider = {
+      handleStream: vi.fn()
+    };
+
+    expect(mockProvider.handleStream).toBeDefined();
+  });
+});
+
+describe('BaseChatProvider', () => {
+  it('should implement the ChatStreamProvider interface', () => {
+    // Create a concrete implementation
+    const provider = new TestChatProvider();
+
+    // Verify it implements the interface
+    expect(provider.handleStream).toBeInstanceOf(Function);
+    expect(provider.getOpenAIClient).toBeInstanceOf(Function);
+    expect(provider.getStreamParams).toBeInstanceOf(Function);
+    expect(provider.processChunk).toBeInstanceOf(Function);
+  });
+
+  it('should have abstract methods that need to be implemented', () => {
+    // This test verifies that the abstract methods exist
+    // We can't instantiate BaseChatProvider directly, so we use the concrete implementation
+    const provider = new TestChatProvider();
+
+    // Verify the abstract methods are implemented
+    expect(provider.getOpenAIClient).toBeDefined();
+    expect(provider.getStreamParams).toBeDefined();
+    expect(provider.processChunk).toBeDefined();
+  });
+});