@robhowley/pi-openrouter 0.9.0 → 0.10.0

package/extensions/openrouter/__tests__/client.test.ts

@@ -1,5 +1,15 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { fetchUserModels, isConfigured, getApiKey, ApiError, AuthError } from '../client.js';
+import {
+  fetchUserModels,
+  isConfigured,
+  getApiKey,
+  getModelSyncApiKey,
+  getUsageApiKey,
+  isConfiguredForModelSync,
+  isConfiguredForUsage,
+  ApiError,
+  AuthError,
+} from '../client.js';
 import { restoreEnv } from './fixtures.js';
 import type { Mock } from 'vitest';
 
@@ -8,14 +18,31 @@ vi.mock('@openrouter/sdk/sdk/sdk.js', () => ({
   OpenRouter: vi.fn(),
 }));
 
+/**
+ * Helper to set or clear OPENROUTER_API_KEY and OPENROUTER_MANAGEMENT_KEY.
+ * Pass undefined to delete the env var.
+ */
+function setKeys(apiKey?: string, mgmtKey?: string) {
+  if (apiKey === undefined) {
+    delete process.env['OPENROUTER_API_KEY'];
+  } else {
+    process.env['OPENROUTER_API_KEY'] = apiKey;
+  }
+  if (mgmtKey === undefined) {
+    delete process.env['OPENROUTER_MANAGEMENT_KEY'];
+  } else {
+    process.env['OPENROUTER_MANAGEMENT_KEY'] = mgmtKey;
+  }
+}
+
 /**
  * Factory function to create a minimal mock SDK client.
  * Reduces boilerplate from ~25 lines to 1 line per test.
  */
