import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { askDuckTool } from '../../src/tools/ask-duck.js';
import { ProviderManager } from '../../src/providers/manager.js';
// Mock dependencies
jest.mock('../../src/utils/logger');
jest.mock('../../src/providers/manager.js');
describe('askDuckTool', () => {
let mockProviderManager: jest.Mocked<ProviderManager>;
const mockResponse = {
provider: 'openai',
nickname: 'OpenAI Duck',
content: 'This is a test response from the duck.',
model: 'gpt-4',
latency: 150,
usage: {
prompt_tokens: 10,
completion_tokens: 20,
total_tokens: 30,
},
};
beforeEach(() => {
mockProviderManager = {
askDuck: jest.fn().mockResolvedValue(mockResponse),
validateModel: jest.fn().mockReturnValue(true),
} as unknown as jest.Mocked<ProviderManager>;
});
it('should throw error when prompt is missing', async () => {
await expect(askDuckTool(mockProviderManager, {})).rejects.toThrow(
'Prompt is required'
);
});
it('should ask duck with basic prompt', async () => {
const result = await askDuckTool(mockProviderManager, {
prompt: 'What is TypeScript?',
});
expect(mockProviderManager.askDuck).toHaveBeenCalledWith(undefined, 'What is TypeScript?', {
model: undefined,
temperature: undefined,
});
expect(result.content).toHaveLength(1);
expect(result.content[0].type).toBe('text');
expect(result.content[0].text).toContain('OpenAI Duck');
expect(result.content[0].text).toContain('test response');
});
it('should include usage info in response', async () => {
const result = await askDuckTool(mockProviderManager, {
prompt: 'Test prompt',
});
expect(result.content[0].text).toContain('Tokens used: 30');
expect(result.content[0].text).toContain('10 prompt');
expect(result.content[0].text).toContain('20 completion');
});
it('should show latency in response', async () => {
const result = await askDuckTool(mockProviderManager, {
prompt: 'Test prompt',
});
expect(result.content[0].text).toContain('150ms');
});
it('should pass provider option', async () => {
await askDuckTool(mockProviderManager, {
prompt: 'Test',
provider: 'groq',
});
expect(mockProviderManager.askDuck).toHaveBeenCalledWith('groq', 'Test', expect.any(Object));
});
it('should pass model and temperature options', async () => {
await askDuckTool(mockProviderManager, {
prompt: 'Test',
provider: 'openai',
model: 'gpt-3.5-turbo',
temperature: 0.5,
});
expect(mockProviderManager.askDuck).toHaveBeenCalledWith('openai', 'Test', {
model: 'gpt-3.5-turbo',
temperature: 0.5,
});
});
it('should validate model when both provider and model are specified', async () => {
await askDuckTool(mockProviderManager, {
prompt: 'Test',
provider: 'openai',
model: 'gpt-4',
});
expect(mockProviderManager.validateModel).toHaveBeenCalledWith('openai', 'gpt-4');
});
it('should not validate model when provider is not specified', async () => {
await askDuckTool(mockProviderManager, {
prompt: 'Test',
model: 'gpt-4',
});
expect(mockProviderManager.validateModel).not.toHaveBeenCalled();
});
it('should handle response without usage info', async () => {
const responseWithoutUsage = { ...mockResponse, usage: undefined };
mockProviderManager.askDuck.mockResolvedValue(responseWithoutUsage);
const result = await askDuckTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).not.toContain('Tokens used');
});
it('should warn when model is not valid for provider', async () => {
mockProviderManager.validateModel.mockReturnValue(false);
// Should still work, just log a warning
const result = await askDuckTool(mockProviderManager, {
prompt: 'Test',
provider: 'openai',
model: 'invalid-model',
});
expect(mockProviderManager.validateModel).toHaveBeenCalledWith('openai', 'invalid-model');
expect(result.content[0].text).toContain('test response');
});
});
