openai-api-mock 0.1.0

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/main.js

@@ -0,0 +1,22 @@
+const nock = require('nock');
+const { getResponce } = require('./src/responce.js');
+
+function mockOpenAIResponse(force = false) {
+    // Define the OpenAI endpoint
+    const openaiEndpoint = 'https://api.openai.com/v1/chat/completions';
+    var env = process.env.NODE_ENV || 'development'
+    // Intercept the HTTP call and return the mock response
+    if (env === 'development' || force) {
+        nock(openaiEndpoint)
+            .post('')
+            .reply(
+                function (uri, requestBody) {
+                    return [200, getResponce(requestBody)];
+                }
+            );
+    }
+}
+
+module.exports = {
+    mockOpenAIResponse
+};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "openai-api-mock",
+  "version": "0.1.0",
+  "description": "A Node.js module for mocking OpenAI API responses in a development environment",
+  "keywords": [
+    "openai",
+    "mock",
+    "api",
+    "development",
+    "testing"
+  ],
+  "author": "Chiheb Nabil",
+  "license": "MIT",
+  "dependencies": {
+    "@faker-js/faker": "^8.4.0",
+    "nock": "^13.5.1"
+  }
+}

package/readme.md

@@ -0,0 +1,43 @@
+# OpenAI API Mock
+
+This is a Node.js module for mocking OpenAI API responses in a development environment. 
+It's useful for testing and development purposes when you don't want to make actual API calls.
+The module also supports mocking function_calling
+
+## Installation
+
+You can install this module using npm as a dev dependency :
+
+```sh
+npm install -D openai-api-mock
+```
+
+## Usage
+```js
+const { mockOpenAIResponse } = require('openai-api-mock');
+```
+
+
+Then, call the mockOpenAIResponse function to set up the mock response:
+
+```js
+mockOpenAIResponse();
+```
+This function intercepts HTTP calls to the OpenAI endpoint and returns a mock response. The mock response is generated based on the requestBody of the code , and it supports complex (function call) requestBody structures like arrays and nested objects.
+
+```js
+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'.
+
+
+
+## Dependencies
+This module depends on the following npm packages:
+
+- nock : For intercepting HTTP calls.
+- @faker-js/faker : For generating fake data.
+
+## License
+This project is licensed under the MIT License.

package/src/responce.js

@@ -0,0 +1,99 @@
+const { faker } = require('@faker-js/faker');
+
+function getResponce(requestBody) {
+    const created = Math.floor(Date.now() / 1000)
+    if (!requestBody.functions) {
+        return {
+            choices: [
+                {
+                    finish_reason: 'stop',
+                    index: 0,
+                    message: {
+                        content: faker.lorem.words(5),
+                        role: 'assistant',
+                    },
+                    logprobs: null,
+                },
+            ],
+            created: created,
+            id: `chatcmpl-${faker.string.alphanumeric(30)}`,
+            model: `gpt-3.5-mock`,
+            object: 'chat.completion',
+            usage: {
+                completion_tokens: 17,
+                prompt_tokens: 57,
+                total_tokens: 74,
+            },
+        }
+    }
+
+    let functionCallingResponse = {
+        id: `chatcmpl-${faker.string.alphanumeric(30)}`,
+        object: 'chat.completion',
+        created: created,
+        model: 'gpt-3.5-mock',
+        choices: [
+            {
+                index: 0,
+                message: {
+                    role: 'assistant',
+                    content: null,
+                    function_call: {
+                        name: `${requestBody.functions[0].name}`,
+                        arguments: `${generateFunctionCallArguments(requestBody)}`,
+                    }
+                },
+                finish_reason: 'function_call'
+            }
+        ],
+        usage: {
+            prompt_tokens: 81,
+            completion_tokens: 19,
+            total_tokens: 100
+        }
+    };
+    return functionCallingResponse;
+}
+
+function generateFakeData(type, properties) {
+    if (type === 'string') {
+        return faker.lorem.words(5);
+    } else if (type === 'number') {
+        return faker.random.number();
+    } else if (type === 'array') {
+        const arrayItemsType = properties.items.type;
+        let arrayItems = [];
+        if (arrayItemsType === 'string') {
+            arrayItems = Array.from({ length: 5 }, () => faker.lorem.words(1));
+        } else if (arrayItemsType === 'object') {
+            const itemProperties = properties.items.properties;
+            arrayItems = Array.from({ length: 5 }, () => generateFakeData('object', { properties: itemProperties }));
+        }
+        return arrayItems;
+    } else if (type === 'object') {
+        const itemObject = {};
+        Object.entries(properties.properties).forEach(([itemName, itemDetails]) => {
+            itemObject[itemName] = generateFakeData(itemDetails.type, itemDetails);
+        });
+        return itemObject;
+    } else {
+        return faker.lorem.words(1);
+    }
+}
+/*
+* Generate function call arguments
+*/
+function generateFunctionCallArguments(requestBody) {
+    const { parameters } = requestBody.functions[0];
+    const argumentsObject = {};
+
+    Object.entries(parameters.properties).forEach(([paramName, paramDetails]) => {
+        argumentsObject[paramName] = generateFakeData(paramDetails.type, paramDetails);
+    });
+
+    return JSON.stringify(argumentsObject, null, 2);
+}
+
+module.exports = {
+    getResponce
+}