review-copilot/dist/__tests__/provider-factory.test.js

ReviewCopilot - AI-powered code review assistant with customizable prompts

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const provider_factory_1 = require("../providers/provider-factory");
const deepseek_provider_1 = require("../providers/deepseek-provider");
const openai_1 = __importDefault(require("openai"));
const chalk_1 = __importDefault(require("chalk"));
// Mock chalk
jest.mock('chalk', () => ({
    blue: jest.fn((str) => str),
    green: jest.fn((str) => str),
    yellow: jest.fn((str) => str),
    red: jest.fn((str) => str),
    gray: jest.fn((str) => str),
}));
// Mock OpenAI client with a simpler implementation
jest.mock('openai', () => {
    return jest.fn().mockImplementation(() => ({}));
});
describe('ProviderFactory', () => {
    let provider;
    let mockOpenAI;
    let mockChalk;
    const mockConfig = {
        providers: {
            openai: {
                enabled: true,
                apiKey: 'test-key',
                model: 'gpt-4o-mini',
                baseURL: 'https://api.openai.com/v1',
                reviewLanguage: 'en',
            },
            deepseek: {
                enabled: false,
                apiKey: 'test-key-2',
                model: 'deepseek-chat',
                baseURL: 'https://api.deepseek.com/v1',
                reviewLanguage: 'en',
            },
        },
        triggers: [],
        rules: {
            commitMessage: {
                enabled: true,
                pattern: '',
                prompt: '',
            },
            branchName: {
                enabled: true,
                pattern: '',
                prompt: '',
            },
            codeChanges: {
                enabled: true,
                filePatterns: [],
                prompt: '',
            },
        },
        customReviewPoints: [],
    };
    beforeEach(() => {
        jest.clearAllMocks();
        mockOpenAI = openai_1.default;
        mockChalk = chalk_1.default;
    });
    afterEach(() => {
        if (provider) {
            // @ts-ignore - accessing private property for cleanup
            if (provider.client) {
                // @ts-ignore - accessing private property for cleanup
                provider.client = null;
            }
            provider = null;
        }
        jest.clearAllMocks();
    });
    afterAll(() => {
        jest.restoreAllMocks();
    });
    it('should create OpenAI provider when OpenAI is enabled', () => {
        provider = provider_factory_1.ProviderFactory.createProvider(mockConfig);
        expect(provider.constructor.name).toBe('OpenAIProvider');
        expect(mockOpenAI).toHaveBeenCalledWith({
            apiKey: mockConfig.providers.openai
                .apiKey,
            baseURL: mockConfig.providers.openai
                .baseURL,
            defaultHeaders: {
                'Content-Type': 'application/json',
            },
            timeout: 60000,
        });
        expect(mockChalk.blue).toHaveBeenCalled();
    });
    it('should create DeepSeek provider when DeepSeek is enabled', () => {
        const deepseekConfig = {
            ...mockConfig,
            providers: {
                openai: {
                    enabled: false,
                    apiKey: 'test-key',
                    model: 'gpt-4o-mini',
                    baseURL: 'https://api.openai.com/v1',
                    reviewLanguage: 'en',
                },
                deepseek: {
                    enabled: true,
                    apiKey: 'test-key-2',
                    model: 'deepseek-chat',
                    baseURL: 'https://api.deepseek.com/v1',
                    reviewLanguage: 'en',
                },
            },
        };
        const provider = provider_factory_1.ProviderFactory.createProvider(deepseekConfig);
        expect(provider).toBeInstanceOf(deepseek_provider_1.DeepSeekProvider);
    });
    it('should throw error when no provider is enabled', () => {
        const noProviderConfig = {
            ...mockConfig,
            providers: {
                openai: {
                    enabled: false,
                    apiKey: 'test-key',
                    model: 'gpt-4o-mini',
                    baseURL: 'https://api.openai.com/v1',
                    reviewLanguage: 'en',
                },
                deepseek: {
                    enabled: false,
                    apiKey: 'test-key-2',
                    model: 'deepseek-chat',
                    baseURL: 'https://api.deepseek.com/v1',
                    reviewLanguage: 'en',
                },
            },
        };
        expect(() => provider_factory_1.ProviderFactory.createProvider(noProviderConfig)).toThrow('No AI provider is enabled');
    });
    it('should throw error when multiple providers are enabled', () => {
        const multiProviderConfig = {
            ...mockConfig,
            providers: {
                openai: {
                    enabled: true,
                    apiKey: 'test-key',
                    model: 'gpt-4o-mini',
                    baseURL: 'https://api.openai.com/v1',
                    reviewLanguage: 'en',
                },
                deepseek: {
                    enabled: true,
                    apiKey: 'test-key-2',
                    model: 'deepseek-chat',
                    baseURL: 'https://api.deepseek.com/v1',
                    reviewLanguage: 'en',
                },
            },
        };
        expect(() => provider_factory_1.ProviderFactory.createProvider(multiProviderConfig)).toThrow('Multiple AI providers are enabled');
    });
    it('should validate provider configuration', () => {
        const invalidConfig = {
            ...mockConfig,
            providers: {
                openai: {
                    enabled: true,
                    apiKey: '',
                    model: 'gpt-4o-mini',
                    baseURL: 'https://api.openai.com/v1',
                    reviewLanguage: 'en',
                },
            },
        };
        expect(() => provider_factory_1.ProviderFactory.validateConfig(invalidConfig)).toThrow('Missing required fields');
    });
    it('should warn about non-standard baseURL', () => {
        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
        const nonStandardConfig = {
            ...mockConfig,
            providers: {
                openai: {
                    enabled: true,
                    apiKey: 'test-key',
                    model: 'gpt-4o-mini',
                    baseURL: 'https://api.example.com',
                    reviewLanguage: 'en',
                },
            },
        };
        provider_factory_1.ProviderFactory.validateConfig(nonStandardConfig);
        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("should typically end with '/v1'"));
        consoleSpy.mockRestore();
    });
});