mirror of
https://github.com/eyaltoledano/claude-task-master.git
synced 2025-11-07 13:27:47 +00:00
6a8a68e1a3
* fix: claude-4 not having the right max_tokens * feat: add bedrock support * chore: fix package-lock.json * fix: rename baseUrl to baseURL * feat: add azure support * fix: final touches of azure integration * feat: add google vertex provider * chore: fix tests and refactor task-manager.test.js * chore: move task 92 to 94
879 lines
27 KiB
JavaScript
879 lines
27 KiB
JavaScript
// @ts-check
|
|
/**
|
|
* Module to test the config-manager.js functionality
|
|
* This file uses ES module syntax (.mjs) to properly handle imports
|
|
*/
|
|
|
|
import fs from 'fs';
|
|
import path from 'path';
|
|
import { jest } from '@jest/globals';
|
|
import { fileURLToPath } from 'url';
|
|
import { sampleTasks } from '../fixtures/sample-tasks.js';
|
|
|
|
// Disable chalk's color detection which can cause fs.readFileSync calls
|
|
process.env.FORCE_COLOR = '0';
|
|
|
|
// --- Read REAL supported-models.json data BEFORE mocks ---
|
|
const __filename = fileURLToPath(import.meta.url); // Get current file path
|
|
const __dirname = path.dirname(__filename); // Get current directory
|
|
const realSupportedModelsPath = path.resolve(
|
|
__dirname,
|
|
'../../scripts/modules/supported-models.json'
|
|
);
|
|
let REAL_SUPPORTED_MODELS_CONTENT;
|
|
let REAL_SUPPORTED_MODELS_DATA;
|
|
try {
|
|
REAL_SUPPORTED_MODELS_CONTENT = fs.readFileSync(
|
|
realSupportedModelsPath,
|
|
'utf-8'
|
|
);
|
|
REAL_SUPPORTED_MODELS_DATA = JSON.parse(REAL_SUPPORTED_MODELS_CONTENT);
|
|
} catch (err) {
|
|
console.error(
|
|
'FATAL TEST SETUP ERROR: Could not read or parse real supported-models.json',
|
|
err
|
|
);
|
|
REAL_SUPPORTED_MODELS_CONTENT = '{}'; // Default to empty object on error
|
|
REAL_SUPPORTED_MODELS_DATA = {};
|
|
process.exit(1); // Exit if essential test data can't be loaded
|
|
}
|
|
|
|
// --- Define Mock Function Instances ---
|
|
const mockFindProjectRoot = jest.fn();
|
|
const mockLog = jest.fn();
|
|
const mockResolveEnvVariable = jest.fn();
|
|
|
|
// --- Mock fs functions directly instead of the whole module ---
|
|
const mockExistsSync = jest.fn();
|
|
const mockReadFileSync = jest.fn();
|
|
const mockWriteFileSync = jest.fn();
|
|
|
|
// Instead of mocking the entire fs module, mock just the functions we need
|
|
fs.existsSync = mockExistsSync;
|
|
fs.readFileSync = mockReadFileSync;
|
|
fs.writeFileSync = mockWriteFileSync;
|
|
|
|
// --- Test Data (Keep as is, ensure DEFAULT_CONFIG is accurate) ---
|
|
const MOCK_PROJECT_ROOT = '/mock/project';
|
|
const MOCK_CONFIG_PATH = path.join(MOCK_PROJECT_ROOT, '.taskmasterconfig');
|
|
|
|
// Updated DEFAULT_CONFIG reflecting the implementation
|
|
const DEFAULT_CONFIG = {
|
|
models: {
|
|
main: {
|
|
provider: 'anthropic',
|
|
modelId: 'claude-3-7-sonnet-20250219',
|
|
maxTokens: 64000,
|
|
temperature: 0.2
|
|
},
|
|
research: {
|
|
provider: 'perplexity',
|
|
modelId: 'sonar-pro',
|
|
maxTokens: 8700,
|
|
temperature: 0.1
|
|
},
|
|
fallback: {
|
|
provider: 'anthropic',
|
|
modelId: 'claude-3-5-sonnet',
|
|
maxTokens: 64000,
|
|
temperature: 0.2
|
|
}
|
|
},
|
|
global: {
|
|
logLevel: 'info',
|
|
debug: false,
|
|
defaultSubtasks: 5,
|
|
defaultPriority: 'medium',
|
|
projectName: 'Task Master',
|
|
ollamaBaseURL: 'http://localhost:11434/api'
|
|
}
|
|
};
|
|
|
|
// Other test data (VALID_CUSTOM_CONFIG, PARTIAL_CONFIG, INVALID_PROVIDER_CONFIG)
|
|
const VALID_CUSTOM_CONFIG = {
|
|
models: {
|
|
main: {
|
|
provider: 'openai',
|
|
modelId: 'gpt-4o',
|
|
maxTokens: 4096,
|
|
temperature: 0.5
|
|
},
|
|
research: {
|
|
provider: 'google',
|
|
modelId: 'gemini-1.5-pro-latest',
|
|
maxTokens: 8192,
|
|
temperature: 0.3
|
|
},
|
|
fallback: {
|
|
provider: 'anthropic',
|
|
modelId: 'claude-3-opus-20240229',
|
|
maxTokens: 100000,
|
|
temperature: 0.4
|
|
}
|
|
},
|
|
global: {
|
|
logLevel: 'debug',
|
|
defaultPriority: 'high',
|
|
projectName: 'My Custom Project'
|
|
}
|
|
};
|
|
|
|
const PARTIAL_CONFIG = {
|
|
models: {
|
|
main: { provider: 'openai', modelId: 'gpt-4-turbo' }
|
|
},
|
|
global: {
|
|
projectName: 'Partial Project'
|
|
}
|
|
};
|
|
|
|
const INVALID_PROVIDER_CONFIG = {
|
|
models: {
|
|
main: { provider: 'invalid-provider', modelId: 'some-model' },
|
|
research: {
|
|
provider: 'perplexity',
|
|
modelId: 'llama-3-sonar-large-32k-online'
|
|
}
|
|
},
|
|
global: {
|
|
logLevel: 'warn'
|
|
}
|
|
};
|
|
|
|
// Define spies globally to be restored in afterAll
|
|
let consoleErrorSpy;
|
|
let consoleWarnSpy;
|
|
|
|
beforeAll(() => {
|
|
// Set up console spies
|
|
consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
|
|
consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
|
|
});
|
|
|
|
afterAll(() => {
|
|
// Restore all spies
|
|
jest.restoreAllMocks();
|
|
});
|
|
|
|
describe('Config Manager Module', () => {
|
|
// Declare variables for imported module
|
|
let configManager;
|
|
|
|
// Reset mocks before each test for isolation
|
|
beforeEach(async () => {
|
|
// Clear all mock calls and reset implementations between tests
|
|
jest.clearAllMocks();
|
|
// Reset the external mock instances for utils
|
|
mockFindProjectRoot.mockReset();
|
|
mockLog.mockReset();
|
|
mockResolveEnvVariable.mockReset();
|
|
mockExistsSync.mockReset();
|
|
mockReadFileSync.mockReset();
|
|
mockWriteFileSync.mockReset();
|
|
|
|
// --- Mock Dependencies BEFORE importing the module under test ---
|
|
// Mock the 'utils.js' module using doMock (applied at runtime)
|
|
jest.doMock('../../scripts/modules/utils.js', () => ({
|
|
__esModule: true, // Indicate it's an ES module mock
|
|
findProjectRoot: mockFindProjectRoot, // Use the mock function instance
|
|
log: mockLog, // Use the mock function instance
|
|
resolveEnvVariable: mockResolveEnvVariable // Use the mock function instance
|
|
}));
|
|
|
|
// Dynamically import the module under test AFTER mocking dependencies
|
|
configManager = await import('../../scripts/modules/config-manager.js');
|
|
|
|
// --- Default Mock Implementations ---
|
|
mockFindProjectRoot.mockReturnValue(MOCK_PROJECT_ROOT); // Default for utils.findProjectRoot
|
|
mockExistsSync.mockReturnValue(true); // Assume files exist by default
|
|
|
|
// Default readFileSync: Return REAL models content, mocked config, or throw error
|
|
mockReadFileSync.mockImplementation((filePath) => {
|
|
const baseName = path.basename(filePath);
|
|
if (baseName === 'supported-models.json') {
|
|
// Return the REAL file content stringified
|
|
return REAL_SUPPORTED_MODELS_CONTENT;
|
|
} else if (filePath === MOCK_CONFIG_PATH) {
|
|
// Still mock the .taskmasterconfig reads
|
|
return JSON.stringify(DEFAULT_CONFIG); // Default behavior
|
|
}
|
|
// Throw for unexpected reads - helps catch errors
|
|
throw new Error(`Unexpected fs.readFileSync call in test: ${filePath}`);
|
|
});
|
|
|
|
// Default writeFileSync: Do nothing, just allow calls
|
|
mockWriteFileSync.mockImplementation(() => {});
|
|
});
|
|
|
|
// --- Validation Functions ---
|
|
describe('Validation Functions', () => {
|
|
// Tests for validateProvider and validateProviderModelCombination
|
|
test('validateProvider should return true for valid providers', () => {
|
|
expect(configManager.validateProvider('openai')).toBe(true);
|
|
expect(configManager.validateProvider('anthropic')).toBe(true);
|
|
expect(configManager.validateProvider('google')).toBe(true);
|
|
expect(configManager.validateProvider('perplexity')).toBe(true);
|
|
expect(configManager.validateProvider('ollama')).toBe(true);
|
|
expect(configManager.validateProvider('openrouter')).toBe(true);
|
|
});
|
|
|
|
test('validateProvider should return false for invalid providers', () => {
|
|
expect(configManager.validateProvider('invalid-provider')).toBe(false);
|
|
expect(configManager.validateProvider('grok')).toBe(false); // Not in mock map
|
|
expect(configManager.validateProvider('')).toBe(false);
|
|
expect(configManager.validateProvider(null)).toBe(false);
|
|
});
|
|
|
|
test('validateProviderModelCombination should validate known good combinations', () => {
|
|
// Re-load config to ensure MODEL_MAP is populated from mock (now real data)
|
|
configManager.getConfig(MOCK_PROJECT_ROOT, true);
|
|
expect(
|
|
configManager.validateProviderModelCombination('openai', 'gpt-4o')
|
|
).toBe(true);
|
|
expect(
|
|
configManager.validateProviderModelCombination(
|
|
'anthropic',
|
|
'claude-3-5-sonnet-20241022'
|
|
)
|
|
).toBe(true);
|
|
});
|
|
|
|
test('validateProviderModelCombination should return false for known bad combinations', () => {
|
|
// Re-load config to ensure MODEL_MAP is populated from mock (now real data)
|
|
configManager.getConfig(MOCK_PROJECT_ROOT, true);
|
|
expect(
|
|
configManager.validateProviderModelCombination(
|
|
'openai',
|
|
'claude-3-opus-20240229'
|
|
)
|
|
).toBe(false);
|
|
});
|
|
|
|
test('validateProviderModelCombination should return true for ollama/openrouter (empty lists in map)', () => {
|
|
// Re-load config to ensure MODEL_MAP is populated from mock (now real data)
|
|
configManager.getConfig(MOCK_PROJECT_ROOT, true);
|
|
expect(
|
|
configManager.validateProviderModelCombination('ollama', 'any-model')
|
|
).toBe(false);
|
|
expect(
|
|
configManager.validateProviderModelCombination(
|
|
'openrouter',
|
|
'any/model'
|
|
)
|
|
).toBe(false);
|
|
});
|
|
|
|
test('validateProviderModelCombination should return true for providers not in map', () => {
|
|
// Re-load config to ensure MODEL_MAP is populated from mock (now real data)
|
|
configManager.getConfig(MOCK_PROJECT_ROOT, true);
|
|
// The implementation returns true if the provider isn't in the map
|
|
expect(
|
|
configManager.validateProviderModelCombination(
|
|
'unknown-provider',
|
|
'some-model'
|
|
)
|
|
).toBe(true);
|
|
});
|
|
});
|
|
|
|
// --- getConfig Tests ---
|
|
describe('getConfig Tests', () => {
|
|
test('should return default config if .taskmasterconfig does not exist', () => {
|
|
// Arrange
|
|
mockExistsSync.mockReturnValue(false);
|
|
// findProjectRoot mock is set in beforeEach
|
|
|
|
// Act: Call getConfig with explicit root
|
|
const config = configManager.getConfig(MOCK_PROJECT_ROOT, true); // Force reload
|
|
|
|
// Assert
|
|
expect(config).toEqual(DEFAULT_CONFIG);
|
|
expect(mockFindProjectRoot).not.toHaveBeenCalled(); // Explicit root provided
|
|
expect(mockExistsSync).toHaveBeenCalledWith(MOCK_CONFIG_PATH);
|
|
expect(mockReadFileSync).not.toHaveBeenCalled(); // No read if file doesn't exist
|
|
expect(consoleWarnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining('not found at provided project root')
|
|
);
|
|
});
|
|
|
|
test.skip('should use findProjectRoot and return defaults if file not found', () => {
|
|
// TODO: Fix mock interaction, findProjectRoot isn't being registered as called
|
|
// Arrange
|
|
mockExistsSync.mockReturnValue(false);
|
|
// findProjectRoot mock is set in beforeEach
|
|
|
|
// Act: Call getConfig without explicit root
|
|
const config = configManager.getConfig(null, true); // Force reload
|
|
|
|
// Assert
|
|
expect(mockFindProjectRoot).toHaveBeenCalled(); // Should be called now
|
|
expect(mockExistsSync).toHaveBeenCalledWith(MOCK_CONFIG_PATH);
|
|
expect(config).toEqual(DEFAULT_CONFIG);
|
|
expect(mockReadFileSync).not.toHaveBeenCalled();
|
|
expect(consoleWarnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining('not found at derived root')
|
|
); // Adjusted expected warning
|
|
});
|
|
|
|
test('should read and merge valid config file with defaults', () => {
|
|
// Arrange: Override readFileSync for this test
|
|
mockReadFileSync.mockImplementation((filePath) => {
|
|
if (filePath === MOCK_CONFIG_PATH)
|
|
return JSON.stringify(VALID_CUSTOM_CONFIG);
|
|
if (path.basename(filePath) === 'supported-models.json') {
|
|
// Provide necessary models for validation within getConfig
|
|
return JSON.stringify({
|
|
openai: [{ id: 'gpt-4o' }],
|
|
google: [{ id: 'gemini-1.5-pro-latest' }],
|
|
perplexity: [{ id: 'sonar-pro' }],
|
|
anthropic: [
|
|
{ id: 'claude-3-opus-20240229' },
|
|
{ id: 'claude-3-5-sonnet' },
|
|
{ id: 'claude-3-7-sonnet-20250219' },
|
|
{ id: 'claude-3-5-sonnet' }
|
|
],
|
|
ollama: [],
|
|
openrouter: []
|
|
});
|
|
}
|
|
throw new Error(`Unexpected fs.readFileSync call: ${filePath}`);
|
|
});
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
|
|
// Act
|
|
const config = configManager.getConfig(MOCK_PROJECT_ROOT, true); // Force reload
|
|
|
|
// Assert: Construct expected merged config
|
|
const expectedMergedConfig = {
|
|
models: {
|
|
main: {
|
|
...DEFAULT_CONFIG.models.main,
|
|
...VALID_CUSTOM_CONFIG.models.main
|
|
},
|
|
research: {
|
|
...DEFAULT_CONFIG.models.research,
|
|
...VALID_CUSTOM_CONFIG.models.research
|
|
},
|
|
fallback: {
|
|
...DEFAULT_CONFIG.models.fallback,
|
|
...VALID_CUSTOM_CONFIG.models.fallback
|
|
}
|
|
},
|
|
global: { ...DEFAULT_CONFIG.global, ...VALID_CUSTOM_CONFIG.global }
|
|
};
|
|
expect(config).toEqual(expectedMergedConfig);
|
|
expect(mockExistsSync).toHaveBeenCalledWith(MOCK_CONFIG_PATH);
|
|
expect(mockReadFileSync).toHaveBeenCalledWith(MOCK_CONFIG_PATH, 'utf-8');
|
|
});
|
|
|
|
test('should merge defaults for partial config file', () => {
|
|
// Arrange
|
|
mockReadFileSync.mockImplementation((filePath) => {
|
|
if (filePath === MOCK_CONFIG_PATH)
|
|
return JSON.stringify(PARTIAL_CONFIG);
|
|
if (path.basename(filePath) === 'supported-models.json') {
|
|
return JSON.stringify({
|
|
openai: [{ id: 'gpt-4-turbo' }],
|
|
perplexity: [{ id: 'sonar-pro' }],
|
|
anthropic: [
|
|
{ id: 'claude-3-7-sonnet-20250219' },
|
|
{ id: 'claude-3-5-sonnet' }
|
|
],
|
|
ollama: [],
|
|
openrouter: []
|
|
});
|
|
}
|
|
throw new Error(`Unexpected fs.readFileSync call: ${filePath}`);
|
|
});
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
|
|
// Act
|
|
const config = configManager.getConfig(MOCK_PROJECT_ROOT, true);
|
|
|
|
// Assert: Construct expected merged config
|
|
const expectedMergedConfig = {
|
|
models: {
|
|
main: {
|
|
...DEFAULT_CONFIG.models.main,
|
|
...PARTIAL_CONFIG.models.main
|
|
},
|
|
research: { ...DEFAULT_CONFIG.models.research },
|
|
fallback: { ...DEFAULT_CONFIG.models.fallback }
|
|
},
|
|
global: { ...DEFAULT_CONFIG.global, ...PARTIAL_CONFIG.global }
|
|
};
|
|
expect(config).toEqual(expectedMergedConfig);
|
|
expect(mockReadFileSync).toHaveBeenCalledWith(MOCK_CONFIG_PATH, 'utf-8');
|
|
});
|
|
|
|
test('should handle JSON parsing error and return defaults', () => {
|
|
// Arrange
|
|
mockReadFileSync.mockImplementation((filePath) => {
|
|
if (filePath === MOCK_CONFIG_PATH) return 'invalid json';
|
|
// Mock models read needed for initial load before parse error
|
|
if (path.basename(filePath) === 'supported-models.json') {
|
|
return JSON.stringify({
|
|
anthropic: [{ id: 'claude-3-7-sonnet-20250219' }],
|
|
perplexity: [{ id: 'sonar-pro' }],
|
|
fallback: [{ id: 'claude-3-5-sonnet' }],
|
|
ollama: [],
|
|
openrouter: []
|
|
});
|
|
}
|
|
throw new Error(`Unexpected fs.readFileSync call: ${filePath}`);
|
|
});
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
|
|
// Act
|
|
const config = configManager.getConfig(MOCK_PROJECT_ROOT, true);
|
|
|
|
// Assert
|
|
expect(config).toEqual(DEFAULT_CONFIG);
|
|
expect(consoleErrorSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining('Error reading or parsing')
|
|
);
|
|
});
|
|
|
|
test('should handle file read error and return defaults', () => {
|
|
// Arrange
|
|
const readError = new Error('Permission denied');
|
|
mockReadFileSync.mockImplementation((filePath) => {
|
|
if (filePath === MOCK_CONFIG_PATH) throw readError;
|
|
// Mock models read needed for initial load before read error
|
|
if (path.basename(filePath) === 'supported-models.json') {
|
|
return JSON.stringify({
|
|
anthropic: [{ id: 'claude-3-7-sonnet-20250219' }],
|
|
perplexity: [{ id: 'sonar-pro' }],
|
|
fallback: [{ id: 'claude-3-5-sonnet' }],
|
|
ollama: [],
|
|
openrouter: []
|
|
});
|
|
}
|
|
throw new Error(`Unexpected fs.readFileSync call: ${filePath}`);
|
|
});
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
|
|
// Act
|
|
const config = configManager.getConfig(MOCK_PROJECT_ROOT, true);
|
|
|
|
// Assert
|
|
expect(config).toEqual(DEFAULT_CONFIG);
|
|
expect(consoleErrorSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining(
|
|
`Permission denied. Using default configuration.`
|
|
)
|
|
);
|
|
});
|
|
|
|
test('should validate provider and fallback to default if invalid', () => {
|
|
// Arrange
|
|
mockReadFileSync.mockImplementation((filePath) => {
|
|
if (filePath === MOCK_CONFIG_PATH)
|
|
return JSON.stringify(INVALID_PROVIDER_CONFIG);
|
|
if (path.basename(filePath) === 'supported-models.json') {
|
|
return JSON.stringify({
|
|
perplexity: [{ id: 'llama-3-sonar-large-32k-online' }],
|
|
anthropic: [
|
|
{ id: 'claude-3-7-sonnet-20250219' },
|
|
{ id: 'claude-3-5-sonnet' }
|
|
],
|
|
ollama: [],
|
|
openrouter: []
|
|
});
|
|
}
|
|
throw new Error(`Unexpected fs.readFileSync call: ${filePath}`);
|
|
});
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
|
|
// Act
|
|
const config = configManager.getConfig(MOCK_PROJECT_ROOT, true);
|
|
|
|
// Assert
|
|
expect(consoleWarnSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining(
|
|
'Warning: Invalid main provider "invalid-provider"'
|
|
)
|
|
);
|
|
const expectedMergedConfig = {
|
|
models: {
|
|
main: { ...DEFAULT_CONFIG.models.main },
|
|
research: {
|
|
...DEFAULT_CONFIG.models.research,
|
|
...INVALID_PROVIDER_CONFIG.models.research
|
|
},
|
|
fallback: { ...DEFAULT_CONFIG.models.fallback }
|
|
},
|
|
global: { ...DEFAULT_CONFIG.global, ...INVALID_PROVIDER_CONFIG.global }
|
|
};
|
|
expect(config).toEqual(expectedMergedConfig);
|
|
});
|
|
});
|
|
|
|
// --- writeConfig Tests ---
|
|
describe('writeConfig', () => {
|
|
test('should write valid config to file', () => {
|
|
// Arrange (Default mocks are sufficient)
|
|
// findProjectRoot mock set in beforeEach
|
|
mockWriteFileSync.mockImplementation(() => {}); // Ensure it doesn't throw
|
|
|
|
// Act
|
|
const success = configManager.writeConfig(
|
|
VALID_CUSTOM_CONFIG,
|
|
MOCK_PROJECT_ROOT
|
|
);
|
|
|
|
// Assert
|
|
expect(success).toBe(true);
|
|
expect(mockWriteFileSync).toHaveBeenCalledWith(
|
|
MOCK_CONFIG_PATH,
|
|
JSON.stringify(VALID_CUSTOM_CONFIG, null, 2) // writeConfig stringifies
|
|
);
|
|
expect(consoleErrorSpy).not.toHaveBeenCalled();
|
|
});
|
|
|
|
test('should return false and log error if write fails', () => {
|
|
// Arrange
|
|
const mockWriteError = new Error('Disk full');
|
|
mockWriteFileSync.mockImplementation(() => {
|
|
throw mockWriteError;
|
|
});
|
|
// findProjectRoot mock set in beforeEach
|
|
|
|
// Act
|
|
const success = configManager.writeConfig(
|
|
VALID_CUSTOM_CONFIG,
|
|
MOCK_PROJECT_ROOT
|
|
);
|
|
|
|
// Assert
|
|
expect(success).toBe(false);
|
|
expect(mockWriteFileSync).toHaveBeenCalled();
|
|
expect(consoleErrorSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining(`Disk full`)
|
|
);
|
|
});
|
|
|
|
test.skip('should return false if project root cannot be determined', () => {
|
|
// TODO: Fix mock interaction or function logic, returns true unexpectedly in test
|
|
// Arrange: Override mock for this specific test
|
|
mockFindProjectRoot.mockReturnValue(null);
|
|
|
|
// Act: Call without explicit root
|
|
const success = configManager.writeConfig(VALID_CUSTOM_CONFIG);
|
|
|
|
// Assert
|
|
expect(success).toBe(false); // Function should return false if root is null
|
|
expect(mockFindProjectRoot).toHaveBeenCalled();
|
|
expect(mockWriteFileSync).not.toHaveBeenCalled();
|
|
expect(consoleErrorSpy).toHaveBeenCalledWith(
|
|
expect.stringContaining('Could not determine project root')
|
|
);
|
|
});
|
|
});
|
|
|
|
// --- Getter Functions ---
|
|
describe('Getter Functions', () => {
|
|
test('getMainProvider should return provider from config', () => {
|
|
// Arrange: Set up readFileSync to return VALID_CUSTOM_CONFIG
|
|
mockReadFileSync.mockImplementation((filePath) => {
|
|
if (filePath === MOCK_CONFIG_PATH)
|
|
return JSON.stringify(VALID_CUSTOM_CONFIG);
|
|
if (path.basename(filePath) === 'supported-models.json') {
|
|
return JSON.stringify({
|
|
openai: [{ id: 'gpt-4o' }],
|
|
google: [{ id: 'gemini-1.5-pro-latest' }],
|
|
anthropic: [
|
|
{ id: 'claude-3-opus-20240229' },
|
|
{ id: 'claude-3-7-sonnet-20250219' },
|
|
{ id: 'claude-3-5-sonnet' }
|
|
],
|
|
perplexity: [{ id: 'sonar-pro' }],
|
|
ollama: [],
|
|
openrouter: []
|
|
}); // Added perplexity
|
|
}
|
|
throw new Error(`Unexpected fs.readFileSync call: ${filePath}`);
|
|
});
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
|
|
// Act
|
|
const provider = configManager.getMainProvider(MOCK_PROJECT_ROOT);
|
|
|
|
// Assert
|
|
expect(provider).toBe(VALID_CUSTOM_CONFIG.models.main.provider);
|
|
});
|
|
|
|
test('getLogLevel should return logLevel from config', () => {
|
|
// Arrange: Set up readFileSync to return VALID_CUSTOM_CONFIG
|
|
mockReadFileSync.mockImplementation((filePath) => {
|
|
if (filePath === MOCK_CONFIG_PATH)
|
|
return JSON.stringify(VALID_CUSTOM_CONFIG);
|
|
if (path.basename(filePath) === 'supported-models.json') {
|
|
// Provide enough mock model data for validation within getConfig
|
|
return JSON.stringify({
|
|
openai: [{ id: 'gpt-4o' }],
|
|
google: [{ id: 'gemini-1.5-pro-latest' }],
|
|
anthropic: [
|
|
{ id: 'claude-3-opus-20240229' },
|
|
{ id: 'claude-3-7-sonnet-20250219' },
|
|
{ id: 'claude-3-5-sonnet' }
|
|
],
|
|
perplexity: [{ id: 'sonar-pro' }],
|
|
ollama: [],
|
|
openrouter: []
|
|
});
|
|
}
|
|
throw new Error(`Unexpected fs.readFileSync call: ${filePath}`);
|
|
});
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
|
|
// Act
|
|
const logLevel = configManager.getLogLevel(MOCK_PROJECT_ROOT);
|
|
|
|
// Assert
|
|
expect(logLevel).toBe(VALID_CUSTOM_CONFIG.global.logLevel);
|
|
});
|
|
|
|
// Add more tests for other getters (getResearchProvider, getProjectName, etc.)
|
|
});
|
|
|
|
// --- isConfigFilePresent Tests ---
|
|
describe('isConfigFilePresent', () => {
|
|
test('should return true if config file exists', () => {
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
expect(configManager.isConfigFilePresent(MOCK_PROJECT_ROOT)).toBe(true);
|
|
expect(mockExistsSync).toHaveBeenCalledWith(MOCK_CONFIG_PATH);
|
|
});
|
|
|
|
test('should return false if config file does not exist', () => {
|
|
mockExistsSync.mockReturnValue(false);
|
|
// findProjectRoot mock set in beforeEach
|
|
expect(configManager.isConfigFilePresent(MOCK_PROJECT_ROOT)).toBe(false);
|
|
expect(mockExistsSync).toHaveBeenCalledWith(MOCK_CONFIG_PATH);
|
|
});
|
|
|
|
test.skip('should use findProjectRoot if explicitRoot is not provided', () => {
|
|
// TODO: Fix mock interaction, findProjectRoot isn't being registered as called
|
|
mockExistsSync.mockReturnValue(true);
|
|
// findProjectRoot mock set in beforeEach
|
|
expect(configManager.isConfigFilePresent()).toBe(true);
|
|
expect(mockFindProjectRoot).toHaveBeenCalled(); // Should be called now
|
|
});
|
|
});
|
|
|
|
// --- getAllProviders Tests ---
|
|
describe('getAllProviders', () => {
|
|
test('should return list of providers from supported-models.json', () => {
|
|
// Arrange: Ensure config is loaded with real data
|
|
configManager.getConfig(null, true); // Force load using the mock that returns real data
|
|
|
|
// Act
|
|
const providers = configManager.getAllProviders();
|
|
// Assert
|
|
// Assert against the actual keys in the REAL loaded data
|
|
const expectedProviders = Object.keys(REAL_SUPPORTED_MODELS_DATA);
|
|
expect(providers).toEqual(expect.arrayContaining(expectedProviders));
|
|
expect(providers.length).toBe(expectedProviders.length);
|
|
});
|
|
});
|
|
|
|
// Add tests for getParametersForRole if needed
|
|
|
|
// Note: Tests for setMainModel, setResearchModel were removed as the functions were removed in the implementation.
|
|
// If similar setter functions exist, add tests for them following the writeConfig pattern.
|
|
|
|
// --- isApiKeySet Tests ---
|
|
describe('isApiKeySet', () => {
|
|
const mockSession = { env: {} }; // Mock session for MCP context
|
|
|
|
// Test cases: [providerName, envVarName, keyValue, expectedResult, testName]
|
|
const testCases = [
|
|
// Valid Keys
|
|
[
|
|
'anthropic',
|
|
'ANTHROPIC_API_KEY',
|
|
'sk-valid-key',
|
|
true,
|
|
'valid Anthropic key'
|
|
],
|
|
[
|
|
'openai',
|
|
'OPENAI_API_KEY',
|
|
'sk-another-valid-key',
|
|
true,
|
|
'valid OpenAI key'
|
|
],
|
|
[
|
|
'perplexity',
|
|
'PERPLEXITY_API_KEY',
|
|
'pplx-valid',
|
|
true,
|
|
'valid Perplexity key'
|
|
],
|
|
[
|
|
'google',
|
|
'GOOGLE_API_KEY',
|
|
'google-valid-key',
|
|
true,
|
|
'valid Google key'
|
|
],
|
|
[
|
|
'mistral',
|
|
'MISTRAL_API_KEY',
|
|
'mistral-valid-key',
|
|
true,
|
|
'valid Mistral key'
|
|
],
|
|
[
|
|
'openrouter',
|
|
'OPENROUTER_API_KEY',
|
|
'or-valid-key',
|
|
true,
|
|
'valid OpenRouter key'
|
|
],
|
|
['xai', 'XAI_API_KEY', 'xai-valid-key', true, 'valid XAI key'],
|
|
[
|
|
'azure',
|
|
'AZURE_OPENAI_API_KEY',
|
|
'azure-valid-key',
|
|
true,
|
|
'valid Azure key'
|
|
],
|
|
|
|
// Ollama (special case - no key needed)
|
|
[
|
|
'ollama',
|
|
'OLLAMA_API_KEY',
|
|
undefined,
|
|
true,
|
|
'Ollama provider (no key needed)'
|
|
], // OLLAMA_API_KEY might not be in keyMap
|
|
|
|
// Invalid / Missing Keys
|
|
[
|
|
'anthropic',
|
|
'ANTHROPIC_API_KEY',
|
|
undefined,
|
|
false,
|
|
'missing Anthropic key'
|
|
],
|
|
['anthropic', 'ANTHROPIC_API_KEY', null, false, 'null Anthropic key'],
|
|
['openai', 'OPENAI_API_KEY', '', false, 'empty OpenAI key'],
|
|
[
|
|
'perplexity',
|
|
'PERPLEXITY_API_KEY',
|
|
' ',
|
|
false,
|
|
'whitespace Perplexity key'
|
|
],
|
|
|
|
// Placeholder Keys
|
|
[
|
|
'google',
|
|
'GOOGLE_API_KEY',
|
|
'YOUR_GOOGLE_API_KEY_HERE',
|
|
false,
|
|
'placeholder Google key (YOUR_..._HERE)'
|
|
],
|
|
[
|
|
'mistral',
|
|
'MISTRAL_API_KEY',
|
|
'MISTRAL_KEY_HERE',
|
|
false,
|
|
'placeholder Mistral key (..._KEY_HERE)'
|
|
],
|
|
[
|
|
'openrouter',
|
|
'OPENROUTER_API_KEY',
|
|
'ENTER_OPENROUTER_KEY_HERE',
|
|
false,
|
|
'placeholder OpenRouter key (general ...KEY_HERE)'
|
|
],
|
|
|
|
// Unknown provider
|
|
['unknownprovider', 'UNKNOWN_KEY', 'any-key', false, 'unknown provider']
|
|
];
|
|
|
|
testCases.forEach(
|
|
([providerName, envVarName, keyValue, expectedResult, testName]) => {
|
|
test(`should return ${expectedResult} for ${testName} (CLI context)`, () => {
|
|
// CLI context (resolveEnvVariable uses process.env or .env via projectRoot)
|
|
mockResolveEnvVariable.mockImplementation((key) => {
|
|
return key === envVarName ? keyValue : undefined;
|
|
});
|
|
expect(
|
|
configManager.isApiKeySet(providerName, null, MOCK_PROJECT_ROOT)
|
|
).toBe(expectedResult);
|
|
if (providerName !== 'ollama' && providerName !== 'unknownprovider') {
|
|
// Ollama and unknown don't try to resolve
|
|
expect(mockResolveEnvVariable).toHaveBeenCalledWith(
|
|
envVarName,
|
|
null,
|
|
MOCK_PROJECT_ROOT
|
|
);
|
|
}
|
|
});
|
|
|
|
test(`should return ${expectedResult} for ${testName} (MCP context)`, () => {
|
|
// MCP context (resolveEnvVariable uses session.env)
|
|
const mcpSession = { env: { [envVarName]: keyValue } };
|
|
mockResolveEnvVariable.mockImplementation((key, sessionArg) => {
|
|
return sessionArg && sessionArg.env
|
|
? sessionArg.env[key]
|
|
: undefined;
|
|
});
|
|
expect(
|
|
configManager.isApiKeySet(providerName, mcpSession, null)
|
|
).toBe(expectedResult);
|
|
if (providerName !== 'ollama' && providerName !== 'unknownprovider') {
|
|
expect(mockResolveEnvVariable).toHaveBeenCalledWith(
|
|
envVarName,
|
|
mcpSession,
|
|
null
|
|
);
|
|
}
|
|
});
|
|
}
|
|
);
|
|
|
|
test('isApiKeySet should log a warning for an unknown provider', () => {
|
|
mockLog.mockClear(); // Clear previous log calls
|
|
configManager.isApiKeySet('nonexistentprovider');
|
|
expect(mockLog).toHaveBeenCalledWith(
|
|
'warn',
|
|
expect.stringContaining('Unknown provider name: nonexistentprovider')
|
|
);
|
|
});
|
|
|
|
test('isApiKeySet should handle provider names case-insensitively for keyMap lookup', () => {
|
|
mockResolveEnvVariable.mockReturnValue('a-valid-key');
|
|
expect(
|
|
configManager.isApiKeySet('Anthropic', null, MOCK_PROJECT_ROOT)
|
|
).toBe(true);
|
|
expect(mockResolveEnvVariable).toHaveBeenCalledWith(
|
|
'ANTHROPIC_API_KEY',
|
|
null,
|
|
MOCK_PROJECT_ROOT
|
|
);
|
|
|
|
mockResolveEnvVariable.mockReturnValue('another-valid-key');
|
|
expect(configManager.isApiKeySet('OPENAI', null, MOCK_PROJECT_ROOT)).toBe(
|
|
true
|
|
);
|
|
expect(mockResolveEnvVariable).toHaveBeenCalledWith(
|
|
'OPENAI_API_KEY',
|
|
null,
|
|
MOCK_PROJECT_ROOT
|
|
);
|
|
});
|
|
});
|
|
});
|