-function createMockSDKClient(overrides: { listForUser?: Mock } = {}) {
+function createMockSDKClient(overrides: { listForUser?: Mock; getCredits?: Mock } = {}) {
   return {
     models: { listForUser: overrides.listForUser ?? vi.fn() },
-    credits: {},
+    credits: { getCredits: overrides.getCredits ?? vi.fn() },
     analytics: {},
     chat: {},
     embeddings: {},
@@ -46,14 +73,14 @@ describe('fetchUserModels', () => {
   });
 
   it('should throw AuthError when API key not set', async () => {
-    delete process.env['OPENROUTER_API_KEY'];
+    setKeys(undefined, undefined);
 
-    await expect(fetchUserModels()).rejects.toThrow('OPENROUTER_API_KEY not set');
+    await expect(fetchUserModels()).rejects.toThrow('OpenRouter API key not configured');
     await expect(fetchUserModels()).rejects.toBeInstanceOf(AuthError);
   });
 
   it('should fetch models with SDK', async () => {
-    process.env['OPENROUTER_API_KEY'] = 'test-key';
+    setKeys('test-key', undefined);
 
     const mockResponse = {
       data: [
@@ -81,7 +108,7 @@ describe('fetchUserModels', () => {
   });
 
   it('should throw ApiError on 401 unauthorized', async () => {
-    process.env['OPENROUTER_API_KEY'] = 'invalid-key';
+    setKeys('invalid-key', undefined);
 
     const MockOpenRouter = vi.mocked((await import('@openrouter/sdk/sdk/sdk.js')).OpenRouter);
     const mockClient = createMockSDKClient({
@@ -96,7 +123,7 @@ describe('fetchUserModels', () => {
   });
 
   it('should throw ApiError on rate limit (429)', async () => {
-    process.env['OPENROUTER_API_KEY'] = 'test-key';
+    setKeys('test-key', undefined);
 
     const MockOpenRouter = vi.mocked((await import('@openrouter/sdk/sdk/sdk.js')).OpenRouter);
     const mockClient = createMockSDKClient({
@@ -111,7 +138,7 @@ describe('fetchUserModels', () => {
   });
 
   it('should throw ApiError on server error', async () => {
-    process.env['OPENROUTER_API_KEY'] = 'test-key';
+    setKeys('test-key', undefined);
 
     const MockOpenRouter = vi.mocked((await import('@openrouter/sdk/sdk/sdk.js')).OpenRouter);
     const mockClient = createMockSDKClient({
@@ -132,17 +159,17 @@ describe('isConfigured', () => {
   });
 
   it('should return true when API key is set', () => {
-    process.env['OPENROUTER_API_KEY'] = 'test-key';
+    setKeys('test-key', undefined);
     expect(isConfigured()).toBe(true);
   });
 
   it('should return false when API key is not set', () => {
-    delete process.env['OPENROUTER_API_KEY'];
+    setKeys(undefined, undefined);
     expect(isConfigured()).toBe(false);
   });
 
   it('should return false when API key is empty string', () => {
-    process.env['OPENROUTER_API_KEY'] = '';
+    setKeys('', undefined);
     expect(isConfigured()).toBe(false);
   });
 });
@@ -153,17 +180,308 @@ describe('getApiKey', () => {
   });
 
   it('should return the API key when set', () => {
-    process.env['OPENROUTER_API_KEY'] = 'test-key';
+    setKeys('test-key', undefined);
     expect(getApiKey()).toBe('test-key');
   });
 
   it('should return undefined when API key is not set', () => {
-    delete process.env['OPENROUTER_API_KEY'];
+    setKeys(undefined, undefined);
     expect(getApiKey()).toBeUndefined();
   });
 
   it('should return empty string when API key is empty', () => {
-    process.env['OPENROUTER_API_KEY'] = '';
+    setKeys('', undefined);
     expect(getApiKey()).toBe('');
   });
 });
+
+// Phase 1 regression tests
+describe('getModelSyncApiKey', () => {
+  beforeEach(() => {
+    restoreEnv();
+  });
+
+  it.each([
+    {
+      apiKey: 'api-key',
+      mgmtKey: 'mgmt-key',
+      expected: 'api-key',
+      desc: 'should return OPENROUTER_API_KEY when both keys are present',
+    },
+    {
+      apiKey: undefined,
+      mgmtKey: 'mgmt-key',
+      expected: 'mgmt-key',
+      desc: 'should return OPENROUTER_MANAGEMENT_KEY when only management key is present',
+    },
+    {
+      apiKey: undefined,
+      mgmtKey: undefined,
+      expected: undefined,
+      desc: 'should return undefined when no keys are present',
+    },
+    {
+      apiKey: '',
+      mgmtKey: 'mgmt-key',
+      expected: 'mgmt-key',
+      desc: 'should treat empty strings as absent',
+    },
+    {
+      apiKey: '  ',
+      mgmtKey: 'mgmt-key',
+      expected: 'mgmt-key',
+      desc: 'should treat whitespace-only strings as absent',
+    },
+  ])('$desc', ({ apiKey, mgmtKey, expected }) => {
+    setKeys(apiKey, mgmtKey);
+    expect(getModelSyncApiKey()).toBe(expected);
+  });
+});
+
+describe('getUsageApiKey', () => {
+  beforeEach(() => {
+    restoreEnv();
+  });
+
+  it.each([
+    {
+      apiKey: 'api-key',
+      mgmtKey: 'mgmt-key',
+      expected: 'mgmt-key',
+      desc: 'should return OPENROUTER_MANAGEMENT_KEY when both keys are present',
+    },
+    {
+      apiKey: 'api-key',
+      mgmtKey: undefined,
+      expected: 'api-key',
+      desc: 'should return OPENROUTER_API_KEY when only API key is present',
+    },
+    {
+      apiKey: undefined,
+      mgmtKey: undefined,
+      expected: undefined,
+      desc: 'should return undefined when no keys are present',
+    },
+    {
+      apiKey: 'api-key',
+      mgmtKey: '',
+      expected: 'api-key',
+      desc: 'should treat empty strings as absent',
+    },
+    {
+      apiKey: '  ',
+      mgmtKey: 'mgmt-key',
+      expected: 'mgmt-key',
+      desc: 'should treat whitespace-only strings as absent',
+    },
+  ])('$desc', ({ apiKey, mgmtKey, expected }) => {
+    setKeys(apiKey, mgmtKey);
+    expect(getUsageApiKey()).toBe(expected);
+  });
+});
+
+describe('isConfiguredForModelSync', () => {
+  beforeEach(() => {
+    restoreEnv();
+  });
+
+  it.each([
+    {
+      apiKey: 'api-key',
+      mgmtKey: undefined,
+      expected: true,
+      desc: 'should return true when API key is set',
+    },
+    {
+      apiKey: undefined,
+      mgmtKey: 'mgmt-key',
+      expected: true,
+      desc: 'should return true when management key is set',
+    },
+    {
+      apiKey: undefined,
+      mgmtKey: undefined,
+      expected: false,
+      desc: 'should return false when no keys are set',
+    },
+  ])('$desc', ({ apiKey, mgmtKey, expected }) => {
+    setKeys(apiKey, mgmtKey);
+    expect(isConfiguredForModelSync()).toBe(expected);
+  });
+});
+
+describe('isConfiguredForUsage', () => {
+  beforeEach(() => {
+    restoreEnv();
+  });
+
+  it.each([
+    {
+      apiKey: undefined,
+      mgmtKey: 'mgmt-key',
+      expected: true,
+      desc: 'should return true when management key is set',
+    },
+    {
+      apiKey: 'api-key',
+      mgmtKey: undefined,
+      expected: true,
+      desc: 'should return true when API key is set',
+    },
+    {
+      apiKey: undefined,
+      mgmtKey: undefined,
+      expected: false,
+      desc: 'should return false when no keys are set',
+    },
+  ])('$desc', ({ apiKey, mgmtKey, expected }) => {
+    setKeys(apiKey, mgmtKey);
+    expect(isConfiguredForUsage()).toBe(expected);
+  });
+});
+
+describe('fetchUserModels with management key fallback', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    restoreEnv();
+  });
+
+  it('should accept OPENROUTER_MANAGEMENT_KEY when only management key is present', async () => {
+    setKeys(undefined, 'mgmt-key');
+
+    const mockResponse = {
+      data: [
+        {
+          id: 'openai/gpt-4',
+          name: 'GPT-4',
+          context_length: 8192,
+          pricing: { prompt: '0.00003', completion: '0.00006' },
+        },
+      ],
+    };
+
+    const MockOpenRouter = vi.mocked((await import('@openrouter/sdk/sdk/sdk.js')).OpenRouter);
+    const mockClient = createMockSDKClient({
+      listForUser: vi.fn().mockResolvedValue(mockResponse),
+    });
+    MockOpenRouter.mockImplementation(() => mockClient as any);
+
+    const result = await fetchUserModels();
+    expect(result!.data).toHaveLength(1);
+    expect(mockClient.models.listForUser).toHaveBeenCalled();
+    // Verify management key was used
+    expect(MockOpenRouter).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'mgmt-key' }));
+  });
+
+  it('should prefer OPENROUTER_API_KEY when both keys are present', async () => {
+    setKeys('api-key', 'mgmt-key');
+
+    const mockResponse = {
+      data: [
+        {
+          id: 'openai/gpt-4',
+          name: 'GPT-4',
+          context_length: 8192,
+          pricing: { prompt: '0.00003', completion: '0.00006' },
+        },
+      ],
+    };
+
+    const MockOpenRouter = vi.mocked((await import('@openrouter/sdk/sdk/sdk.js')).OpenRouter);
+    const mockClient = createMockSDKClient({
+      listForUser: vi.fn().mockResolvedValue(mockResponse),
+    });
+    MockOpenRouter.mockImplementation(() => mockClient as any);
+
+    await fetchUserModels();
+    // Verify that the OpenRouter client was constructed with the API key, not management key
+    expect(MockOpenRouter).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'api-key' }));
+  });
+});
+
+describe('getCredits with usage API key selection', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    restoreEnv();
+    vi.resetModules(); // Clear module cache including client instance
+  });
+
+  it('should use OPENROUTER_MANAGEMENT_KEY when both keys are present', async () => {
+    setKeys('api-key', 'mgmt-key');
+
+    const mockResponse = {
+      data: {
+        total_granted: 10.0,
+        total_used: 2.5,
+        total_available: 7.5,
+      },
+    };
+
+    const MockOpenRouter = vi.mocked((await import('@openrouter/sdk/sdk/sdk.js')).OpenRouter);
+    const mockClient = createMockSDKClient({
+      getCredits: vi.fn().mockResolvedValue(mockResponse),
+    });
+    MockOpenRouter.mockImplementation(() => mockClient as any);
+
+    const { getCredits } = await import('../client.js');
+    await getCredits();
+
+    // Verify management key was used (not API key)
+    expect(MockOpenRouter).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'mgmt-key' }));
+  });
+
+  it('should fall back to OPENROUTER_API_KEY when only API key is present', async () => {
+    setKeys('api-key', undefined);
+
+    const mockResponse = {
+      data: {
+        total_granted: 10.0,
+        total_used: 2.5,
+        total_available: 7.5,
+      },
+    };
+
+    const MockOpenRouter = vi.mocked((await import('@openrouter/sdk/sdk/sdk.js')).OpenRouter);
+    const mockClient = createMockSDKClient({
+      getCredits: vi.fn().mockResolvedValue(mockResponse),
+    });
+    MockOpenRouter.mockImplementation(() => mockClient as any);
+
+    const { getCredits } = await import('../client.js');
+    await getCredits();
+
+    expect(MockOpenRouter).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'api-key' }));
+  });
+
+  it('should fall back to API key when management key is whitespace', async () => {
+    setKeys('api-key', '  ');
+
+    const mockResponse = {
+      data: {
+        total_granted: 10.0,
+        total_used: 2.5,
+        total_available: 7.5,
+      },
+    };
+
+    const MockOpenRouter = vi.mocked((await import('@openrouter/sdk/sdk/sdk.js')).OpenRouter);
+    const mockClient = createMockSDKClient({
+      getCredits: vi.fn().mockResolvedValue(mockResponse),
+    });
+    MockOpenRouter.mockImplementation(() => mockClient as any);
+
+    const { getCredits } = await import('../client.js');
+    await getCredits();
+
+    // Should use API key since management key is whitespace-only
+    expect(MockOpenRouter).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'api-key' }));
+  });
+
+  it('should return null when no keys are configured', async () => {
+    setKeys(undefined, undefined);
+
+    const { getCredits } = await import('../client.js');
+    const result = await getCredits();
+    expect(result).toBeNull();
+  });
+});