openai-api-mock 0.1.23 → 0.1.25

package/__tests__/custom_endpoint.test.js

@@ -0,0 +1,47 @@
+import fetch from 'node-fetch';
+import { mockOpenAIResponse, stopMocking } from '../src/index.js';
+
+describe('Mock Custom OpenAI endpoint', () => {
+    let mock;
+    beforeEach(() => {
+        mock = mockOpenAIResponse(true, { logRequests: true });
+    });
+
+    afterEach(() => {
+        stopMocking();
+    });
+
+    test('should mock custom endpoint', async () => {
+        mock.addCustomEndpoint('POST', '/v1/custom/endpoint', () => {
+            return [200, { message: 'Custom endpoint response' }];
+        });
+        const response = await fetch('https://api.openai.com/v1/custom/endpoint'
+            , {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+
+        const data = await response.json();
+        expect(data).toEqual({ message: 'Custom endpoint response' });
+    });
+
+    test('should mock custom endpoint with error', async () => {
+        mock.addCustomEndpoint('POST', '/v1/custom/endpoint', () => {
+            return [400, { error: { message: 'Invalid request' } }];
+        });
+        const response = await fetch('https://api.openai.com/v1/custom/endpoint'
+            , {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            }
+        );
+
+        const data = await response.json();
+        expect(data).toEqual({ error: { message: 'Invalid request' } });
+    });
+});

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

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

package/jest.config.js

@@ -1,6 +1,6 @@
 export default {
   collectCoverageFrom: [
-    'main.js',
+    '/src/index.js',
     '!**/node_modules/**',
   ],
   coverageReporters: ['text', 'lcov'],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openai-api-mock",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "A Node.js module for mocking OpenAI API responses in a development environment",
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
   },
   "author": "Chiheb Nabil",
   "license": "MIT",
-  "main": "main.js",
+  "main": "./src/index.js",
   "dependencies": {
     "@faker-js/faker": "^9.0.0",
     "nock": "^13.5.4"

package/readme.md

@@ -30,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
+
+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();
 
-If force is `false` or not provided, the mock response will only be used if the `NODE_ENV` environment variable is set to `development`.
+// Add custom endpoint mock (uses api.openai.com as base url)
+mock.addCustomEndpoint('POST', '/v1/custom', (uri, body) => {
+    return [200, { custom: 'response' }];
+});
+```
 
 ### Example responses
 

package/src/index.js

@@ -0,0 +1,127 @@
+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';
+const customScopes = []; // Track custom scopes
+/**
+ * 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 (e.g., 'GET', 'POST')
+         * @param {string} path - Endpoint path (e.g., '/v1/custom')
+         * @param {Function} handler - Function returning [statusCode, responseBody]
+         */
+        addCustomEndpoint(method, path, handler) {
+            const methodLower = method.toLowerCase();
+            const scope = nock(OPEN_AI_BASE_URL)
+            [methodLower](path)
+                .reply(handler)
+                .persist(); // Keep the mock active indefinitely
+            customScopes.push(scope);
+        }
+    };
+}
+
+function stopMocking() {
+    nock.cleanAll();
+    customScopes.forEach(scope => scope.persist(false)); // Disable persistence
+}
+
+export { mockOpenAIResponse, stopMocking };

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 };