261 lines
8.4 KiB
TypeScript
261 lines
8.4 KiB
TypeScript
/**
|
|
* Tests for OpenAI Provider
|
|
*/
|
|
|
|
import { describe, it, expect, beforeEach } from 'bun:test';
|
|
import { OpenAIProvider, AIProviderError, AIErrorType } from '../src/index.js';
|
|
|
|
describe('OpenAIProvider', () => {
|
|
let provider: OpenAIProvider;
|
|
|
|
beforeEach(() => {
|
|
provider = new OpenAIProvider({
|
|
apiKey: 'test-api-key',
|
|
defaultModel: 'gpt-3.5-turbo'
|
|
});
|
|
});
|
|
|
|
describe('constructor', () => {
|
|
it('should create provider with valid config', () => {
|
|
expect(provider).toBeInstanceOf(OpenAIProvider);
|
|
expect(provider.isInitialized()).toBe(false);
|
|
});
|
|
|
|
it('should throw error for missing API key', () => {
|
|
expect(() => {
|
|
new OpenAIProvider({ apiKey: '' });
|
|
}).toThrow(AIProviderError);
|
|
});
|
|
|
|
it('should set default model', () => {
|
|
const customProvider = new OpenAIProvider({
|
|
apiKey: 'test-key',
|
|
defaultModel: 'gpt-4'
|
|
});
|
|
expect(customProvider).toBeInstanceOf(OpenAIProvider);
|
|
});
|
|
|
|
it('should handle organization and project options', () => {
|
|
const customProvider = new OpenAIProvider({
|
|
apiKey: 'test-key',
|
|
organization: 'org-123',
|
|
project: 'proj-456'
|
|
});
|
|
expect(customProvider).toBeInstanceOf(OpenAIProvider);
|
|
});
|
|
});
|
|
|
|
describe('getInfo', () => {
|
|
it('should return provider information', () => {
|
|
const info = provider.getInfo();
|
|
|
|
expect(info.name).toBe('OpenAI');
|
|
expect(info.version).toBe('1.0.0');
|
|
expect(info.supportsStreaming).toBe(true);
|
|
expect(info.models).toContain('gpt-4');
|
|
expect(info.models).toContain('gpt-3.5-turbo');
|
|
expect(info.maxContextLength).toBe(128000);
|
|
expect(info.capabilities).toHaveProperty('vision', true);
|
|
expect(info.capabilities).toHaveProperty('functionCalling', true);
|
|
expect(info.capabilities).toHaveProperty('jsonMode', true);
|
|
expect(info.capabilities).toHaveProperty('systemMessages', true);
|
|
});
|
|
});
|
|
|
|
describe('validation', () => {
|
|
it('should validate temperature range', async () => {
|
|
// Mock initialization to avoid API call
|
|
(provider as any).initialized = true;
|
|
(provider as any).client = {};
|
|
|
|
await expect(
|
|
provider.complete({
|
|
messages: [{ role: 'user', content: 'test' }],
|
|
temperature: 1.5
|
|
})
|
|
).rejects.toThrow('Temperature must be a number between 0.0 and 1.0');
|
|
});
|
|
|
|
it('should validate top_p range', async () => {
|
|
(provider as any).initialized = true;
|
|
(provider as any).client = {};
|
|
|
|
await expect(
|
|
provider.complete({
|
|
messages: [{ role: 'user', content: 'test' }],
|
|
topP: 1.5
|
|
})
|
|
).rejects.toThrow('Top-p must be a number between 0.0 (exclusive) and 1.0 (inclusive)');
|
|
});
|
|
|
|
it('should validate message format', async () => {
|
|
(provider as any).initialized = true;
|
|
(provider as any).client = {};
|
|
|
|
await expect(
|
|
provider.complete({
|
|
messages: [{ role: 'invalid' as any, content: 'test' }]
|
|
})
|
|
).rejects.toThrow('Message at index 0 has invalid role \'invalid\'. Must be: system, user, assistant');
|
|
});
|
|
|
|
it('should validate empty content', async () => {
|
|
(provider as any).initialized = true;
|
|
(provider as any).client = {};
|
|
|
|
await expect(
|
|
provider.complete({
|
|
messages: [{ role: 'user', content: '' }]
|
|
})
|
|
).rejects.toThrow('Message at index 0 must have non-empty string content');
|
|
});
|
|
|
|
it('should require initialization before use', async () => {
|
|
await expect(
|
|
provider.complete({
|
|
messages: [{ role: 'user', content: 'test' }]
|
|
})
|
|
).rejects.toThrow('Provider must be initialized before use');
|
|
});
|
|
});
|
|
|
|
describe('error handling', () => {
|
|
it('should handle authentication errors', () => {
|
|
const error = new Error('Unauthorized');
|
|
(error as any).status = 401;
|
|
|
|
const providerError = (provider as any).handleOpenAIError(error);
|
|
|
|
expect(providerError).toBeInstanceOf(AIProviderError);
|
|
expect(providerError.type).toBe(AIErrorType.AUTHENTICATION);
|
|
expect(providerError.message).toContain('Authentication failed');
|
|
});
|
|
|
|
it('should handle rate limit errors', () => {
|
|
const error = new Error('Rate limited');
|
|
(error as any).status = 429;
|
|
|
|
const providerError = (provider as any).handleOpenAIError(error);
|
|
|
|
expect(providerError).toBeInstanceOf(AIProviderError);
|
|
expect(providerError.type).toBe(AIErrorType.RATE_LIMIT);
|
|
expect(providerError.message).toContain('Too many requests');
|
|
});
|
|
|
|
it('should handle model not found errors', () => {
|
|
const error = new Error('Model not found');
|
|
(error as any).status = 404;
|
|
|
|
const providerError = (provider as any).handleOpenAIError(error);
|
|
|
|
expect(providerError).toBeInstanceOf(AIProviderError);
|
|
expect(providerError.type).toBe(AIErrorType.MODEL_NOT_FOUND);
|
|
expect(providerError.message).toContain('Model not found');
|
|
});
|
|
|
|
it('should handle invalid request errors', () => {
|
|
const error = new Error('Bad request');
|
|
(error as any).status = 400;
|
|
|
|
const providerError = (provider as any).handleOpenAIError(error);
|
|
|
|
expect(providerError).toBeInstanceOf(AIProviderError);
|
|
expect(providerError.type).toBe(AIErrorType.INVALID_REQUEST);
|
|
});
|
|
|
|
it('should handle server errors', () => {
|
|
const error = new Error('Internal server error');
|
|
(error as any).status = 500;
|
|
|
|
const providerError = (provider as any).handleOpenAIError(error);
|
|
|
|
expect(providerError).toBeInstanceOf(AIProviderError);
|
|
expect(providerError.type).toBe(AIErrorType.NETWORK);
|
|
});
|
|
|
|
it('should handle unknown errors', () => {
|
|
const error = new Error('Unknown error');
|
|
|
|
const providerError = (provider as any).handleOpenAIError(error);
|
|
|
|
expect(providerError).toBeInstanceOf(AIProviderError);
|
|
expect(providerError.type).toBe(AIErrorType.UNKNOWN);
|
|
});
|
|
});
|
|
|
|
describe('message conversion', () => {
|
|
it('should convert messages to OpenAI format', () => {
|
|
const messages = [
|
|
{ role: 'system' as const, content: 'You are helpful' },
|
|
{ role: 'user' as const, content: 'Hello' },
|
|
{ role: 'assistant' as const, content: 'Hi there' }
|
|
];
|
|
|
|
const result = (provider as any).convertMessages(messages);
|
|
|
|
expect(result).toHaveLength(3);
|
|
expect(result[0]).toEqual({ role: 'system', content: 'You are helpful' });
|
|
expect(result[1]).toEqual({ role: 'user', content: 'Hello' });
|
|
expect(result[2]).toEqual({ role: 'assistant', content: 'Hi there' });
|
|
});
|
|
|
|
it('should handle messages with metadata', () => {
|
|
const messages = [
|
|
{
|
|
role: 'user' as const,
|
|
content: 'Hello',
|
|
metadata: { timestamp: '2024-01-01' }
|
|
}
|
|
];
|
|
|
|
const result = (provider as any).convertMessages(messages);
|
|
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0]).toEqual({ role: 'user', content: 'Hello' });
|
|
// Metadata should not be included in OpenAI format
|
|
});
|
|
});
|
|
|
|
describe('response formatting', () => {
|
|
it('should format completion response correctly', () => {
|
|
const mockResponse = {
|
|
id: 'chatcmpl-123',
|
|
model: 'gpt-3.5-turbo',
|
|
choices: [{
|
|
message: { content: 'Hello there!' },
|
|
finish_reason: 'stop'
|
|
}],
|
|
usage: {
|
|
prompt_tokens: 10,
|
|
completion_tokens: 20,
|
|
total_tokens: 30
|
|
},
|
|
system_fingerprint: 'fp_123'
|
|
};
|
|
|
|
const result = (provider as any).formatCompletionResponse(mockResponse);
|
|
|
|
expect(result.content).toBe('Hello there!');
|
|
expect(result.model).toBe('gpt-3.5-turbo');
|
|
expect(result.id).toBe('chatcmpl-123');
|
|
expect(result.usage.promptTokens).toBe(10);
|
|
expect(result.usage.completionTokens).toBe(20);
|
|
expect(result.usage.totalTokens).toBe(30);
|
|
expect(result.metadata.finishReason).toBe('stop');
|
|
expect(result.metadata.systemFingerprint).toBe('fp_123');
|
|
});
|
|
|
|
it('should throw error for empty response', () => {
|
|
const mockResponse = {
|
|
id: 'chatcmpl-123',
|
|
model: 'gpt-3.5-turbo',
|
|
choices: [],
|
|
usage: { prompt_tokens: 10, completion_tokens: 0, total_tokens: 10 }
|
|
};
|
|
|
|
expect(() => {
|
|
(provider as any).formatCompletionResponse(mockResponse);
|
|
}).toThrow('No content found in OpenAI response');
|
|
});
|
|
});
|
|
});
|