@nest-yalc-2/utils 1.0.0 → 2.1.0

package/src/__tests__/enum.helper.spec.ts

@@ -1,53 +0,0 @@
-import {
-  describe,
-  expect,
-  it,
-  jest,
-  beforeAll,
-  beforeEach,
-  test,
-} from '@jest/globals';
-
-import {
-  belongsToEnum,
-  mergeEnums,
-  getEnumValueByEnumKey,
-} from '../enum.helper.js';
-import { TestEnum1, TestEnum2 } from '../__mocks__/enum.mock.js';
-
-test('belongsToEnum should check if a value belongs to a specific Enum', () => {
-  enum TestEnum {
-    TEST = 'test',
-  }
-
-  let result = belongsToEnum(TestEnum, 'test');
-  expect(result).toBeTruthy();
-
-  result = belongsToEnum(TestEnum, 'TEST');
-  expect(result).toBeFalsy();
-});
-
-test('mergeEnums should merge 2 enums', () => {
-  const result = mergeEnums(TestEnum1, TestEnum2);
-  const compareWith = {
-    ...TestEnum1,
-    ...TestEnum2,
-  };
-
-  expect(result).toMatchObject(compareWith);
-});
-
-test('getEnumValueByEnumKey should return value of enum 1 by key of enum 2', () => {
-  const result = getEnumValueByEnumKey(TestEnum1, Object.keys(TestEnum2)[0]);
-  expect(result).toBe('test2');
-});
-
-test('getEnumValueByEnumKey should return value of enum 1 by key of enum 2', () => {
-  const result = getEnumValueByEnumKey(TestEnum1, Object.keys(TestEnum2)[1]);
-  expect(result).toBeUndefined();
-});
-
-test('getEnumValueByEnumKey should return null when no undefined key is provided ', () => {
-  const result = getEnumValueByEnumKey(TestEnum1, undefined);
-  expect(result).toBeUndefined();
-});

package/src/__tests__/env.helper.spec.ts

@@ -1,68 +0,0 @@
-import {
-  describe,
-  expect,
-  it,
-  jest,
-  beforeAll,
-  beforeEach,
-  test,
-} from '@jest/globals';
-
-import { envIsTrue, envToArray, isProduction } from '../env.helper.js';
-import { envTestHelper } from '@nest-yalc-2/jest';
-
-describe('environment helper test', () => {
-  it('should convert a comma separated list to an array', () => {
-    process.env.Test = 'apple,pear,pineapple,cherry';
-    const res = envToArray('Test');
-    expect(res).toEqual(['apple', 'pear', 'pineapple', 'cherry']);
-  });
-
-  it('should return an empty array when the var is an empty string', () => {
-    process.env.Test = '';
-    const res = envToArray('Test');
-    expect(res).toEqual([]);
-  });
-
-  it('should return an empty array when the var is missing', () => {
-    delete process.env.Test;
-    const res = envToArray('Test');
-    expect(res).toEqual([]);
-  });
-
-  it('should return false for "undefined"', () => {
-    expect(envIsTrue(undefined)).toEqual(false);
-  });
-
-  it('should return true for "true"', () => {
-    expect(envIsTrue('true')).toEqual(true);
-  });
-
-  it('should return true for "1"', () => {
-    expect(envIsTrue('1')).toEqual(true);
-  });
-
-  it('should return true for "on"', () => {
-    expect(envIsTrue('on')).toEqual(true);
-  });
-
-  it('should return true if is production"', () => {
-    const env = envTestHelper(process.env);
-    env.setEnv('NODE_ENV', 'production');
-    expect(isProduction(false)).toBeTruthy();
-
-    env.setEnv('NODE_ENV', 'somethingelse');
-    expect(isProduction(true)).toBeTruthy();
-    env.reset();
-  });
-
-  it('should return false if is not production"', () => {
-    const env = envTestHelper(process.env);
-    env.setEnv('NODE_ENV', 'pipeline');
-    expect(isProduction()).toBeFalsy();
-
-    env.setEnv('NODE_ENV', 'somethingelse');
-    expect(isProduction(false)).toBeFalsy();
-    env.reset();
-  });
-});

package/src/__tests__/error.helper.spec.ts

