openai-api-mock 0.1.6 → 0.1.8

package/main.js

@@ -2,33 +2,36 @@ const nock = require('nock');
 const { getChatResponce } = require('./src/chat.js');
 const { getImageResponce } = require('./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) {
-    // Define the OpenAI endpoints
-    const openaiCompletionEndpoint = 'https://api.openai.com/v1/chat/completions';
-    const imageEndpoint = 'https://api.openai.com/v1/images/generations';
     var env = process.env.NODE_ENV || 'development';
-
     // Intercept the HTTP call and return the mock response
     if (env === 'development' || force) {
-        nock(openaiCompletionEndpoint)
-            .post('')
+        nock(OPEN_AI_BASE_URL)
+            .post(CHAT_COMPLETIONS_ENDPOINT)
             .reply(function (uri, requestBody) {
                 return [200, getChatResponce(requestBody)];
             });
 
-        nock(imageEndpoint)
-            .post('')
+        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.emitter.on('no match', function (req) {
-            nock.enableNetConnect(req);
-        });
+        nock.enableNetConnect(host => host !== "api.openai.com");
     }
 }
 
+function stopMocking() {
+    nock.cleanAll();
+}
+
 module.exports = {
-    mockOpenAIResponse
-};
+    mockOpenAIResponse,
+    stopMocking,
+};

package/main.test.js

@@ -0,0 +1,180 @@
+const { mockOpenAIResponse, stopMocking } = require('./main');
+
+const OpenAI = require('openai');
+const openai = new OpenAI({ apiKey: "OPENAI_API_KEY" });
+
+describe('Mock OpenAI Chat & Image generation API', () => {
+    beforeEach(() => {
+        mockOpenAIResponse(true);
+    });
+    afterEach(() => {
+        stopMocking();
+    });
+    it('should mock the chat completion', async () => {
+        try {
+            const response = await openai.chat.completions.create({
+                model: "gpt-3.5",
+                messages: [
+                    { role: 'system', content: "You'r an expert chef" },
+                    { role: 'user', content: "Suggest at least 5 recipes" },
+                ]
+            });
+            expect(response.choices[0]).toHaveProperty('finish_reason', 'stop');
+            expect(response.model).toEqual('gpt-3.5-mock');
+        } catch (error) {
+            throw new Error(error);
+        }
+    });
+
+    it('should mock the chat completion with function call', async () => {
+        try {
+            const response = await openai.chat.completions.create({
+                model: "gpt-3.5",
+                messages: [
+                    { role: 'system', content: "You'r 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',
+                                                description: 'The name of the recipe',
+                                            },
+                                            ingredients: {
+                                                type: 'array',
+                                                description: 'The ingredients needed for the recipe',
+                                                items: {
+                                                    type: 'string',
+                                                    description: 'The name of the ingredient',
+                                                },
+                                            },
+                                            instructions: {
+                                                type: 'string',
+                                                description: 'Detailed instructions on how to make the recipe',
+                                            },
+                                            serving: {
+                                                type: 'string',
+                                                description: 'The number of people the recipe serves',
+                                            },
+                                        }
+                                    }
+                                },
+                            }
+                        },
+                        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');
+            expect(JSON.parse(response.choices[0].message.function_call.arguments)).toHaveProperty('recipes');
+
+        } catch (error) {
+            throw new Error(error);
+        }
+    });
+
+
+    it('should mock the chat completion with function call (tools)', async () => {
+            const response = await openai.chat.completions.create({
+                model: "gpt-3.5",
+                messages: [
+                    { role: 'system', content: "You'r an expert chef" },
+                    { role: 'user', content: "Suggest at least 5 recipes" },
+                ],
+                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",
+                                    description: "The recipes that can be made with the ingredients",
+                                    items: {
+                                        type: 'object',
+                                        properties: {
+                                            name: {
+                                                type: 'string',
+                                                description: 'The name of the recipe',
+                                            },
+                                            ingredients: {
+                                                type: 'array',
+                                                description: 'The ingredients needed for the recipe',
+                                                items: {
+                                                    type: 'string',
+                                                    description: 'The name of the ingredient',
+                                                },
+                                            },
+                                            instructions: {
+                                                type: 'string',
+                                                description: 'Detailed instructions on how to make the recipe',
+                                            },
+                                            serving: {
+                                                type: 'string',
+                                                description: 'The number of people the recipe serves',
+                                            },
+                                        }
+                                    }
+                                },
+                            }
+                        },
+                        required: ["recipes"],
+                    }
+
+                }],
+                tool_choice: { name: 'get_recipes' },
+            });
+            expect(response.model).toEqual('gpt-3.5-mock');
+            expect(response.choices[0]).toHaveProperty('finish_reason', 'tool_calls');
+            expect(response.choices[0].message.tool_calls[0].function).toHaveProperty('name', 'get_recipes');
+            expect(response.choices[0].message.tool_calls[0].function).toHaveProperty('arguments');
+            expect(JSON.parse(response.choices[0].message.tool_calls[0].function.arguments)).toHaveProperty('recipes');
+    });
+
+
+    it('should mock image generation', async () => {
+        try {
+            const response = await openai.images.generate({
+                model: "dall-e-3",
+                prompt: "Kurt Cobain",
+                n: 1,
+                size: "1024x1024",
+                quality: "hd",
+            });
+
+            expect(response.data[0]).toHaveProperty('revised_prompt');
+            expect(response.data[0]).toHaveProperty('url');
+        } catch (error) {
+            throw new Error(error);
+        }
+
+    });
+
+    it('should allow other requests', async () => {
+        try {
+            const response = await fetch('https://jsonplaceholder.typicode.com/todos');
+            const data = await response.json();
+            expect(data[0]).toHaveProperty('completed');
+        } catch (error) {
+            throw new Error(error);
+        }
+    })
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openai-api-mock",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "A Node.js module for mocking OpenAI API responses in a development environment",
   "repository": {
     "type": "git",
@@ -11,13 +11,22 @@
     "mock",
     "api",
     "development",
-    "testing"
+    "testing",
+    "chatgpt",
+    "interceptor"
   ],
