openai-api-mock 0.1.31 → 0.1.33

package/index.d.ts

@@ -0,0 +1,45 @@
+
+export interface MockOptions {
+  /**
+   * When true, randomly simulates API errors
+   */
+  includeErrors?: boolean;
+  /**
+   * Adds artificial delay to responses in milliseconds
+   */
+  latency?: number;
+  /**
+   * Logs incoming requests to console for debugging
+   */
+  logRequests?: boolean;
+}
+
+export interface MockControl {
+  /**
+   * Indicates if mocking is currently active
+   */
+  isActive: boolean;
+  /**
+   * Stops all active mocks
+   */
+  stopMocking: () => void;
+  /**
+   * Adds a custom endpoint mock
+   * @param method - HTTP method (GET, POST, etc.)
+   * @param path - Endpoint path (will be appended to api.openai.com)
+   * @param handler - Function to handle the request and return response
+   */
+  addCustomEndpoint: (
+    method: string,
+    path: string,
+    handler: (uri: string, body: any) => [number, any] | Promise<[number, any]>
+  ) => void;
+}
+
+/**
+ * Sets up mocking for OpenAI API responses
+ * @param force - If true, forces mocking regardless of environment. If false, only mocks in development
+ * @param options - Configuration options for the mock behavior
+ * @returns Object with control methods for the mock
+ */
+export function mockOpenAIResponse(force?: boolean, options?: MockOptions): MockControl;

package/package.json