@@ -1,20 +0,0 @@
-import {
-  describe,
-  expect,
-  it,
-  jest,
-  beforeAll,
-  beforeEach,
-  test,
-} from '@jest/globals';
-import { throwWrap } from '../error.helper.js';
-
-describe('Test errors helpers', () => {
-  it('should throw an error without wraping it', () => {
-    const fixedErrorMessage = `i'm an error`;
-    const fixedError = new Error(fixedErrorMessage);
-
-    expect(() => throwWrap(fixedErrorMessage)).toThrow(fixedErrorMessage);
-    expect(() => throwWrap(fixedError)).toThrow(fixedErrorMessage);
-  });
-});

package/src/__tests__/faker-helper.spec.ts

@@ -1,187 +0,0 @@
-import {
-  describe,
-  expect,
-  it,
-  jest,
-  beforeAll,
-  beforeEach,
-  test,
-} from '@jest/globals';
-
-import {
-  DEF_FAKER_MAX_TIME,
-  FakerHelper,
-} from '../faker-helper.js';
-import { faker } from '@faker-js/faker';
-
-enum testEnum {
-  KEY = 'value',
-  VALUE_KEY = 'test',
-}
-describe('faker helper test', () => {
-  // Don't do beforeEach, since we need a single instance
-  const fakerHelper = new FakerHelper();
-  it('should generate a person object, with first-, lastName, gender and email', () => {
-    jest.spyOn(faker.person, 'firstName').mockReturnValueOnce('Elon');
-    jest.spyOn(faker.person, 'lastName').mockReturnValueOnce('Musk');
-    jest
-      .spyOn(faker.internet, 'email')
-      .mockReturnValueOnce('Elon_Musk@gmail.test');
-    const person = fakerHelper.createPerson();
-    expect(person).toBeDefined();
-    expect(person.email).toBeDefined();
-    expect(person.firstName).toBeDefined();
-    expect(person.lastName).toBeDefined();
-    expect(person.gender).toBeDefined();
-  });
-
-  it('should not reuse already generated names', () => {
-    jest.spyOn(faker.person, 'firstName').mockReturnValueOnce('Elon');
-    jest.spyOn(faker.person, 'lastName').mockReturnValueOnce('Musk');
-    jest
-      .spyOn(faker.internet, 'email')
-      .mockReturnValueOnce('Elon_Musk@gmail.test');
-    const person = fakerHelper.createPerson();
-    expect(person).toBeDefined();
-    expect(person.email).not.toEqual('ElonMusk@google.test');
-    expect(person.firstName).toBeDefined();
-    expect(person.lastName).toBeDefined();
-    expect(person.gender).toBeDefined();
-  });
-
-  it('should be able to use first and lastname to generate email', () => {
-    const firstName = 'Elon';
-    const lastName = 'Musk';
-
-    const email = fakerHelper.generateNewEmail(firstName, lastName);
-    expect(email).toContain(firstName);
-
-    // Not validating lastName as the Faker library may not use it
-    // @url https://github.com/Marak/faker.js/issues/791
-  });
-
-  it('should be able to use first name, lastname and provider to generate email', () => {
-    const firstName = 'Elon';
-    const lastName = 'Musk';
-    const provider = 'tesla.com';
-
-    const email = fakerHelper.generateNewEmail(firstName, lastName, provider);
-    expect(email).toContain(firstName);
-    expect(email).toContain(provider);
-  });
-
-  it('should generate unique emails on multiple calls', () => {
-    const firstName = 'Elon';
-    const lastName = 'Musk';
-    const provider = 'dogecoin.lol';
-
-    const email1 = fakerHelper.generateNewEmail(firstName, lastName, provider);
-    const email2 = fakerHelper.generateNewEmail(firstName, lastName, provider);
-    const email3 = fakerHelper.generateNewEmail(firstName, lastName, provider);
-
-    expect(email1).not.toEqual(email2);
-    expect(email2).not.toEqual(email3);
-  });
-
-  it('should fall back when unique email generation exceeds the time limit', () => {
-    const helper = new FakerHelper();
-    jest
-      .spyOn(faker.internet, 'email')
-      .mockReturnValueOnce('same@gmail.test');
-    helper.generateNewEmail('Elon', 'Musk', 'gmail.test');
-
-    jest
-      .spyOn(Date, 'now')
-      .mockReturnValueOnce(0)
-      .mockReturnValueOnce(DEF_FAKER_MAX_TIME + 1);
-    jest
-      .spyOn(faker.internet, 'email')
-      .mockReturnValueOnce('same@gmail.test')
-      .mockReturnValueOnce('fallback@gmail.test');
-
-    expect(helper.generateNewEmail('Elon', 'Musk', 'gmail.test')).toBe(
-      'fallback@gmail.test',
-    );
-    expect(
-      (
-        helper as unknown as { generatedEmails: Set<string> }
-      ).generatedEmails.has('fallback@gmail.test'),
-    ).toBe(true);
-  });
-
-  it('should be able to generate a valid birthDate between age 18 and 100 (YYYY-MM-DD) (min age)', () => {
-    const currentDate = new Date();
-    // make a copy instead of reusing pointer
-    const returnDate = new Date(currentDate.toUTCString());
-    jest.spyOn(faker.date, 'past').mockReturnValue(returnDate);
-
-    const currentYear = currentDate.getUTCFullYear();
-    const currentMonth = currentDate.getUTCMonth() + 1;
-    const currentDay = currentDate.getUTCDate();
-
-    const birthDate = fakerHelper.randomBirthDate();
-    const splitted = birthDate.split('-');
-
-    expect(parseInt(splitted[0])).toEqual(currentYear - 18);
-
-    // TODO: fix it for the edge cases (february, 00:00 etc.)
-
-    // expect(parseInt(splitted[1])).toEqual(currentMonth);
-    // expect(parseInt(splitted[2])).toEqual(currentDay);
-  });
-
-  it('should be able to generate a valid birthDate between age 18 and 100 (YYYY-MM-DD) (max age)', () => {
-    const currentDate = new Date();
-    // make a copy instead of reusing pointer
-    const returnDate = new Date(currentDate.valueOf());
-    returnDate.setUTCFullYear(returnDate.getUTCFullYear() - 82);
-    jest.spyOn(faker.date, 'past').mockReturnValue(returnDate);
-
-    const currentYear = currentDate.getUTCFullYear();
-    const currentMonth = currentDate.getUTCMonth() + 1;
-    // const currentDay = currentDate.getUTCDate();
-
-    const birthDate = fakerHelper.randomBirthDate();
-    const splitted = birthDate.split('-');
-
-    expect(parseInt(splitted[0])).toEqual(currentYear - 100);
-
-    // TODO: fix it for the edge cases (february, 00:00 etc.)
-
-    // expect(parseInt(splitted[1])).toEqual(currentMonth);
-    // expect(parseInt(splitted[2])).toEqual(currentDay);
-  });
-
-  it('should generate valid lock dates in the past', () => {
-    jest.clearAllMocks();
-    jest.spyOn(faker.number, 'int').mockReturnValue(0 as never);
-    expect(fakerHelper.randomLockDate().valueOf()).toBeLessThan(Date.now());
-  });
-
-  it('should generate valid lock dates in the future', () => {
-    jest.clearAllMocks();
-    jest.spyOn(faker.number, 'int').mockReturnValueOnce(1 as never);
-    jest
-      .spyOn(faker.date, 'future')
-      .mockReturnValueOnce(new Date(Date.now() + 1000));
-    expect(fakerHelper.randomLockDate().valueOf()).toBeGreaterThan(Date.now());
-  });
-
-  it('should return undefined when no lock is present', () => {
-    jest.clearAllMocks();
-    jest.spyOn(faker.number, 'int').mockReturnValue(2 as never);
-    expect(fakerHelper.randomLockDate()).toEqual(undefined);
-  });
-
-  it('should return the first element of the enum', () => {
-    jest.clearAllMocks();
-    jest.spyOn(faker.number, 'int').mockReturnValue(0 as never);
-    expect(fakerHelper.randomFromEnum(testEnum)).toEqual(testEnum.KEY);
-  });
-
-  it('should return a decimal', () => {
-    jest.clearAllMocks();
-    jest.spyOn(faker.number, 'float').mockReturnValue(3.14 as never);
-    expect(fakerHelper.randomDecimal(0, 42, 2)).toEqual('3.14');
-  });
-});

