automaker/apps/server/tests/unit/providers/base-provider.test.ts

import { describe, it, expect } from 'vitest';
import { BaseProvider } from '@/providers/base-provider.js';
import type {
  ProviderConfig,
  ExecuteOptions,
  ProviderMessage,
  InstallationStatus,
  ModelDefinition,
} from '@automaker/types';

// Concrete implementation for testing the abstract class
class TestProvider extends BaseProvider {
  getName(): string {
    return 'test-provider';
  }

  async *executeQuery(_options: ExecuteOptions): AsyncGenerator<ProviderMessage> {
    yield { type: 'text', text: 'test response' };
  }

  async detectInstallation(): Promise<InstallationStatus> {
    return { installed: true };
  }

  getAvailableModels(): ModelDefinition[] {
    return [{ id: 'test-model-1', name: 'Test Model 1', description: 'A test model' }];
  }
}

describe('base-provider.ts', () => {
  describe('constructor', () => {
    it('should initialize with empty config when none provided', () => {
      const provider = new TestProvider();
      expect(provider.getConfig()).toEqual({});
    });

    it('should initialize with provided config', () => {
      const config: ProviderConfig = {
        apiKey: 'test-key',
        baseUrl: 'https://test.com',
      };
      const provider = new TestProvider(config);
      expect(provider.getConfig()).toEqual(config);
    });

    it('should call getName() during initialization', () => {
      const provider = new TestProvider();
      expect(provider.getName()).toBe('test-provider');
    });
  });

  describe('validateConfig', () => {
    it('should return valid when config exists', () => {
      const provider = new TestProvider({ apiKey: 'test' });
      const result = provider.validateConfig();

      expect(result.valid).toBe(true);
      expect(result.errors).toHaveLength(0);
      expect(result.warnings).toHaveLength(0);
    });

    it('should return invalid when config is undefined', () => {
      // Create provider without config
      const provider = new TestProvider();
      // Manually set config to undefined to test edge case
      (provider as any).config = undefined;

      const result = provider.validateConfig();

      expect(result.valid).toBe(false);
      expect(result.errors).toContain('Provider config is missing');
    });

    it('should return valid for empty config object', () => {
      const provider = new TestProvider({});
      const result = provider.validateConfig();

      expect(result.valid).toBe(true);
      expect(result.errors).toHaveLength(0);
    });

    it('should include warnings array in result', () => {
      const provider = new TestProvider();
      const result = provider.validateConfig();

      expect(result).toHaveProperty('warnings');
      expect(Array.isArray(result.warnings)).toBe(true);
    });
  });

  describe('supportsFeature', () => {
    it("should support 'tools' feature", () => {
      const provider = new TestProvider();
      expect(provider.supportsFeature('tools')).toBe(true);
    });

    it("should support 'text' feature", () => {
      const provider = new TestProvider();
      expect(provider.supportsFeature('text')).toBe(true);
    });

    it('should not support unknown features', () => {
      const provider = new TestProvider();
      expect(provider.supportsFeature('vision')).toBe(false);
      expect(provider.supportsFeature('mcp')).toBe(false);
      expect(provider.supportsFeature('unknown')).toBe(false);
    });

    it('should be case-sensitive', () => {
      const provider = new TestProvider();
      expect(provider.supportsFeature('TOOLS')).toBe(false);
      expect(provider.supportsFeature('Text')).toBe(false);
    });
  });

  describe('getConfig', () => {
    it('should return current config', () => {
      const config: ProviderConfig = {
        apiKey: 'test-key',
        model: 'test-model',
      };
      const provider = new TestProvider(config);

      expect(provider.getConfig()).toEqual(config);
    });

    it('should return same reference', () => {
      const config: ProviderConfig = { apiKey: 'test' };
      const provider = new TestProvider(config);

      const retrieved1 = provider.getConfig();
      const retrieved2 = provider.getConfig();

      expect(retrieved1).toBe(retrieved2);
    });
  });

  describe('setConfig', () => {
    it('should merge partial config with existing config', () => {
      const provider = new TestProvider({ apiKey: 'original-key' });

      provider.setConfig({ model: 'new-model' });

      expect(provider.getConfig()).toEqual({
        apiKey: 'original-key',
        model: 'new-model',
      });
    });

    it('should override existing fields', () => {
      const provider = new TestProvider({ apiKey: 'old-key', model: 'old-model' });

      provider.setConfig({ apiKey: 'new-key' });

      expect(provider.getConfig()).toEqual({
        apiKey: 'new-key',
        model: 'old-model',
      });
    });

    it('should accept empty object', () => {
      const provider = new TestProvider({ apiKey: 'test' });
      const originalConfig = provider.getConfig();

      provider.setConfig({});

      expect(provider.getConfig()).toEqual(originalConfig);
    });

    it('should handle multiple updates', () => {
      const provider = new TestProvider();

      provider.setConfig({ apiKey: 'key1' });
      provider.setConfig({ model: 'model1' });
      provider.setConfig({ baseUrl: 'https://test.com' });

      expect(provider.getConfig()).toEqual({
        apiKey: 'key1',
        model: 'model1',
        baseUrl: 'https://test.com',
      });
    });

    it('should preserve other fields when updating one field', () => {
      const provider = new TestProvider({
        apiKey: 'key',
        model: 'model',
        baseUrl: 'https://test.com',
      });

      provider.setConfig({ model: 'new-model' });

      expect(provider.getConfig()).toEqual({
        apiKey: 'key',
        model: 'new-model',
        baseUrl: 'https://test.com',
      });
    });
  });

  describe('abstract methods', () => {
    it('should require getName implementation', () => {
      const provider = new TestProvider();
      expect(typeof provider.getName).toBe('function');
      expect(provider.getName()).toBe('test-provider');
    });

    it('should require executeQuery implementation', async () => {
      const provider = new TestProvider();
      expect(typeof provider.executeQuery).toBe('function');

      const generator = provider.executeQuery({
        prompt: 'test',
        projectDirectory: '/test',
      });
      const result = await generator.next();

      expect(result.value).toEqual({ type: 'text', text: 'test response' });
    });

    it('should require detectInstallation implementation', async () => {
      const provider = new TestProvider();
      expect(typeof provider.detectInstallation).toBe('function');

      const status = await provider.detectInstallation();
      expect(status).toHaveProperty('installed');
    });

    it('should require getAvailableModels implementation', () => {
      const provider = new TestProvider();
      expect(typeof provider.getAvailableModels).toBe('function');

      const models = provider.getAvailableModels();
      expect(Array.isArray(models)).toBe(true);
      expect(models.length).toBeGreaterThan(0);
    });
  });
});