openai-api-mock 0.1.6 → 0.1.7

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,120 @@
+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 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.7",
   "description": "A Node.js module for mocking OpenAI API responses in a development environment",
   "repository": {
     "type": "git",
@@ -13,11 +13,18 @@
     "development",
     "testing"
   ],
+  "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/src/chat.js

@@ -119,4 +119,4 @@ function generateFunctionCallArguments(requestBody) {
 
 module.exports = {
     getChatResponce,
-};
+};

package/src/image.js

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