package/src/__tests__/files.helper.spec.ts

@@ -1,22 +0,0 @@
-import {
-  describe,
-  expect,
-  it,
-  jest,
-  beforeAll,
-  beforeEach,
-  test,
-} from '@jest/globals';
-
-import { ___dirname, __filename } from '../files.helper.js';
-
-describe('Test files.helper.ts', () => {
-  it('should run __filename', () => {
-    expect(__filename('file:///C:/Users/nn/Desktop/code/nestjs-yalc/utils/src/__tests__/files.helper.spec.ts')).toBeDefined();
-  });
-
-  it('should run ___dirname', () => {
-    const dir = ___dirname('file:///C:/Users/nn/Desktop/code/nestjs-yalc/utils/src/__tests__/files.helper.spec.ts');
-    expect(dir).toContain('utils');
-  });
-});

package/src/__tests__/http.helper.spec.ts

@@ -1,15 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-
-import { getHttpStatusDescription } from '../http.helper.js';
-
-describe('Test http.helper.ts', () => {
-  it('should run getHttpStatusDescription', () => {
-    expect(getHttpStatusDescription(200)).toBe(
-      '200: Request successful and response provided.',
-    );
-  });
-
-  it('should work with the fallback', () => {
-    expect(getHttpStatusDescription(999)).toBe('Unknown status code');
-  });
-});

