openai-api-mock 0.1.15 → 0.1.17

package/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Nabil Chiheb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/main.test.js

@@ -1,6 +1,4 @@
 const { mockOpenAIResponse, stopMocking } = require('./main');
-const { Stream } = require('stream');
-
 const OpenAI = require('openai');
 const openai = new OpenAI({ apiKey: "OPENAI_API_KEY" });
 
@@ -8,49 +6,66 @@ describe('Mock OpenAI Chat & Image generation API', () => {
     beforeEach(() => {
         mockOpenAIResponse(true);
     });
+
     afterEach(() => {
         stopMocking();
     });
-    it('should mock the chat completion', async () => {
-        try {
+
+    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",
+                model: "gpt-3.5-turbo",
                 messages: [
-                    { role: 'system', content: "You'r an expert chef" },
+                    { role: 'system', content: "You're an expert chef" },
                     { role: 'user', content: "Suggest at least 5 recipes" },
                 ]
             });
-            expect(response.choices[0]).toHaveProperty('finish_reason', 'stop');
+            
+            expect(response).toHaveProperty('id');
+            expect(response).toHaveProperty('object', 'chat.completion');
+            expect(response).toHaveProperty('created');
             expect(response.model).toEqual('gpt-3.5-mock');
-        } catch (error) {
-            throw new Error(error);
-        }
-    });
+            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 () => {
-        try {
+        it('should mock the streaming chat completion', async () => {
             const response = await openai.chat.completions.create({
-                model: "gpt-3.5",
+                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) {
-                console.log(part.choices[0]?.delta?.content || '')
+                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;
+                }
             }
-        } catch (error) {
-            throw new Error(error);
-        }
-    });
+            expect(streamContent).not.toBe('');
+        });
 
-    it('should mock the chat completion with function call', async () => {
-        try {
+        it('should mock the chat completion with function call', async () => {
             const response = await openai.chat.completions.create({
-                model: "gpt-3.5",
+                model: "gpt-3.5-turbo",
                 messages: [
-                    { role: 'system', content: "You'r an expert chef" },
+                    { role: 'system', content: "You're an expert chef" },
                     { role: 'user', content: "Suggest at least 5 recipes" },
                 ],
                 functions: [
@@ -66,26 +81,10 @@ describe('Mock OpenAI Chat & Image generation API', () => {
                                     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',
-                                            },
+                                            name: { type: 'string' },
+                                            ingredients: { type: 'array', items: { type: 'string' } },
+                                            instructions: { type: 'string' },
+                                            serving: { type: 'string' },
                                         }
                                     }
                                 },
@@ -96,27 +95,56 @@ describe('Mock OpenAI Chat & Image generation API', () => {
                 ],
                 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);
-        }
-    });
-
+            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 email function call (tools)', async () => {
-        try {
+        it('should mock the chat completion with tool calls', async () => {
             const response = await openai.chat.completions.create({
-                model: "gpt-3.5",
+                model: "gpt-3.5-turbo",
                 messages: [
-                    { role: 'system', content: "You'r an expert chef" },
-                    { role: 'user', content: "Suggest at least 5 recipes" },
+                    { 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: {
@@ -125,118 +153,71 @@ describe('Mock OpenAI Chat & Image generation API', () => {
                             parameters: {
                                 type: "object",
                                 properties: {
-                                    email: {
-                                        type: "string",
-                                        description: "The email address of the user",
-                                    }
+                                    email: { type: "string" },
+                                    subject: { type: "string" },
+                                    body: { type: "string" },
                                 }
                             },
-                            required: ["email"],
+                            required: ["email", "subject", "body"],
                         }
-
-                    }],
-
-                tool_choice: { name: 'send_email' },
+                    }
+                ],
+                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[0].function).toHaveProperty('name', 'send_email');
-            expect(response.choices[0].message.tool_calls[0].function).toHaveProperty('arguments');
-            expect(JSON.parse(response.choices[0].message.tool_calls[0].function.arguments)).toHaveProperty('email');
+            expect(response.choices[0].message.tool_calls).toBeInstanceOf(Array);
 
-        } 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' },
+            const recipesArgs = JSON.parse(response.choices[0].message.tool_calls[0].function.arguments);
+            expect(recipesArgs).toHaveProperty('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 {
+    describe('Image Generation Tests', () => {
+        it('should mock image generation with correct properties', async () => {
             const response = await openai.images.generate({
                 model: "dall-e-3",
-                prompt: "Kurt Cobain",
+                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');
-        } catch (error) {
-            throw new Error(error);
-        }
+            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 () => {
-        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);
-        }
-    })
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openai-api-mock",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "A Node.js module for mocking OpenAI API responses in a development environment",
   "repository": {
     "type": "git",
@@ -22,11 +22,11 @@
   "license": "MIT",
   "main": "main.js",
   "dependencies": {
-    "@faker-js/faker": "^8.4.0",
-    "nock": "^13.5.1"
+    "@faker-js/faker": "^9.0.0",
+    "nock": "^13.5.4"
   },
   "devDependencies": {
     "jest": "^29.7.0",
-    "openai": "^4.26.0"
+    "openai": "^4.52.4"
   }
 }

package/readme.md

@@ -30,7 +30,9 @@ This function intercepts HTTP calls to the OpenAI endpoint and returns a mock re
 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'.
+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 `NODE_ENV` environment variable is set to `development`.
 
 ### Example responces
 

package/renovate.json

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