import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { chatDuckTool } from '../../src/tools/chat-duck.js';
import { ProviderManager } from '../../src/providers/manager.js';
import { ConversationManager } from '../../src/services/conversation.js';
// Mock dependencies
jest.mock('../../src/utils/logger');
jest.mock('../../src/providers/manager.js');
jest.mock('../../src/services/conversation.js');
describe('chatDuckTool', () => {
let mockProviderManager: jest.Mocked<ProviderManager>;
let mockConversationManager: jest.Mocked<ConversationManager>;
const mockResponse = {
provider: 'openai',
nickname: 'OpenAI Duck',
content: 'This is a test response.',
model: 'gpt-4',
latency: 150,
};
const mockConversation = {
id: 'test-conv',
provider: 'openai',
messages: [],
createdAt: new Date(),
updatedAt: new Date(),
};
beforeEach(() => {
mockProviderManager = {
askDuck: jest.fn().mockResolvedValue(mockResponse),
getProviderNames: jest.fn().mockReturnValue(['openai', 'groq']),
} as unknown as jest.Mocked<ProviderManager>;
mockConversationManager = {
getConversation: jest.fn().mockReturnValue(mockConversation),
createConversation: jest.fn().mockReturnValue(mockConversation),
switchProvider: jest.fn().mockReturnValue({ ...mockConversation, provider: 'groq' }),
addMessage: jest.fn().mockReturnValue(mockConversation),
getConversationContext: jest.fn().mockReturnValue([]),
} as unknown as jest.Mocked<ConversationManager>;
});
it('should throw error when conversation_id is missing', async () => {
await expect(
chatDuckTool(mockProviderManager, mockConversationManager, { message: 'Hello' })
).rejects.toThrow('conversation_id and message are required');
});
it('should throw error when message is missing', async () => {
await expect(
chatDuckTool(mockProviderManager, mockConversationManager, { conversation_id: 'test' })
).rejects.toThrow('conversation_id and message are required');
});
it('should create new conversation if not exists', async () => {
mockConversationManager.getConversation.mockReturnValue(undefined);
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'new-conv',
message: 'Hello',
});
expect(mockConversationManager.createConversation).toHaveBeenCalledWith('new-conv', 'openai');
});
it('should use existing conversation', async () => {
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'test-conv',
message: 'Hello',
});
expect(mockConversationManager.createConversation).not.toHaveBeenCalled();
});
it('should switch provider when requested', async () => {
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'test-conv',
message: 'Hello',
provider: 'groq',
});
expect(mockConversationManager.switchProvider).toHaveBeenCalledWith('test-conv', 'groq');
});
it('should not switch provider if same as current', async () => {
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'test-conv',
message: 'Hello',
provider: 'openai', // Same as mockConversation.provider
});
expect(mockConversationManager.switchProvider).not.toHaveBeenCalled();
});
it('should add user message to conversation', async () => {
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'test-conv',
message: 'What is TypeScript?',
});
expect(mockConversationManager.addMessage).toHaveBeenCalledWith(
'test-conv',
expect.objectContaining({
role: 'user',
content: 'What is TypeScript?',
})
);
});
it('should add assistant response to conversation', async () => {
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'test-conv',
message: 'Hello',
});
expect(mockConversationManager.addMessage).toHaveBeenCalledWith(
'test-conv',
expect.objectContaining({
role: 'assistant',
content: 'This is a test response.',
})
);
});
it('should pass conversation context to provider', async () => {
const contextMessages = [
{ role: 'user' as const, content: 'Previous', timestamp: new Date() },
];
mockConversationManager.getConversationContext.mockReturnValue(contextMessages);
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'test-conv',
message: 'Hello',
});
expect(mockProviderManager.askDuck).toHaveBeenCalledWith(
'openai',
'',
expect.objectContaining({
messages: contextMessages,
})
);
});
it('should pass model option to provider', async () => {
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'test-conv',
message: 'Hello',
model: 'gpt-3.5-turbo',
});
expect(mockProviderManager.askDuck).toHaveBeenCalledWith(
'openai',
'',
expect.objectContaining({
model: 'gpt-3.5-turbo',
})
);
});
it('should format response with conversation info', async () => {
mockConversationManager.getConversationContext.mockReturnValue([
{ role: 'user' as const, content: 'Hello', timestamp: new Date() },
]);
const result = await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'test-conv',
message: 'Hello',
});
expect(result.content[0].text).toContain('OpenAI Duck');
expect(result.content[0].text).toContain('test-conv');
expect(result.content[0].text).toContain('Messages: 2'); // context (1) + 1 new
expect(result.content[0].text).toContain('150ms');
});
it('should use specified provider for new conversation', async () => {
mockConversationManager.getConversation.mockReturnValue(undefined);
await chatDuckTool(mockProviderManager, mockConversationManager, {
conversation_id: 'new-conv',
message: 'Hello',
provider: 'groq',
});
expect(mockConversationManager.createConversation).toHaveBeenCalledWith('new-conv', 'groq');
});
});
