fix remote test runs in github actions

Author: mrlynn

.github/workflows/test.yml

@@ -6,27 +6,14 @@ jobs:
   test:
     runs-on: ubuntu-latest
     env:
-      MONGODB_URI: ${{ secrets.MONGODB_URI }}
-      EMBEDDING_PROVIDER: ${{ secrets.EMBEDDING_PROVIDER }}
-      EMBEDDING_API_KEY: ${{ secrets.EMBEDDING_API_KEY }}
+      MONGODB_URI: mongodb://localhost:27017/test
+      EMBEDDING_PROVIDER: openai
+      EMBEDDING_API_KEY: test-key-123
+      NODE_ENV: test
     steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
         with:
           node-version: 18
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Debug Environment Variables
-        run: |
-          echo "Embedding Provider: $EMBEDDING_PROVIDER"
-          echo "API Key Length: ${#EMBEDDING_API_KEY}"
-        env:
-          EMBEDDING_API_KEY: ${{ secrets.EMBEDDING_API_KEY }}
-
-      - name: Run tests
-        run: npm test
+      - run: npm install
+      - run: npm test

src/providers/BaseEmbeddingProvider.js

@@ -1,3 +1,4 @@
+// src/providers/BaseEmbeddingProvider.js
 import debug from 'debug';
 
 const log = debug('mongodb-rag:embedding');
@@ -11,9 +12,13 @@ class BaseEmbeddingProvider {
       ...options
     };
 
+    if (!this.options.apiKey) {
+      throw new Error('API key is required');
+    }
+
     this.rateLimiter = {
       tokens: 60,
-      refillRate: 60, // tokens per minute
+      refillRate: 60,
       lastRefill: Date.now()
     };
   }
@@ -23,23 +28,35 @@ class BaseEmbeddingProvider {
       texts = [texts];
     }
 
