@quantumai/quantum-cli-core
Version:
Quantum CLI Core - Multi-LLM Collaboration System
122 lines • 4.5 kB
JavaScript
/**
* @license
* Copyright 2025 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* Tests for the base provider class
*/
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { BaseLLMProvider } from './base-provider.js';
// Mock implementation for testing
class MockProvider extends BaseLLMProvider {
id = 'mock-provider';
capabilities = ['mock-capability'];
constructor(providerConfig) {
super(providerConfig);
}
async generate(prompt) {
const textContent = `Mock response to: ${prompt}`;
return this.createResponse(textContent, 100, 10, 0.001, 0.9);
}
async validateCredentials() {
return true;
}
}
describe('BaseLLMProvider', () => {
let config;
beforeEach(() => {
config = {
id: 'test-provider',
name: 'Test Provider',
type: 'gemini',
enabled: true,
apiKey: 'test-api-key',
capabilities: ['text-generation'],
costPerToken: 0.0001,
};
});
describe('constructor', () => {
it('should initialize with direct API key', () => {
const provider = new MockProvider(config);
expect(provider.getId()).toBe('test-provider');
expect(provider.getType()).toBe('gemini');
});
it('should get API key from environment variable', () => {
const envConfig = {
...config,
apiKey: undefined,
apiKeyEnvVar: 'TEST_API_KEY',
type: 'gemini',
name: 'Test Provider',
};
vi.stubEnv('TEST_API_KEY', 'env-api-key');
const provider = new MockProvider(envConfig);
expect(provider.getId()).toBe('test-provider');
vi.unstubAllEnvs();
});
it('should throw error if no API key is provided', () => {
const noKeyConfig = {
...config,
apiKey: undefined,
type: 'gemini',
name: 'Test Provider',
};
expect(() => new MockProvider(noKeyConfig)).toThrow('API key not found');
});
});
describe('provider properties', () => {
let provider;
beforeEach(() => {
provider = new MockProvider(config);
});
it('should return correct ID and type', () => {
expect(provider.getId()).toBe('test-provider');
expect(provider.getType()).toBe('gemini');
});
it('should return enabled status', () => {
expect(provider.isEnabled()).toBe(true);
});
it('should return capabilities and strengths', () => {
expect(provider.getCapabilities()).toEqual(['text-generation']);
expect(provider.getStrengths()).toEqual(['reasoning', 'code']);
});
it('should return empty arrays if capabilities/strengths not defined', () => {
const minimalConfig = {
...config,
capabilities: undefined,
type: 'gemini',
name: 'Test Provider',
};
const minimalProvider = new MockProvider(minimalConfig);
expect(minimalProvider.getCapabilities()).toEqual([]);
expect(minimalProvider.getStrengths?.() ?? []).toEqual([]);
});
});
describe('cost calculation', () => {
it('should calculate cost correctly', () => {
const provider = new MockProvider(config);
expect(provider.calculateCost(1000)).toBe(0.1);
expect(provider.calculateCost(5000)).toBe(0.5);
});
it('should return 0 if costPerToken not defined', () => {
const noCostConfig = {
...config,
costPerToken: undefined,
type: 'gemini',
name: 'Test Provider',
};
const provider = new MockProvider(noCostConfig);
expect(provider.calculateCost(1000)).toBe(0);
});
});
describe('response creation', () => {
it('should generate response with mock implementation', async () => {
const provider = new MockProvider(config);
const response = await provider.generate('test query');
expect(response.providerId).toBe('test-provider');
expect(response.content).toBe('Mock response to: test query');
});
});
});
//# sourceMappingURL=base-provider.test.js.map