openai-api-mock 0.1.30 → 0.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openai-api-mock",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "A Node.js module for mocking OpenAI API responses in a development environment",
   "repository": {
     "type": "git",
@@ -25,7 +25,9 @@
   "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"
+    "coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
+	"prepublishOnly": "npm run build"
+
   },
   "author": "Chiheb Nabil",
   "license": "MIT",
@@ -37,6 +39,7 @@
       "import": "./dist/index.js"
     }
   },
+  "files": ["dist"],
   "dependencies": {
     "@faker-js/faker": "^9.0.0",
     "nock": "^14.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,
-};

package/src/index.js

@@ -1,123 +0,0 @@
-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
- */
-export 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 };
-    }
-
-    // Mock chat completions endpoint
-    const chatScope = nock(OPEN_AI_BASE_URL)
-        .post(CHAT_COMPLETIONS_ENDPOINT)
-        .delay(latency) // Add delay to the interceptor
-        .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)
-        .delay(latency) // Add delay to the interceptor
-        .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);
-        }
-    };
-}
-
-export function stopMocking() {
-    nock.cleanAll();
-    customScopes.forEach(scope => scope.persist(false)); // Disable persistence
-}