package/src/__tests__/interval.helper.spec.ts

@@ -1,29 +0,0 @@
-import {
-  describe,
-  expect,
-  it,
-  jest,
-  beforeAll,
-  beforeEach,
-  test,
-} from '@jest/globals';
-import { IntervalHelper } from '../interval.helper.js';
-
-describe('interval helper test', () => {
-  it('Generates interval of 1 day with miliseconds', () => {
-    const interval = IntervalHelper.createOneDayInterval();
-
-    expect(interval).toEqual(86400000);
-  });
-
-  it('Generates 1 second interval', () => {
-    const interval = IntervalHelper.createOneSecondInterval();
-
-    expect(interval).toEqual(1000);
-  });
-  it('Generates interval of 5 mins with miliseconds', () => {
-    const interval = IntervalHelper.createFiveMinutesInterval();
-
-    expect(interval).toEqual(300000);
-  });
-});

package/src/__tests__/math.helper.spec.ts

@@ -1,24 +0,0 @@
-import {
-  describe,
-  expect,
-  it,
-  jest,
-  beforeAll,
-  beforeEach,
-  test,
-} from '@jest/globals';
-import { isScientificNotation } from '../math.helper.js';
-
-describe('math helper test', () => {
-  it('should return true for scientific notation', () => {
-    const result = isScientificNotation(0.000000002);
-
-    expect(result).toBeTruthy();
-  });
-
-  it('should return false for non scientific notation', () => {
-    const result = isScientificNotation(0.002);
-
-    expect(result).toBeFalsy();
-  });
-});

package/src/__tests__/object.helper.spec.ts

