Merge pull request #36 from Pythagora-io/unit_tests

Unit tests

Author: zvone187

README.md

@@ -1,6 +1,6 @@
 {
   "name": "pythagora",
-  "version": "0.0.59",
+  "version": "0.0.60",
   "author": {
     "name": "Zvonimir Sabljic",
     "email": "[email protected]"
@@ -15,7 +15,8 @@
   "main": "src/Pythagora.js",
   "scripts": {
     "publish-pythagora": "src/bin/publish.bash",
-    "prepublishOnly": "node src/bin/prepublish.js"
+    "prepublishOnly": "node src/bin/prepublish.js",
+    "test": "npx jest ./pythagora_tests/ --coverage"
   },
   "bin": {
     "pythagora": "src/bin/run.js"
@@ -24,15 +25,23 @@
     "node": ">=14.x"
   },
   "dependencies": {
+    "@babel/generator": "^7.22.3",
+    "@babel/parser": "^7.22.3",
+    "@babel/traverse": "^7.22.1",
     "@mswjs/interceptors": "^0.19.2",
     "axios": "^1.2.2",
+    "blessed": "^0.1.81",
     "body-parser": "^1.20.1",
+    "handlebars": "^4.7.7",
     "jest": "^29.5.0",
     "lodash": "^4.17.21",
     "nyc": "^15.1.0",
     "tryrequire": "^3.0.0",
     "uuid": "^9.0.0"
   },
+  "devDependencies": {
+    "mongodb": "^5.6.0"
+  },
   "contributors": [
     {
       "name": "Zvonimir Sabljic",

package.json

@@ -0,0 +1,39 @@
+const { cleanupGPTResponse } = require('../../../../../src/helpers/api');
+
+describe('cleanupGPTResponse', () => {
+  test('should remove code block markdown in the start and end', () => {
+    const input = "```\nThis is a test\n```";
+    const expected = 'This is a test\n';
+    expect(cleanupGPTResponse(input)).toBe(expected);
+  });
+
+  test('should return input unchanged if it does not begin with code block markdown', () => {
+    const input = 'This is another test';
+    const expected = 'This is another test';
+    expect(cleanupGPTResponse(input)).toBe(expected);
+  });
+
+  test('should handle empty input string', () => {
+    const input = '';
+    const expected = '';
+    expect(cleanupGPTResponse(input)).toBe(expected);
+  });
+
+  test('should handle input string with only code block markdown and nothing else', () => {
+    const input = '```\n```';
+    const expected = '';
+    expect(cleanupGPTResponse(input)).toBe(expected);
+  });
+
+  test('should handle multiple lines in code block markdown', () => {
+    const input = '```\nLine 1\nLine 2\nLine 3```';
+    const expected = 'Line 1\nLine 2\nLine 3';
+    expect(cleanupGPTResponse(input)).toBe(expected);
+  });
+
+  test('should not remove code block markdown from the middle of the string', () => {
+    const input = 'This is a test with ```code inside``` the string';
+    const expected = 'This is a test with ```code inside``` the string';
+    expect(cleanupGPTResponse(input)).toBe(expected);
+  });
+});

pythagora_tests/unit/src/helpers/api/cleanupGPTResponse.test.js

@@ -0,0 +1,36 @@
+describe("extractDataFromMongoRes tests", () => {
+  const { extractDataFromMongoRes } = require("../../../../../src/helpers/mongodb");
+
+  test("should return empty object for empty input", () => {
+    expect(extractDataFromMongoRes({})).toEqual({});
+  });
+
+  test("should return input object when not a CommandResult or special object", () => {
+    const input = { a: 1, b: 2 };
+    expect(extractDataFromMongoRes(input)).toEqual(input);
+  });
+
+  test("should return result object for CommandResult input", () => {
+    const input = {
+      result: { a: 1, b: 2 },
+      electionId: "electionId",
+      opTime: "opTime",
+      $clusterTime: "clusterTime",
+      operationTime: "operationTime",
+      __proto__: { constructor: { name: "CommandResult" } },
+    };
+    const expected = { a: 1, b: 2 };
+    expect(extractDataFromMongoRes(input)).toEqual(expected);
+  });
+
+  test("should return value object for special object input", () => {
+    const input = {
+      value: { a: 1, b: 2 },
+      lastErrorObject: "lastErrorObject",
+      ok: "ok",
+      __proto__: { constructor: { name: "Object" } },
+    };
+    const expected = { a: 1, b: 2 };
+    expect(extractDataFromMongoRes(input)).toEqual(expected);
+  });
+});

pythagora_tests/unit/src/helpers/mongodb/extractDataFromMongoRes.test.js

@@ -0,0 +1,60 @@
+const { jsonObjToMongo } = require("../../../../../src/helpers/mongodb");
+const {ObjectId} = require("mongodb");
+
+describe('jsonObjToMongo', () => {
+  test('should return correct output for an array input', () => {
+    const input = [{ _id: 'ObjectId("60f1e7b5d119076884d289ad")', createdAt: 'Date("2021-08-10T08:47:00.000Z")' }];
+    const expected = [{ _id: new ObjectId("60f1e7b5d119076884d289ad"), createdAt: new Date("2021-08-10T08:47:00.000Z") }];
+    expect(jsonObjToMongo(input)).toEqual(expected);
+  });
+
+  test('should return correct output for a nested object input', () => {
+    const input = { outer: { _id: 'ObjectId("60f1e7b5d119076884d289ad")', createdAt: 'Date("2021-08-10T08:47:00.000Z")' } };
+    const expected = { outer: { _id: new ObjectId("60f1e7b5d119076884d289ad"), createdAt: new Date("2021-08-10T08:47:00.000Z") } };
+    expect(jsonObjToMongo(input)).toEqual(expected);
+  });
+
+  test('should return correct output for a string input', () => {
+    const input = 'ObjectId("60f1e7b5d119076884d289ad")';
+    const expected = new ObjectId("60f1e7b5d119076884d289ad");
+    expect(jsonObjToMongo(input)).toEqual(expected);
+  });
+
+  test('should return correct output for a date string input', () => {
+    const input = 'Date("2021-08-10T08:47:00.000Z")';
+    const expected = new Date("2021-08-10T08:47:00.000Z");
+    expect(jsonObjToMongo(input)).toEqual(expected);
+  });
+
+  test('should return correct output for a RegExp string input', () => {
+    const input = '/test\\wstring/i';
+    const expected = /test\wstring/i;
+    expect(jsonObjToMongo(input)).toEqual(expected);
+  });
+
+  test('should return correct output for an ObjectID string input', () => {
+    const input = '60f1e7b5d119076884d289ad';
+    const expected = new ObjectId("60f1e7b5d119076884d289ad");
+    expect(jsonObjToMongo(input)).toEqual(expected);
+  });
+
+  test('should return the input for non-matching string input', () => {
+    const input = 'non-matching string input';
+    const expected = 'non-matching string input';
+    expect(jsonObjToMongo(input)).toEqual(expected);
+  });
+
+  test('should return undefined for undefined input', () => {
+    expect(jsonObjToMongo(undefined)).toBeUndefined();
+  });
+
+  test('should return null for null input', () => {
+    expect(jsonObjToMongo(null)).toBeNull();
+  });
+
+  test('should return the input for non-object, non-array input', () => {
+    const input = 123;
+    const expected = 123;
+    expect(jsonObjToMongo(input)).toEqual(expected);
+  });
+});

pythagora_tests/unit/src/helpers/mongodb/jsonObjToMongo.test.js

@@ -0,0 +1,50 @@
+const {ObjectId} = require("mongodb");
+const {mongoObjToJson} = require("../../../../../src/helpers/mongodb");
+
+describe("mongoObjToJson", () => {
+  test('should convert ObjectId to string format', () => {
+    const objectId = new ObjectId();
+    expect(mongoObjToJson(objectId)).toEqual(`ObjectId("${objectId.toString()}")`);
+  });
+
+  test('should convert Date to string format', () => {
+    const date = new Date();
+    expect(mongoObjToJson({ time: date })).toEqual({ time: `Date("${date.toISOString()}")` });
+  });
+
+  test('should convert RegExp to string format', () => {
+    const regex = /^test$/i;
+    expect(mongoObjToJson({ pattern: regex })).toEqual({ pattern: `RegExp("${regex.toString()}")` });
+  });
+
+  test('should handle nested objects and arrays', () => {
+    const objectId = new ObjectId();
+    const date = new Date();
+    const regex = new RegExp(/^test$/i);
+    const input = {
+      _id: objectId,
+      dates: [{ time: date }],
+      regexArr: [regex],
+      nestedObj: { _id: objectId, time: date, patternRegex: regex },
+    };
+    const expectedResult = {
+      _id: `ObjectId("${objectId.toString()}")`,
+      dates: [{ time: `Date("${date.toISOString()}")` }],
+      regexArr: [`RegExp("${regex.toString()}")`],
+      nestedObj: {
+        _id: `ObjectId("${objectId.toString()}")`,
+        time: `Date("${date.toISOString()}")`,
+        patternRegex: `RegExp("${regex.toString()}")`,
+      },
+    };
+    expect(mongoObjToJson(input)).toEqual(expectedResult);
+  });
+
+  test('should return null if input is null', () => {
+    expect(mongoObjToJson(null)).toBeNull();
+  });
+
+  test('should return undefined if input is undefined', () => {
+    expect(mongoObjToJson(undefined)).toBeUndefined();
+  });
+});

pythagora_tests/unit/src/helpers/mongodb/mongoObjToJson.test.js

@@ -0,0 +1,49 @@
+describe('searchAllModuleFolders', () => {
+  const fs = require('fs');
+  const path = require('path');
+  const { searchAllModuleFolders } = require("../../../../../src/helpers/starting");
+
+  test('returns empty object when no modules', () => {
+    const result = searchAllModuleFolders('.', []);
+    expect(result).toEqual({});
+  });
+
+  test('returns empty module paths when modules not found', () => {
+    const result = searchAllModuleFolders('.', ['nonexistent']);
+    expect(result).toEqual({ nonexistent: [] });
+  });
+
+  test('finds nested node_modules directories', () => {
+    const module1Path = path.join('.', 'testdir', 'node_modules', 'module1');
+    fs.mkdirSync(module1Path, { recursive: true });
+    const result = searchAllModuleFolders('.', ['module1']);
+    expect(result).toEqual({ module1: [module1Path] });
+    fs.rmdirSync(path.join('.', 'testdir'), { recursive: true });
+  });
+
+  test('finds multiple node_modules directories for multiple modules', () => {
+    const module1Path = path.join('.', 'testdir', 'node_modules', 'module1');
+    const module2Path = path.join('.', 'testdir', 'node_modules', 'module2');
+
+    fs.mkdirSync(module1Path, { recursive: true });
+    fs.mkdirSync(module2Path, { recursive: true });
+
+    const result = searchAllModuleFolders('.', ['module1', 'module2']);
+    expect(result).toEqual({
+      module1: [module1Path],
+      module2: [module2Path]
+    });
+
+    fs.rmdirSync(path.join('.', 'testdir'), { recursive: true });
+  });
+
+  test('finds deeply nested node_modules directories', () => {
+    const module1Path = path.join('.', 'testdir', 'subdir', 'node_modules', 'module1');
+    fs.mkdirSync(module1Path, { recursive: true });
+
+    const result = searchAllModuleFolders('.', ['module1']);
+    expect(result).toEqual({ module1: [module1Path] });
+
+    fs.rmdirSync(path.join('.', 'testdir'), { recursive: true });
+  });
+});

pythagora_tests/unit/src/helpers/starting/searchAllModuleFolders.test.js

@@ -0,0 +1,45 @@
+describe('checkDirectoryExists', () => {
+
+  test('should return true when directory exists', async () => {
+    const { checkDirectoryExists } = require('../../../../../src/utils/common.js');
+    const fs = require('fs');
+
+    fs.mkdirSync('test-dir');
+    const exists = await checkDirectoryExists('test-dir');
+    fs.rmdirSync('test-dir');
+
+    expect(exists).toBe(true);
+  });
+
+  test('should return false when directory does not exist', async () => {
+    const { checkDirectoryExists } = require('../../../../../src/utils/common.js');
+
+    const exists = await checkDirectoryExists('nonexistent-dir');
+
+    expect(exists).toBe(false);
+  });
+
+  test('should return false when provided path is to a file', async () => {
+    const { checkDirectoryExists } = require('../../../../../src/utils/common.js');
+    const fs = require('fs');
+
+    fs.writeFileSync('test-file.txt', 'test contents');
+    const exists = await checkDirectoryExists('test-file.txt');
+    fs.unlinkSync('test-file.txt');
+
+    expect(exists).toBe(false);
+  });
+
+  test('should handle null input', async () => {
+    const { checkDirectoryExists } = require('../../../../../src/utils/common.js');
+
+    await expect(checkDirectoryExists(null)).rejects.toThrow();
+  });
+
+  test('should handle undefined input', async () => {
+    const { checkDirectoryExists } = require('../../../../../src/utils/common.js');
+
+    await expect(checkDirectoryExists(undefined)).rejects.toThrow();
+  });
+
+});