@@ -1,53 +1,60 @@
-{
-  "name": "openai-api-mock",
-  "version": "0.1.31",
-  "description": "A Node.js module for mocking OpenAI API responses in a development environment",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/chihebnabil/openai-api-mock.git"
-  },
-  "type": "module",
-  "keywords": [
-    "openai",
-    "mock",
-    "api",
-    "development",
-    "testing",
-    "chatgpt",
-    "interceptor",
-    "sandbox",
-    "fake",
-    "mocking",
-    "ai",
-    "artificial intelligence",
-    "machine learning"
-  ],  
-  "scripts": {
-    "build": "vite build",
-    "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": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "exports": {
-    ".": {
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.js"
-    }
-  },
-  "dependencies": {
-    "@faker-js/faker": "^9.0.0",
-    "nock": "^14.0.0"
-  },
-  "devDependencies": {
-    "jest": "^29.7.0",
-    "node-fetch": "^3.3.2",
-    "openai": "^4.52.4",
-    "vite": "^6.2.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}
+{
+  "name": "openai-api-mock",
+  "version": "0.1.33",
+  "description": "A Node.js module for mocking OpenAI API responses in a development environment",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chihebnabil/openai-api-mock.git"
+  },
+  "type": "module",
+  "types": "./index.d.ts",
+  "keywords": [
+    "openai",
+    "mock",
+    "api",
+    "development",
+    "testing",
+    "chatgpt",
+    "interceptor",
+    "sandbox",
+    "fake",
+    "mocking",
+    "ai",
+    "artificial intelligence",
+    "machine learning"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "pretest": "npm run build",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "author": "Chiheb Nabil",
+  "license": "MIT",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "index.d.ts"
+  ],
+  "dependencies": {
+    "@faker-js/faker": "^9.0.0",
+    "nock": "^14.0.0"
+  },
+  "devDependencies": {
+    "jest": "^30.0.0",
+    "node-fetch": "^3.3.2",
+    "openai": "^4.52.4",
+    "vite": "^6.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/.github/workflows/test.yml

@@ -1,33 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches: [ dev ]
-  pull_request:
-    branches: [ dev ]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [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: Build package
-      run: npm run build
-      
-    - name: Run tests  
-      run: npm test

package/__tests__/custom_endpoint.test.js

@@ -1,47 +0,0 @@
-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/__tests__/index.test.js

@@ -1,225 +0,0 @@
-import fetch from 'node-fetch';
-import { mockOpenAIResponse, stopMocking } from  '../src/index.js';
-import OpenAI from 'openai'; 
-
-const openai = new OpenAI({ apiKey: "OPENAI_API_KEY" });
-
-describe('Mock OpenAI Chat & Image generation API', () => {
-    beforeEach(() => {
-        mockOpenAIResponse(true);
-    });
-
-    afterEach(() => {
-        stopMocking();
-    });
-
-    describe('Chat Completion Tests', () => {
-        it('should mock the chat completion with correct properties', async () => {
-            const response = await openai.chat.completions.create({
-                model: "gpt-3.5-turbo",
-                messages: [
-                    { role: 'system', content: "You're an expert chef" },
-                    { role: 'user', content: "Suggest at least 5 recipes" },
-                ]
-            });
-
-            expect(response).toHaveProperty('id');
-            expect(response).toHaveProperty('object', 'chat.completion');
-            expect(response).toHaveProperty('created');
-            expect(response.model).toEqual('gpt-3.5-mock');
-            expect(response.choices).toBeInstanceOf(Array);
-            expect(response.choices[0]).toHaveProperty('index', 0);
-            expect(response.choices[0]).toHaveProperty('message');
-            expect(response.choices[0].message).toHaveProperty('role', 'assistant');
-            expect(response.choices[0].message).toHaveProperty('content');
-            expect(response.choices[0]).toHaveProperty('finish_reason', 'stop');
-            expect(response).toHaveProperty('usage');
-            expect(response.usage).toHaveProperty('prompt_tokens');
-            expect(response.usage).toHaveProperty('completion_tokens');
-            expect(response.usage).toHaveProperty('total_tokens');
-        });
-
-        it('should mock the streaming chat completion', async () => {
-            const response = await openai.chat.completions.create({
-                model: "gpt-3.5-turbo",
-                stream: true,
-                messages: [
-                    { role: 'user', content: "What's the biggest country in the world" },
-                ]
-            });
-
-            let streamContent = '';
-            for await (const part of response) {
-                expect(part).toHaveProperty('id');
-                expect(part).toHaveProperty('object', 'chat.completion.chunk');
-                expect(part).toHaveProperty('created');
-                expect(part).toHaveProperty('model', 'gpt-3.5-mock');
-                expect(part.choices[0]).toHaveProperty('index', 0);
-                expect(part.choices[0]).toHaveProperty('delta');
-                if (part.choices[0]?.delta?.content) {
-                    streamContent += part.choices[0].delta.content;
-                }
-            }
-            expect(streamContent).not.toBe('');
-        });
-
-        it('should mock the chat completion with function call', async () => {
-            const response = await openai.chat.completions.create({
-                model: "gpt-3.5-turbo",
-                messages: [
-                    { role: 'system', content: "You're an expert chef" },
-                    { role: 'user', content: "Suggest at least 5 recipes" },
-                ],
-                functions: [
-                    {
-                        name: 'get_recipes',
-                        description: 'Suggest at least 5 recipes based on the ingredients you have',
-                        parameters: {
-                            type: "object",
-                            properties: {
-                                recipes: {
-                                    type: "array",
-                                    description: "The recipes that can be made with the ingredients",
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            name: { type: 'string' },
-                                            ingredients: { type: 'array', items: { type: 'string' } },
-                                            instructions: { type: 'string' },
-                                            serving: { type: 'string' },
-                                        }
-                                    }
-                                },
-                            }
-                        },
-                        required: ["recipes"],
-                    },
-                ],
-                function_call: { name: 'get_recipes' },
-            });
-
-            expect(response.model).toEqual('gpt-3.5-mock');
-            expect(response.choices[0]).toHaveProperty('finish_reason', 'function_call');
-            expect(response.choices[0].message.function_call).toHaveProperty('name', 'get_recipes');
-            expect(response.choices[0].message.function_call).toHaveProperty('arguments');
-            const args = JSON.parse(response.choices[0].message.function_call.arguments);
-            expect(args).toHaveProperty('recipes');
-            expect(args.recipes).toBeInstanceOf(Array);
-            expect(args.recipes.length).toBeGreaterThanOrEqual(5);
-            args.recipes.forEach(recipe => {
-                expect(recipe).toHaveProperty('name');
-                expect(recipe).toHaveProperty('ingredients');
-                expect(recipe).toHaveProperty('instructions');
-                expect(recipe).toHaveProperty('serving');
-            });
-        });
-
-        it('should mock the chat completion with tool calls', async () => {
-            const response = await openai.chat.completions.create({
-                model: "gpt-3.5-turbo",
-                messages: [
-                    { role: 'system', content: "You're an expert chef" },
-                    { role: 'user', content: "Suggest at least 5 recipes and send them to my email" },
-                ],
-                tools: [
-                    {
-                        type: "function",
-                        function: {
-                            name: 'get_recipes',
-                            description: 'Suggest at least 5 recipes based on the ingredients you have',
-                            parameters: {
-                                type: "object",
-                                properties: {
-                                    recipes: {
-                                        type: "array",
-                                        items: {
-                                            type: 'object',
-                                            properties: {
-                                                name: { type: 'string' },
-                                                ingredients: { type: 'array', items: { type: 'string' } },
-                                                instructions: { type: 'string' },
-                                                serving: { type: 'string' },
-                                            }
-                                        }
-                                    },
-                                }
-                            },
-                            required: ["recipes"],
-                        }
-                    },
-                    {
-                        type: "function",
-                        function: {
-                            name: 'send_email',
-                            description: 'Send an email to the user with the recipes',
-                            parameters: {
-                                type: "object",
-                                properties: {
-                                    email: { type: "string" },
-                                    subject: { type: "string" },
-                                    body: { type: "string" },
-                                }
-                            },
-                            required: ["email", "subject", "body"],
-                        }
-                    }
-                ],
-                tool_choice: "auto",
-            });
-
-            expect(response.model).toEqual('gpt-3.5-mock');
-            expect(response.choices[0]).toHaveProperty('finish_reason', 'tool_calls');
-            expect(response.choices[0].message.tool_calls).toBeInstanceOf(Array);
-
-            const recipesArgs = JSON.parse(response.choices[0].message.tool_calls[0].function.arguments);
-            expect(recipesArgs).toHaveProperty('recipes');
-        });
-    });
-
-    describe('Image Generation Tests', () => {
-        it('should mock image generation with correct properties', async () => {
-            const response = await openai.images.generate({
-                model: "dall-e-3",
-                prompt: "A futuristic cityscape",
-                n: 1,
-                size: "1024x1024",
-                quality: "hd",
-            });
-
-            expect(response).toHaveProperty('created');
-            expect(response).toHaveProperty('data');
-            expect(response.data).toBeInstanceOf(Array);
-            expect(response.data.length).toBe(1);
-            expect(response.data[0]).toHaveProperty('revised_prompt');
-            expect(response.data[0]).toHaveProperty('url');
-            expect(response.data[0].url).toMatch(/^http:\/\//);
-        });
-
-        it('should handle multiple image generation', async () => {
-            const response = await openai.images.generate({
-                model: "dall-e-3",
-                prompt: "Abstract art in various styles",
-                n: 3,
-                size: "512x512",
-                quality: "standard",
-            });
-
-            expect(response.data).toBeInstanceOf(Array);
-            expect(response.data.length).toBe(3);
-            response.data.forEach(image => {
-                expect(image).toHaveProperty('url');
-                expect(image.url).toMatch(/^http:\/\//);
-            });
-        });
-    });
-
-    it('should allow other requests', async () => {
-        const response = await fetch('https://jsonplaceholder.typicode.com/todos');
-        const data = await response.json();
-
-        expect(data[0]).toHaveProperty('id');
-        expect(data[0]).toHaveProperty('userId');
-        expect(data[0]).toHaveProperty('title');
-        expect(data[0]).toHaveProperty('completed');
-    });
-});

package/__tests__/mock_delay.test.js

@@ -1,29 +0,0 @@
-import fetch from 'node-fetch';
-import { mockOpenAIResponse, stopMocking } from '../src/index.js';
-import OpenAI from 'openai';
-
-const openai = new OpenAI({ apiKey: "OPENAI_API_KEY" });
-
-describe('Mock OpenAI Chat with a delay', () => {
-
-    beforeEach(() => {
-        mockOpenAIResponse(true, { latency: 1000, logRequests: true });
-    });
-
-    afterEach(() => {
-        stopMocking();
-    });
-
-    test('should mock OpenAI Chat with a delay', async () => {
-        const response = await openai.chat.completions.create({
-            model: "gpt-3.5-mock",
-            messages: [
-                { role: 'system', content: "You're an expert chef" },
-                { role: 'user', content: "Suggest at least 5 recipes" },
-            ]
-        });
-
-        expect(response).toBeDefined();
-
-    });
-});

package/jest.config.js

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

package/renovate.json

@@ -1,4 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:recommended", ":dependencyDashboard"]
-}

package/src/chat.js

@@ -1,16 +0,0 @@
-import { createDefaultResponse, createFunctionCallingResponse } from './utils/responseGenerators.js';
-
-function getChatResponce(requestBody) {
-  const created = Math.floor(Date.now() / 1000);
-
-  if (!requestBody.functions && !requestBody.tools) {
-    return createDefaultResponse(created);
-  }
-
-  return createFunctionCallingResponse(requestBody, created);
-}
-
-
-export {
-  getChatResponce,
-};

package/src/chat.stream.js

@@ -1,33 +0,0 @@
-import { Readable } from 'node:stream';
-import { getSteamChatObject } from './utils/responseGenerators.js'
-
-function createChatStream() {
-    const stream = new Readable({
-        read() { }
-    });
-
-    let count = 0;
-    const maxCount = 5;
-
-    function sendData() {
-        setTimeout(() => {
-            if (count < maxCount - 1) {
-                stream.push(`data: ${getSteamChatObject()}\n\n`);
-                count++;
-                sendData(); // Call the function recursively until the last iteration
-            } else if (count === maxCount - 1) {
-                stream.push(`data: [DONE]\n\n`);
-                stream.push(null); // End the stream after sending the data
-            }
-        }, 200);
-    }
-
-    sendData(); // Start sending data
-
-    return stream;
-}
-
-
-export {
-    createChatStream,
-};

package/src/image.js

@@ -1,24 +0,0 @@
-import { faker } from '@faker-js/faker';
-
-function getImageResponce(requestBody) {
-
-  const n = requestBody.n || 1;
-  const data = [];
-  for (let i = 0; i < n; i++) {
-    data.push({
-      revised_prompt: faker.lorem.words(5),
-      url: "http://via.placeholder.com/" + requestBody.size
-    });
-  }
-
-  return {
-    created: Math.floor(Date.now() / 1000),
-    data: data
-  };
-}
-
-
-
-export {
-  getImageResponce,
-};