openai-api-mock 0.1.22 → 0.1.24

package/.github/workflows/test.yml

@@ -0,0 +1,30 @@
+name: Tests
+
+on:
+  push:
+    branches: [ dev ]
+  pull_request:
+    branches: [ dev ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [16.x, 18.x, 20.x]
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+        
+    - name: Install dependencies
+      run: npm ci
+      
+    - name: Run tests
+      run: npm test

package/jest.config.js

@@ -0,0 +1,15 @@
+export default {
+  collectCoverageFrom: [
+    '/src/index.js',
+    '!**/node_modules/**',
+  ],
+  coverageReporters: ['text', 'lcov'],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openai-api-mock",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "A Node.js module for mocking OpenAI API responses in a development environment",
   "repository": {
     "type": "git",
@@ -14,20 +14,31 @@
     "development",
     "testing",
     "chatgpt",
-    "interceptor"
+    "interceptor",
+    "sandbox",
+    "fake",
+    "mocking",
+    "ai",
+    "artificial intelligence",
+    "machine learning"
   ],
   "scripts": {
-    "test":"node --experimental-vm-modules node_modules/jest/bin/jest.js"
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage"
   },
   "author": "Chiheb Nabil",
   "license": "MIT",
-  "main": "main.js",
+  "main": "./src/index.js",
   "dependencies": {
     "@faker-js/faker": "^9.0.0",
     "nock": "^13.5.4"
   },
   "devDependencies": {
     "jest": "^29.7.0",
+    "node-fetch": "^3.3.2",
     "openai": "^4.52.4"
+  },
+  "engines": {
+    "node": ">=16.0.0"
   }
 }

package/readme.md

@@ -1,6 +1,8 @@
 # OpenAI API Mock
 
-This is a Node.js module for mocking OpenAI API responses in a development environment. 
+This is a Node.js module for mocking OpenAI API responses in a development environment.
+
+[![Tests](https://github.com/chihebnabil/openai-api-mock/actions/workflows/test.yml/badge.svg)](https://github.com/chihebnabil/openai-api-mock/actions/workflows/test.yml)
 
 It's useful for testing and development purposes when you don't want to make actual API calls.
 
@@ -28,18 +30,42 @@ import { mockOpenAIResponse } from 'openai-api-mock';
 Then, call the mockOpenAIResponse function to set up the mock response:
 
 ```js
+// Basic usage
 mockOpenAIResponse();
-```
-This function intercepts HTTP calls to the OpenAI endpoint and returns a mock response. The mock response is generated based on the requestBody of the code, and it supports complex (function call) requestBody structures like arrays and nested objects.
 
-```js
+// Force mocking regardless of environment
 mockOpenAIResponse(true);
+
+// With configuration options
+mockOpenAIResponse(false, {
+    includeErrors: true,    // Simulate random API errors
+    latency: 1000,         // Add 1 second delay to responses
+    logRequests: true      // Log incoming requests to console
+});
 ```
 
-The force parameter is a boolean that determines whether the mock response should be used regardless of the environment. 
-If force is true, the mock response will be used regardless of the environment. 
+The function accepts two parameters:
+- `force` (boolean): Determines whether the mock response should be used regardless of the environment. If false or not provided, mocking only occurs in development environment.
+- `options` (object): Additional configuration options
+  - `includeErrors` (boolean): When true, randomly simulates API errors
+  - `latency` (number): Adds artificial delay to responses in milliseconds
+  - `logRequests` (boolean): Logs incoming requests to console for debugging
 
-If force is `false` or not provided, the mock response will only be used if the `NODE_ENV` environment variable is set to `development`.
+The function returns an object with control methods:
+```js
+const mock = mockOpenAIResponse();
+
+// Check if mocking is active
+console.log(mock.isActive);
+
+// Stop all mocks
+mock.stopMocking();
+
+// Add custom endpoint mock
+mock.addCustomEndpoint('POST', '/v1/custom', (uri, body) => {
+    return [200, { custom: 'response' }];
+});
+```
 
 ### Example responses
 

package/src/index.js

@@ -0,0 +1,122 @@
+import nock from 'nock';
+import { getChatResponce } from './chat.js';
+import { createChatStream } from './chat.stream.js';
+import { getImageResponce } from './image.js';
+
+const OPEN_AI_BASE_URL = 'https://api.openai.com';
+const CHAT_COMPLETIONS_ENDPOINT = '/v1/chat/completions';
+const IMAGE_GENERATIONS_ENDPOINT = '/v1/images/generations';
+
+/**
+ * Mock OpenAI API responses
+ * @param {boolean} force - Force mocking regardless of environment
+ * @param {Object} options - Additional configuration options
+ * @param {boolean} options.includeErrors - Whether to include error scenarios in mocking
+ * @param {number} options.latency - Artificial latency in ms to simulate network delay
+ * @param {boolean} options.logRequests - Whether to log incoming requests
+ * @returns {Object} An object with control methods for the mocks
+ */
+function mockOpenAIResponse(force = false, options = {}) {
+    const {
+        includeErrors = false,
+        latency = 0,
+        logRequests = false
+    } = options;
+    
+    const env = process.env.NODE_ENV || 'development';
+    
+    // Only proceed if in development or forced
+    if (env !== 'development' && !force) {
+        return { isActive: false, stopMocking };
+    }
+    
+    // Add delay if latency is specified
+    const delayResponse = latency > 0 ? 
+        nock.defaults({ delayConnection: latency }) : null;
+    
+    // Mock chat completions endpoint
+    const chatScope = nock(OPEN_AI_BASE_URL)
+        .post(CHAT_COMPLETIONS_ENDPOINT)
+        .reply(function (uri, requestBody) {
+            if (logRequests) {
+                console.log(`[openai-api-mock] Chat request:`, JSON.stringify(requestBody, null, 2));
+            }
+            
+            try {
+                // Validate minimal required fields
+                if (!requestBody.model || !requestBody.messages || !Array.isArray(requestBody.messages)) {
+                    return [400, { error: { message: 'Invalid request. Missing required fields.' } }];
+                }
+                
+                // Simulate random errors if enabled
+                if (includeErrors && Math.random() < 0.05) {
+                    return [429, { error: { message: 'Rate limit exceeded' } }];
+                }
+                
+                const isSteaming = requestBody.stream === true;
+                
+                if (isSteaming) {
+                    const stream = createChatStream(requestBody);
+                    return [200, stream];
+                }
+                
+                return [200, getChatResponce(requestBody)];
+            } catch (error) {
+                console.error('[openai-api-mock] Error processing chat request:', error);
+                return [500, { error: { message: 'Internal server error in mock' } }];
+            }
+        });
+    
+    // Mock image generations endpoint
+    const imageScope = nock(OPEN_AI_BASE_URL)
+        .post(IMAGE_GENERATIONS_ENDPOINT)
+        .reply(function (uri, requestBody) {
+            if (logRequests) {
+                console.log(`[openai-api-mock] Image request:`, JSON.stringify(requestBody, null, 2));
+            }
+            
+            try {
+                // Validate minimal required fields
+                if (!requestBody.prompt) {
+                    return [400, { error: { message: 'Invalid request. Missing prompt.' } }];
+                }
+                
+                // Simulate random errors if enabled
+                if (includeErrors && Math.random() < 0.05) {
+                    return [400, { error: { message: 'Your request was rejected as a result of our safety system.' } }];
+                }
+                
+                return [200, getImageResponce(requestBody)];
+            } catch (error) {
+                console.error('[openai-api-mock] Error processing image request:', error);
+                return [500, { error: { message: 'Internal server error in mock' } }];
+            }
+        });
+    
+    // Enable other network connections
+    nock.enableNetConnect(host => host !== "api.openai.com");
+    
+    return {
+        isActive: true,
+        stopMocking,
+        
+        /**
+         * Adds a custom endpoint mock
+         * @param {string} method - HTTP method (GET, POST, etc.)
+         * @param {string} path - Path to mock (e.g., '/v1/custom')
+         * @param {Function} handler - Handler function that returns [statusCode, responseBody]
+         */
+        addCustomEndpoint(method, path, handler) {
+            nock(OPEN_AI_BASE_URL)[method.toLowerCase()](path).reply(handler);
+        }
+    };
+}
+
+/**
+ * Stop all active mocks
+ */
+function stopMocking() {
+    nock.cleanAll();
+}
+
+export { mockOpenAIResponse, stopMocking };

package/{main.test.js → src/index.test.js}

@@ -1,4 +1,5 @@
-import { mockOpenAIResponse, stopMocking } from  './main.js'
+import fetch from 'node-fetch';
+import { mockOpenAIResponse, stopMocking } from  './index.js'
 import OpenAI from 'openai'; 
 
 const openai = new OpenAI({ apiKey: "OPENAI_API_KEY" });

package/main.js

@@ -1,42 +0,0 @@
-import nock from 'nock';
-import { getChatResponce } from './src/chat.js';
-import { createChatStream } from './src/chat.stream.js';
-import { getImageResponce } from './src/image.js';
-
-const OPEN_AI_BASE_URL = 'https://api.openai.com';
-const CHAT_COMPLETIONS_ENDPOINT = '/v1/chat/completions';
-const IMAGE_GENERATIONS_ENDPOINT = '/v1/images/generations';
-
-function mockOpenAIResponse(force = false) {
-    var env = process.env.NODE_ENV || 'development';
-    // Intercept the HTTP call and return the mock response
-    if (env === 'development' || force) {
-        nock(OPEN_AI_BASE_URL)
-            .post(CHAT_COMPLETIONS_ENDPOINT)
-            .reply(function (uri, requestBody) {
-                let isSteaming = (requestBody.stream && requestBody.stream == true) ? true : false
-
-                if (isSteaming) {
-                    const stream = createChatStream();
-                    return [200, stream];
-                }
-
-                return [200, getChatResponce(requestBody)];
-            });
-
-        nock(OPEN_AI_BASE_URL)
-            .post(IMAGE_GENERATIONS_ENDPOINT)
-            .reply(function (uri, requestBody) {
-                return [200, getImageResponce(requestBody)];
-            });
-
-        // Mocking only the chat completion endpoint, not blocking other requests
-        nock.enableNetConnect(host => host !== "api.openai.com");
-    }
-}
-
-function stopMocking() {
-    nock.cleanAll();
-}
-
-export { mockOpenAIResponse, stopMocking };