Added unit tests

Author: Zvonimir Sabljic

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

@@ -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/mongodb/extractDataFromMongoRes.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/jsonObjToMongo.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/mongoObjToJson.test.js

@@ -0,0 +1,50 @@
+import {ObjectId} from "mongodb";
+import {mongoObjToJson} from "../../../../../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 = /^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/starting/searchAllModuleFolders.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/utils/common/checkDirectoryExists.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();
+  });
+
+});

pythagora_tests/unit/src/utils/common/compareJson.test.js

@@ -0,0 +1,109 @@
+describe('compareJson tests', () => {
+  const { compareJson } = require('../../../../../src/utils/common.js');
+
+  test('Should return true for identical objects', () => {
+    const obj1 = { key: 'value' };
+    const obj2 = { key: 'value' };
+    expect(compareJson(obj1, obj2)).toBe(true);
+  });
+
+  test('Should return false for different objects', () => {
+    const obj1 = { key: 'value' };
+    const obj2 = { key: 'differentValue' };
+    expect(compareJson(obj1, obj2)).toBe(false);
+  });
+
+  test('Should return true for identical arrays', () => {
+    const arr1 = [1, 2, 3];
+    const arr2 = [1, 2, 3];
+    expect(compareJson(arr1, arr2)).toBe(true);
+  });
+
+  test('Should return false for different arrays', () => {
+    const arr1 = [1, 2, 3];
+    const arr2 = [1, 2, 4];
+    expect(compareJson(arr1, arr2)).toBe(false);
+  });
+
+  test('Should return true for identical nested objects', () => {
+    const obj1 = { key: { nestedKey: 'value' } };
+    const obj2 = { key: { nestedKey: 'value' } };
+    expect(compareJson(obj1, obj2)).toBe(true);
+  });
+
+  test('Should return false for different nested objects', () => {
+    const obj1 = { key: { nestedKey: 'value' } };
+    const obj2 = { key: { nestedKey: 'differentValue' } };
+    expect(compareJson(obj1, obj2)).toBe(false);
+  });
+
+  test('Should return true for identical objects with Date', () => {
+    const date = new Date();
+    const obj1 = { key: date };
+    const obj2 = { key: date };
+    expect(compareJson(obj1, obj2)).toBe(true);
+  });
+
+  test('Should return false for different objects with Date', () => {
+    const date1 = new Date();
+    const date2 = new Date(date1.getTime() + 1000);
+    const obj1 = { key: date1 };
+    const obj2 = { key: date2 };
+    expect(compareJson(obj1, obj2)).toBe(true);
+  });
+
+  test('Should return true for identical JSON strings', () => {
+    const jsonString1 = JSON.stringify({ key: 'value' });
+    const jsonString2 = JSON.stringify({ key: 'value' });
+    expect(compareJson(jsonString1, jsonString2)).toBe(true);
+  });
+
+  test('Should return false for different JSON strings', () => {
+    const jsonString1 = JSON.stringify({ key: 'value' });
+    const jsonString2 = JSON.stringify({ key: 'differentValue' });
+    expect(compareJson(jsonString1, jsonString2)).toBe(false);
+  });
+
+  test('Should return true for mixed identical data types', () =>{
+    const date = new Date();
+    const data1 = { key1: 'value', key2: date, key3: [1, 2, 3] };
+    const data2 = { key1: 'value', key2: date, key3: [1, 2, 3] };
+    expect(compareJson(data1, data2)).toBe(true);
+  });
+
+  test('Should return true for strict mode with identical ObjectId strings', () => {
+    const idString1 = 'ObjectId("123456789012345678901234")';
+    const idString2 = 'ObjectId("123456789012345678901234")';
+    expect(compareJson(idString1, idString2, true)).toBe(true);
+  });
+
+  test('Should return false for strict mode with different ObjectId strings', () => {
+    const idString1 = 'ObjectId("123456789012345678901234")';
+    const idString2 = 'ObjectId("123456789012345678901235")';
+    expect(compareJson(idString1, idString2, true)).toBe(false);
+  });
+
+  test('Should return true for non-strict mode with different ObjectId strings', () => {
+    const idString1 = 'ObjectId("123456789012345678901234")';
+    const idString2 = 'ObjectId("123456789012345678901235")';
+    expect(compareJson(idString1, idString2, false)).toBe(true);
+  });
+
+  test('Should return false for comparing an object and an array', () => {
+    const obj = { key: 'value' };
+    const arr = ['value'];
+    expect(compareJson(obj, arr)).toBe(false);
+  });
+
+  test('Should return false for comparing an object and a string', () => {
+    const obj = { key: 'value' };
+    const str = 'value';
+    expect(compareJson(obj, str)).toBe(false);
+  });
+
+  test('Should return false for comparing an array and a string', () => {
+    const arr = ['value'];
+    const str = 'value';
+    expect(compareJson(arr, str)).toBe(false);
+  });
+});