+  "scripts": {
+    "test": "jest"
+  },
   "author": "Chiheb Nabil",
   "license": "MIT",
   "main": "main.js",
   "dependencies": {
     "@faker-js/faker": "^8.4.0",
     "nock": "^13.5.1"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "openai": "^4.26.0"
   }
 }

package/readme.md

@@ -32,6 +32,42 @@ mockOpenAIResponse(force = true);
 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. If force is false or not provided, the mock response will only be used if the <code>NODE_ENV</code> environment variable is set to 'development'.
 
+### Example responces
+
+```js
+// Call the mockOpenAIResponse function once to set up the mock
+mockOpenAIResponse() 
+
+// Now, when you call the OpenAI API, it will return a mock response
+const response = await openai.chat.completions.create({
+                model: "gpt-3.5",
+                messages: [
+                    { role: 'system', content: "You'r an expert chef" },
+                    { role: 'user', content: "Suggest at least 5 recipes" },
+                ]
+});
+ ```
+In this example, the `response` constant will contain mock data, simulating a response from the OpenAI API:
+
+```json
+{
+    choices: [
+        {
+          finish_reason: 'stop',
+          index: 0,
+          message: [Object],
+          logprobs: null
+        }
+      ],
+      created: 1707040459,
+      id: 'chatcmpl-tggOnwW8Lp2XiwQ8dmHHAcNYJ8CfzR',
+      model: 'gpt-3.5-mock',
+      object: 'chat.completion',
+      usage: { completion_tokens: 17, prompt_tokens: 57, total_tokens: 74 }
+}
+```
+
+
 ## Intercepted URLs
 
 This module uses the `nock` library to intercept HTTP calls to the following OpenAI API endpoints:

package/src/chat.js

@@ -3,7 +3,7 @@ const { faker } = require('@faker-js/faker');
 function getChatResponce(requestBody) {
     const created = Math.floor(Date.now() / 1000);
 
-    if (!requestBody.functions) {
+    if (!requestBody.functions && !requestBody.tools) {
         return createDefaultResponse(created);
     }
 
@@ -36,6 +36,10 @@ function createDefaultResponse(created) {
 }
 
 function createFunctionCallingResponse(requestBody, created) {
+    const isTool = Boolean(requestBody.tools);
+    const functionOrToolCallObject = isTool ? [createToolCallObject(requestBody)] : createFunctionCallObject(requestBody);
+    const functionOrToolCall = isTool ? 'tool_calls' : 'function_call';
+
     const functionCallingResponse = {
         id: `chatcmpl-${faker.string.alphanumeric(30)}`,
         object: 'chat.completion',
@@ -47,9 +51,9 @@ function createFunctionCallingResponse(requestBody, created) {
                 message: {
                     role: 'assistant',
                     content: null,
-                    function_call: createFunctionCallObject(requestBody),
+                    [functionOrToolCall]: functionOrToolCallObject,
                 },
-                finish_reason: 'function_call',
+                finish_reason: functionOrToolCall,
             },
         ],
         usage: {
@@ -62,6 +66,16 @@ function createFunctionCallingResponse(requestBody, created) {
     return functionCallingResponse;
 }
 
+function createToolCallObject(requestBody) {
+    return {
+        id: `call-${faker.string.alphanumeric(30)}`,
+        type: "function",
+        "function": {
+            name: `${requestBody.tools[0].function.name}`,
+            arguments: `${generateToolCallArguments(requestBody)}`
+        }
+    };
+}
 function createFunctionCallObject(requestBody) {
     return {
         name: `${requestBody.functions[0].name}`,
@@ -69,6 +83,17 @@ function createFunctionCallObject(requestBody) {
     };
 }
 
+function generateToolCallArguments(requestBody) {
+    const { parameters } = requestBody.tools[0].function;
+    const argumentsObject = {};
+
+    Object.entries(parameters.properties).forEach(([paramName, paramDetails]) => {
+        argumentsObject[paramName] = generateFakeData(paramDetails.type, paramDetails);
+    });
+
+    return JSON.stringify(argumentsObject, null, 2);
+}
+
 function generateFakeData(type, properties) {
     switch (type) {
         case 'string':
@@ -119,4 +144,4 @@ function generateFunctionCallArguments(requestBody) {
 
 module.exports = {
     getChatResponce,
-};
+};

package/src/image.js

@@ -19,8 +19,6 @@ function getImageResponce(requestBody) {
 }
 
 
-
-
 module.exports = {
   getImageResponce,
-};
+};