+    if (texts.length === 0) {
+      return [];
+    }
+
     const batches = this._createBatches(texts);
     const results = [];
 
     for (const batch of batches) {
       await this._waitForRateLimit();
 
       let retries = 0;
+      let lastError = null;
+
       while (retries < this.options.maxRetries) {
         try {
           const embeddings = await this._embedBatch(batch);
           results.push(...embeddings);
           break;
         } catch (error) {
           retries++;
+          lastError = error;
+          
           if (retries === this.options.maxRetries) {
-            throw new Error(`Failed to get embeddings after ${retries} retries: ${error.message}`);
+            const errorMessage = `Failed to get embeddings after ${retries} retries`;
+            const details = lastError?.message || 'Unknown error';
+            log(`${errorMessage}: ${details}`);
+            throw new Error(`${errorMessage}: ${details}`);
           }
+
           log(`Retry ${retries} after error: ${error.message}`);
           await this._sleep(this.options.retryDelay * retries);
         }

src/providers/providers.test.js

@@ -1,55 +1,71 @@
-// __tests__/providers.test.js
-import { jest } from "@jest/globals";
-import dotenv from "dotenv";
-dotenv.config();
+// src/providers/providers.test.js
+import { jest, describe, expect, test, beforeEach } from '@jest/globals';
+import OpenAIEmbeddingProvider from '../../src/providers/OpenAIEmbeddingProvider.js';
 
-import OpenAIEmbeddingProvider from "../../src/providers/OpenAIEmbeddingProvider.js";
-import DeepSeekEmbeddingProvider from "../../src/providers/DeepSeekEmbeddingProvider.js";
-
-// ✅ Mock `axios` correctly
-jest.unstable_mockModule("axios", async () => ({
+// Mock axios
+jest.mock('axios', () => ({
   default: {
     create: jest.fn(() => ({
-      post: jest.fn().mockImplementation(async (url, body) => {
-        if (url.includes("openai.com")) {
-          return { data: { data: [{ embedding: Array(1536).fill(0.1) }] } };
-        } else if (url.includes("deepseek.com")) {
-          return { data: { data: [{ embedding: Array(1536).fill(Math.random() * 0.02 - 0.01) }] } }; // ✅ Returns random small floats
+      post: jest.fn().mockResolvedValue({
+        data: {
+          data: [{ embedding: Array(1536).fill(0.1) }]
         }
-        throw new Error("Unknown API endpoint");
-      }),
-    })),
-  },
+      })
+    }))
+  }
 }));
 
-describe("Embedding Providers", () => {
+describe('Embedding Providers', () => {
   let provider;
+  const mockApiKey = 'test-key-123';
 
   beforeEach(() => {
-    const providerType = process.env.EMBEDDING_PROVIDER || "openai";
-    const apiKey = process.env.EMBEDDING_API_KEY;
-
-    switch (providerType) {
-      case "openai":
-        provider = new OpenAIEmbeddingProvider({ apiKey });
-        break;
-      case "deepseek":
-        provider = new DeepSeekEmbeddingProvider({ apiKey });
-        break;
-      default:
-        throw new Error(`Unsupported provider for embeddings: ${providerType}`);
-    }
+    // Reset mocks
+    jest.clearAllMocks();
+    
+    provider = new OpenAIEmbeddingProvider({
+      apiKey: mockApiKey,
+      model: 'text-embedding-3-small',
+      dimensions: 1536
+    });
   });
 
-  test("should get embeddings from the selected provider", async () => {
-    const result = await provider.getEmbeddings(["test"]);
-    
-    expect(result).toHaveLength(1); // ✅ Ensures a single embedding
-    expect(result[0]).toHaveLength(1536); // ✅ Ensures correct vector size
+  test('should initialize with proper configuration', () => {
+    expect(provider.apiKey).toBe(mockApiKey);
+    expect(provider.model).toBe('text-embedding-3-small');
+  });
 
-    // ✅ Instead of checking for a fixed number, check for numerical range
-    expect(typeof result[0][0]).toBe("number");
+  test('should get embeddings from the OpenAI provider', async () => {
+    const texts = ['test text'];
+    const result = await provider.getEmbeddings(texts);
+    
+    expect(result).toHaveLength(1);
+    expect(result[0]).toHaveLength(1536);
+    expect(typeof result[0][0]).toBe('number');
     expect(result[0][0]).toBeGreaterThanOrEqual(-1);
     expect(result[0][0]).toBeLessThanOrEqual(1);
-  }, 15000);
-});
+  });
+
+  test('should handle empty input', async () => {
+    const result = await provider.getEmbeddings([]);
+    expect(result).toHaveLength(0);
+  });
+
+  test('should handle batch processing', async () => {
+    const texts = Array(5).fill('test text');
+    const result = await provider.getEmbeddings(texts);
+    expect(result).toHaveLength(5);
+    expect(result[0]).toHaveLength(1536);
+  });
+
+  test('should respect batch size limits', async () => {
+    const provider = new OpenAIEmbeddingProvider({
+      apiKey: mockApiKey,
+      batchSize: 2
+    });
+
+    const texts = Array(5).fill('test text');
+    const result = await provider.getEmbeddings(texts);
+    expect(result).toHaveLength(5);
+  });
+});

tests/setup.js

@@ -6,51 +6,42 @@ dotenv.config();
 // Make jest available globally
 global.jest = jest;
 
-// Mock MongoDB operations
-const mockCollection = {
-  createSearchIndex: jest.fn().mockImplementation(async () => ({ name: 'vector_index' })),
-  indexes: jest.fn().mockImplementation(async () => [{ name: 'vector_index', type: 'search' }]),
-  listSearchIndexes: jest.fn().mockImplementation(() => ({
-    toArray: async () => []
-  })),
-  createIndex: jest.fn().mockImplementation(async () => 'index_created'),
-  listIndexes: jest.fn().mockImplementation(() => ({
-    toArray: async () => []
-  })),
-  deleteMany: jest.fn().mockImplementation(async () => ({ deletedCount: 0 }))
-};
-
-const mockDb = {
-  collection: jest.fn().mockReturnValue(mockCollection)
-};
-
-const mockClient = {
-  connect: jest.fn().mockImplementation(async () => undefined),
-  db: jest.fn().mockReturnValue(mockDb),
-  close: jest.fn().mockImplementation(async () => undefined),
-  topology: {
-    isConnected: jest.fn().mockReturnValue(true)
-  }
-};
+// Set default test environment variables if not provided
+process.env.EMBEDDING_PROVIDER = process.env.EMBEDDING_PROVIDER || 'openai';
+process.env.EMBEDDING_API_KEY = process.env.EMBEDDING_API_KEY || 'test-key-123';
+process.env.MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/test';
 
+// Mock MongoDB client
 jest.mock('mongodb', () => ({
-  MongoClient: jest.fn().mockImplementation(() => mockClient)
+  MongoClient: jest.fn().mockImplementation(() => ({
+    connect: jest.fn().mockResolvedValue(undefined),
+    db: jest.fn().mockReturnValue({
+      collection: jest.fn().mockReturnValue({
+        createSearchIndex: jest.fn().mockResolvedValue({ name: 'vector_index' }),
+        indexes: jest.fn().mockResolvedValue([{ name: 'vector_index' }]),
+        listSearchIndexes: jest.fn().mockReturnValue({
+          toArray: jest.fn().mockResolvedValue([])
+        })
+      })
+    }),
+    close: jest.fn().mockResolvedValue(undefined)
+  }))
 }));
 
-// Mock chalk for cleaner test output
-jest.mock('chalk', () => ({
-  cyan: { bold: jest.fn(str => str) },
-  yellow: jest.fn(str => str),
-  red: jest.fn(str => str),
-  green: jest.fn(str => str),
-  blue: jest.fn(str => str),
-  gray: jest.fn(str => str),
-  bold: jest.fn(str => str),
-  whiteBright: jest.fn(str => str),
-  magenta: jest.fn(str => str)
+// Mock axios
+jest.mock('axios', () => ({
+  default: {
+    create: jest.fn(() => ({
+      post: jest.fn().mockResolvedValue({
+        data: {
+          data: [{ embedding: Array(1536).fill(0.1) }]
+        }
+      })
+    }))
+  }
 }));
 
-// Set a longer default timeout for all tests
+// Set longer timeout for all tests
 jest.setTimeout(30000);
 
 // Clear all mocks after each test