@@ -1,181 +0,0 @@
-import { describe, expect, it } from '@jest/globals';
-import {
-  _deepMerge,
-  deepMerge,
-  deepMergeWithoutArrayConcat,
-  getObjectId,
-  isObject,
-  isObjectStrict,
-  objectsHaveSameKeys,
-  objectSetProp,
-} from '../object.helper.js';
-
-describe('test object.helper.ts', () => {
-  it('should set a property correctly', () => {
-    const obj: any = {};
-    objectSetProp(obj, 'test', 1);
-    expect(obj.test).toBe(1);
-  });
-
-  it('should set a subproperty correctly', () => {
-    const obj: any = {};
-    const res = objectSetProp(obj, 'test.foo', 1);
-    expect(obj.test.foo).toBe(1);
-    expect(res.test.foo).toBe(1);
-  });
-
-  it('should set a subproperty on an existing parent object', () => {
-    const obj: any = { test: {} };
-    const res = objectSetProp(obj, 'test.foo', 1);
-    expect(res.test.foo).toBe(1);
-  });
-
-  it('should merge 2 objects correctly', () => {
-    const obj1 = { test: 1, sub: { test2: 2 }, array: [1, 2, 4] };
-    const obj2 = {
-      test: 2,
-      sub: { test3: 3 },
-      new: {
-        test4: 4,
-      },
-      array: [3, 4, 5],
-    };
-
-    const res = deepMerge(obj1, obj2);
-
-    expect(res).toStrictEqual({
-      test: 2,
-      sub: {
-        test2: 2,
-        test3: 3,
-      },
-      new: {
-        test4: 4,
-      },
-      array: [1, 2, 4, 3, 5],
-    });
-  });
-
-  it('should merge objects  correctly (last undefined)', () => {
-    const obj1 = { test: 1, sub: { test2: 2 } };
-
-    const res = deepMerge(obj1);
-
-    expect(res).toStrictEqual({
-      test: 1,
-      sub: {
-        test2: 2,
-      },
-    });
-  });
-
-  it('should skip merge work for non-object targets and sources', () => {
-    const inherited = Object.create({ inherited: true });
-    expect(_deepMerge(true, null as any, { test: 1 })).toBeNull();
-    expect(deepMerge({}, undefined as any)).toStrictEqual({});
-    expect(deepMerge({}, inherited)).toStrictEqual({});
-  });
-
-  it('should merge objects  correctly with array concat', () => {
-    const obj1 = { test: 1, sub: { test2: ['1', '2'] } };
-    const obj2 = { test: 2, sub: { test2: ['3','2'] } };
-
-    const res = deepMerge(obj1,obj2);
-
-    expect(res).toStrictEqual({
-      test: 2,
-      sub: {
-        test2: ['1', '2', '3'],
-      },
-    });
-  });
-
-  it('should merge objects  correctly without array concat', () => {
-    const obj1 = { test: 1, sub: { test2: ['1', '2'] } };
-    const obj2 = { test: 2, sub: { test2: ['3','2'] } };
-
-    const res = deepMergeWithoutArrayConcat(obj1,obj2);
-
-    expect(res).toStrictEqual({
-      test: 2,
-      sub: {
-        test2: ['3', '2'],
-      },
-    });
-  });
-
-  it('should merge objects  correctly with functions', () => {
-    const obj1 = { test: 1};
-    const obj2 = { test: 2, sub: { test2: () => {} } };
-
-    const res = deepMerge(obj1,obj2);
-
-    expect(res).toStrictEqual({
-      test: 2,
-      sub: {
-        test2: expect.any(Function),
-      },
-    });
-  });
-
-  it('should isObjectStrict return true', () => {
-    expect(isObjectStrict({})).toBe(true);
-    expect(isObjectStrict({ test: 1 })).toBe(true);
-    expect(isObjectStrict({ test: 1, sub: { test2: 2 } })).toBe(true);
-    expect(isObjectStrict(new Object('something'))).toBe(true);
-  });
-
-  it('should isObjectStrict return false', () => {
-    expect(isObjectStrict(null)).toBe(false);
-    expect(isObjectStrict(undefined)).toBe(false);
-    expect(isObjectStrict(1)).toBe(false);
-    expect(isObjectStrict('string')).toBe(false);
-    expect(isObjectStrict(true)).toBe(false);
-    expect(isObjectStrict(false)).toBe(false);
-    expect(isObjectStrict([1, 2, 3])).toBe(false);
-    expect(isObjectStrict(new Date())).toBe(false);
-    expect(isObjectStrict(() => {})).toBe(false);
-  });
-
-  it('should isObject return true', () => {
-    expect(isObject({})).toBe(true);
-    expect(isObject({ test: 1 })).toBe(true);
-    expect(isObject({ test: 1, sub: { test2: 2 } })).toBe(true);
-    expect(isObject(new Object('something'))).toBe(true);
-    expect(isObject(null)).toBe(false);
-    expect(isObject(() => {})).toBe(true);
-  });
-
-  it('should isObject return false', () => {
-    expect(isObject(undefined)).toBe(false);
-    expect(isObject(1)).toBe(false);
-    expect(isObject('string')).toBe(false);
-    expect(isObject(true)).toBe(false);
-    expect(isObject(false)).toBe(false);
-    expect(isObject([1, 2, 3])).toBe(false);
-  });
-
-
-  it('should getObjectId return the correct id', () => {
-    const obj = { id: 1 };
-    let res = getObjectId(obj);
-    expect(res).toBeGreaterThan(0);
-    // it should give the same result
-    expect(getObjectId(obj)).toBe(res);
-    // different objects instead should give different results
-    expect(getObjectId({ id: 1 })).not.toBe(1);
-  });
-
-
-  it('should objectsHaveSameKeys return true', () => {
-    const obj1 = { test: 1, sub: { test2: 2 } };
-    const obj2 = { test: 1, sub: { test2: 2 } };
-    expect(objectsHaveSameKeys(obj1, obj2)).toBe(true);
-  });
-
-  it('should objectsHaveSameKeys return false', () => {
-    const obj1 = { test: 1, sub: { test2: 2 } };
-    const obj2 = { test: 1, sub2: { test2: 2 } };
-    expect(objectsHaveSameKeys(obj1, obj2)).toBe(false);
-  });
-});

