fix remote test runs in github actions

Author: mrlynn

src/providers/OpenAIEmbeddingProvider.js

@@ -1,3 +1,4 @@
+// src/providers/OpenAIEmbeddingProvider.js
 import BaseEmbeddingProvider from './BaseEmbeddingProvider.js';
 import axios from 'axios';
 import debug from 'debug';
@@ -14,6 +15,8 @@ class OpenAIEmbeddingProvider extends BaseEmbeddingProvider {
 
     this.apiKey = options.apiKey;
     this.model = options.model || 'text-embedding-3-small';
+    
+    // Create axios instance with default config
     this.client = axios.create({
       baseURL: 'https://api.openai.com/v1',
       headers: {
@@ -34,12 +37,15 @@ class OpenAIEmbeddingProvider extends BaseEmbeddingProvider {
         input: texts
       });
 
+      if (!response.data || !response.data.data) {
+        throw new Error('Unexpected response format from OpenAI API');
+      }
+
       const embeddings = response.data.data.map(item => item.embedding);
-      
       log(`Successfully got embeddings for batch`);
       return embeddings;
     } catch (error) {
-      if (error.response?.data) {
+      if (error.response?.data?.error) {
         throw new Error(`OpenAI API error: ${error.response.data.error.message}`);
       }
       throw error;

src/providers/providers.test.js

@@ -2,32 +2,49 @@
 import { jest, describe, expect, test, beforeEach } from '@jest/globals';
 import OpenAIEmbeddingProvider from '../../src/providers/OpenAIEmbeddingProvider.js';
 
-// Mock axios
-await jest.unstable_mockModule('axios', () => ({
-  default: {
-    create: jest.fn(() => ({
-      post: jest.fn().mockResolvedValue({
-        data: {
-          data: [{ embedding: Array(1536).fill(0.1) }]
+// Mock the axios module
+jest.mock('axios', () => {
+  const mockPost = jest.fn().mockResolvedValue({
+    data: {
+      data: [{ embedding: Array(1536).fill(0.1) }]
+    }
+  });
+
+  return {
+    default: {
+      create: jest.fn(() => ({
+        post: mockPost,
+        defaults: {
+          headers: {
+            common: {}
+          }
         }
-      })
-    }))
-  }
-}));
+      }))
+    }
+  };
+});
+
+// Import axios after mocking
+import axios from 'axios';
 
 describe('Embedding Providers', () => {
   let provider;
   const mockApiKey = 'test-key-123';
+  let mockAxiosPost;
 
   beforeEach(() => {
-    // Reset mocks
+    // Clear all mocks
     jest.clearAllMocks();
 
+    // Create new provider instance
     provider = new OpenAIEmbeddingProvider({
       apiKey: mockApiKey,
       model: 'text-embedding-3-small',
       dimensions: 1536
     });
+
+    // Get reference to the mock post function
+    mockAxiosPost = axios.create().post;
   });
 
   test('should initialize with proper configuration', () => {
@@ -36,9 +53,21 @@ describe('Embedding Providers', () => {
   });
 
   test('should get embeddings from the OpenAI provider', async () => {
+    // Set up mock response for single text
+    mockAxiosPost.mockResolvedValueOnce({
+      data: {
+        data: [{ embedding: Array(1536).fill(0.1) }]
+      }
+    });
+
     const texts = ['test text'];
     const result = await provider.getEmbeddings(texts);
 
+    expect(mockAxiosPost).toHaveBeenCalledWith('/embeddings', {
+      model: 'text-embedding-3-small',
+      input: texts
+    });
+    
     expect(result).toHaveLength(1);
     expect(result[0]).toHaveLength(1536);
     expect(typeof result[0][0]).toBe('number');
@@ -49,23 +78,72 @@ describe('Embedding Providers', () => {
   test('should handle empty input', async () => {
     const result = await provider.getEmbeddings([]);
     expect(result).toHaveLength(0);
+    expect(mockAxiosPost).not.toHaveBeenCalled();
   });
 
   test('should handle batch processing', async () => {
+    // Set up mock response for batch
+    mockAxiosPost.mockResolvedValueOnce({
+      data: {
+        data: Array(5).fill({ embedding: Array(1536).fill(0.1) })
+      }
+    });
+
     const texts = Array(5).fill('test text');
     const result = await provider.getEmbeddings(texts);
+    
+    expect(mockAxiosPost).toHaveBeenCalledWith('/embeddings', {
+      model: 'text-embedding-3-small',
+      input: texts
+    });
+    
     expect(result).toHaveLength(5);
     expect(result[0]).toHaveLength(1536);
   });
 
   test('should respect batch size limits', async () => {
-    const provider = new OpenAIEmbeddingProvider({
+    // Create provider with small batch size
+    const smallBatchProvider = new OpenAIEmbeddingProvider({
       apiKey: mockApiKey,
       batchSize: 2
     });
 
+    // Set up mock responses for each batch
+    mockAxiosPost
+      .mockResolvedValueOnce({
+        data: {
+          data: Array(2).fill({ embedding: Array(1536).fill(0.1) })
+        }
+      })
+      .mockResolvedValueOnce({
+        data: {
+          data: Array(2).fill({ embedding: Array(1536).fill(0.1) })
+        }
+      })
+      .mockResolvedValueOnce({
+        data: {
+          data: Array(1).fill({ embedding: Array(1536).fill(0.1) })
+        }
+      });
+
     const texts = Array(5).fill('test text');
-    const result = await provider.getEmbeddings(texts);
+    const result = await smallBatchProvider.getEmbeddings(texts);
+    
     expect(result).toHaveLength(5);
+    expect(mockAxiosPost).toHaveBeenCalledTimes(3); // Should be called three times for batches of 2,2,1
+  });
+
+  test('should handle API errors', async () => {
+    mockAxiosPost.mockRejectedValueOnce({
+      response: {
+        data: {
+          error: {
+            message: 'Test API error'
+          }
+        }
+      }
+    });
+
+    await expect(provider.getEmbeddings(['test'])).rejects.toThrow('Test API error');
   });
 });