package/src/__tests__/plugin.helper.spec.ts

@@ -1,85 +0,0 @@
-import { WithPluginSystem, Plugin, PluginMethods } from '../plugin.helper.js';
-import { describe, it, expect, beforeEach, jest } from '@jest/globals';
-
-describe('WithPluginSystem', () => {
-  class TestMethods implements PluginMethods {
-    [key: string]: { (...args: any[]): void } | undefined;
-    testMethod1?: (...args: any[]) => void;
-    testMethod2?: (...args: any[]) => void;
-  }
-
-  class TestBase {}
-
-  it('should create a PluginSystemWrapper with default base class', () => {
-    const PluginSystemWrapper = WithPluginSystem<TestMethods>();
-    expect(new PluginSystemWrapper()).toBeInstanceOf(PluginSystemWrapper);
-  });
-
-  it('should create a PluginSystemWrapper with a custom base class', () => {
-    const PluginSystemWrapper = WithPluginSystem<TestMethods>(TestBase);
-    expect(new PluginSystemWrapper()).toBeInstanceOf(TestBase);
-  });
-
-  describe('PluginSystemWrapper', () => {
-    let PluginSystemWrapper: any;
-    let pluginSystem: any;
-
-    beforeEach(() => {
-      PluginSystemWrapper = WithPluginSystem<TestMethods>();
-      pluginSystem = new PluginSystemWrapper();
-    });
-
-    describe('registerPlugin', () => {
-      it('should register a plugin', () => {
-        const plugin: Plugin<TestMethods> = { pluginMethods: {} };
-        pluginSystem.registerPlugin(plugin);
-        expect(pluginSystem.plugins).toContain(plugin);
-      });
-    });
-
-    describe('unregisterPlugin', () => {
-      it('should unregister a plugin', () => {
-        const plugin: Plugin<TestMethods> = { pluginMethods: {} };
-        pluginSystem.registerPlugin(plugin);
-        pluginSystem.unregisterPlugin(plugin);
-        expect(pluginSystem.plugins).not.toContain(plugin);
-      });
-    });
-
-    describe('invokePlugins', () => {
-      it('should invoke the correct method on all plugins', () => {
-        const plugin1: Plugin<TestMethods> = {
-          pluginMethods: {
-            testMethod1: jest.fn(),
-          },
-        };
-        const plugin2: Plugin<TestMethods> = {
-          pluginMethods: {
-            testMethod1: jest.fn(),
-          },
-        };
-        pluginSystem.registerPlugin(plugin1);
-        pluginSystem.registerPlugin(plugin2);
-        pluginSystem.invokePlugins('testMethod1', 'arg1', 'arg2');
-
-        expect(plugin1.pluginMethods.testMethod1).toHaveBeenCalledWith(
-          'arg1',
-          'arg2',
-        );
-        expect(plugin2.pluginMethods.testMethod1).toHaveBeenCalledWith(
-          'arg1',
-          'arg2',
-        );
-      });
-
-      it('should not throw if a method is undefined', () => {
-        const plugin: Plugin<TestMethods> = { pluginMethods: {} };
-        pluginSystem.registerPlugin(plugin);
-
-        expect(() =>
-          pluginSystem.invokePlugins('testMethod1', 'arg1'),
-        ).not.toThrow();
-      });
-    });
-  });
-});