@nest-yalc-2/utils 1.0.0

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

@@ -0,0 +1,187 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,24 @@
+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__/nest.decorator.spec.ts

@@ -0,0 +1,29 @@
+import {
+  describe,
+  expect,
+  it,
+  jest,
+  beforeAll,
+  beforeEach,
+  test,
+} from '@jest/globals';
+import {
+  GetContext,
+  paramDecoratorToCreate,
+} from '../nestjs/nest.decorator.js';
+import { createMock } from '@golevelup/ts-jest';
+import { ExecutionContext } from '@nestjs/common';
+
+describe('Role decoratortest', () => {
+  const mockedCtx = createMock<ExecutionContext>();
+
+  it('Check GetContext', async () => {
+    const testData = GetContext(null, mockedCtx);
+    expect(testData).toBeDefined();
+  });
+
+  it('Check paramDecoratorToCreate ', async () => {
+    const testData = paramDecoratorToCreate(null, mockedCtx);
+    expect(testData).toEqual(mockedCtx);
+  });
+});

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

@@ -0,0 +1,26 @@
+import { describe, expect, it } from '@jest/globals';
+import { isProviderObject } from '../nestjs/nest.helper.js';
+
+describe('isProviderObject', () => {
+  it('should return true for a provider object', () => {
+    const provider = {
+      provide: 'PROVIDER',
+      useValue: 'VALUE',
+    };
+
+    expect(isProviderObject(provider)).toBe(true);
+  });
+
+  it('should return false for a non-provider object', () => {
+    const provider = {
+      provide: 'PROVIDER',
+      useValue: 'VALUE',
+    };
+
+    expect(isProviderObject(provider)).toBe(true);
+  });
+
+  it('should return false for a non-object', () => {
+    expect(isProviderObject('string')).toBe(false);
+  });
+});

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

@@ -0,0 +1,167 @@
+import { describe, expect, it } from '@jest/globals';
+
+import { objectMapper } from '../object-mapper.helper.js';
+
+describe('objectMapper', () => {
+  it('should map properties with the specified mapper', () => {
+    const input = {
+      a: 'A',
+      b: 'B',
+      c: 'C',
+    };
+
+    const mapper = {
+      a: 'x',
+      b: 'y',
+      c: false,
+    };
+
+    const output = objectMapper(input, mapper);
+
+    expect(output).toEqual({
+      x: 'A',
+      y: 'B',
+    });
+  });
+
+  it('should map properties with the specified mapper using transformer', () => {
+    const input = {
+      a: 'A',
+      b: 'B',
+    };
+
+    const mapper = {
+      a: {
+        x: {
+          transformer: (
+            inputObject: any,
+            propertyName: keyof typeof inputObject,
+          ) => inputObject[propertyName].toLowerCase(),
+        },
+      },
+      b: {
+        y: {
+          transformer: (
+            inputObject: any,
+            propertyName: keyof typeof inputObject,
+          ) => inputObject[propertyName].toLowerCase(),
+        },
+      },
+    };
+
+    const output = objectMapper(input, mapper);
+
+    expect(output).toEqual({
+      x: 'a',
+      y: 'b',
+    });
+  });
+
+  it('should not map excluded properties in object type mapProperty', () => {
+    const input = {
+      a: 'A',
+      b: 'B',
+    };
+
+    const mapper = {
+      a: {
+        x: {
+          exclude: true,
+        },
+        y: true,
+      },
+    };
+
+    const output = objectMapper(input, mapper);
+
+    expect(output).toEqual({
+      y: 'A',
+    });
+  });
+
+  it('should exclude properties with false value in object type mapProperty', () => {
+    const input = {
+      a: 'A',
+      b: 'B',
+    };
+
+    const mapper = {
+      a: {
+        x: false,
+        y: true,
+      },
+    };
+
+    const output = objectMapper(input, mapper);
+
+    expect(output).toEqual({
+      y: 'A',
+    });
+  });
+
+  it('should copy non-mapped properties when copyNonMappedProperties option is true', () => {
+    const input = {
+      a: 'A',
+      b: 'B',
+    };
+
+    const mapper = {
+      a: 'x',
+      z: {
+        y: null,
+      },
+    };
+
+    const output = objectMapper(input, mapper, {
+      copyNonMappedProperties: true,
+    });
+
+    expect(output).toEqual({
+      x: 'A',
+      b: 'B',
+    });
+  });
+
+  it('should not copy non-mapped properties when copyNonMappedProperties option is false', () => {
+    const input = {
+      a: 'A',
+      b: 'B',
+    };
+
+    const mapper = {
+      a: 'x',
+    };
+
+    const output = objectMapper(input, mapper, {
+      copyNonMappedProperties: false,
+    });
+
+    expect(output).toEqual({
+      x: 'A',
+    });
+  });
+
+  it('should call the $transformer function if defined in the input object', () => {
+    const input = {
+      a: 'A',
+      b: 'B',
+      $transformer: (
+        inputObject: { a: string; b: string },
+        outputObject: { x: string; y: string },
+      ) => {
+        outputObject.y = inputObject.b.toLowerCase();
+      },
+    };
+
+    const mapper = {
+      a: 'x',
+    };
+
+    const output = objectMapper(input, mapper);
+
+    expect(output).toEqual({
+      x: 'A',
+      y: 'b',
+    });
+  });
+});

package/src/__tests__/object-mapper.interceptor.spec.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from '@jest/globals';
+
+import { CallHandler, ExecutionContext } from '@nestjs/common';
+import { objectMapperInterceptor } from '../object-mapper.interceptor.js';
+import { ObjectMapperType } from '../object-mapper.helper.js';
+import { of } from 'rxjs';
+import { createMock } from '@golevelup/ts-jest';
+
+describe('objectMapperInterceptor', () => {
+  const input = {
+    a: 'A',
+    b: 'B',
+  };
+
+  const mapper: ObjectMapperType<typeof input, { x: string; y: string }> = {
+    a: 'x',
+    b: 'y',
+  };
+
+  const mockExecutionContext = createMock<ExecutionContext>();
+
+  const mockCallHandler: CallHandler = {
+    handle: () => of(input),
+  };
+
+  it('should map properties with the specified mapper', (done) => {
+    const interceptor = objectMapperInterceptor(mapper);
+    const instance = new interceptor();
+    instance
+      .intercept(mockExecutionContext, mockCallHandler)
+      .subscribe((result) => {
+        expect(result).toEqual({
+          x: 'A',
+          y: 'B',
+        });
+        done();
+      });
+  });
+
+  it('should handle array data and map each item', (done) => {
+    const interceptor = objectMapperInterceptor(mapper);
+    const instance = new interceptor();
+
+    const arrayData = [input, input];
+    const mockCallHandlerWithArray: CallHandler = {
+      handle: () => of(arrayData),
+    };
+
+    instance
+      .intercept(mockExecutionContext, mockCallHandlerWithArray)
+      .subscribe((result) => {
+        expect(result).toEqual([
+          {
+            x: 'A',
+            y: 'B',
+          },
+          {
+            x: 'A',
+            y: 'B',
+          },
+        ]);
+        done();
+      });
+  });
+
+  it('should use transformData if provided', (done) => {
+    const interceptor = objectMapperInterceptor(mapper, {
+      transformData: (data: any) => {
+        return { ...data, a: data.a.toLowerCase() };
+      },
+    });
+
+    const instance = new interceptor();
+    instance
+      .intercept(mockExecutionContext, mockCallHandler)
+      .subscribe((result) => {
+        expect(result).toEqual({
+          x: 'a',
+          y: 'B',
+        });
+        done();
+      });
+  });
+
+  it('should use callback if provided', (done) => {
+    const interceptor = objectMapperInterceptor(mapper, {
+      callback: (inputData: any, outputData: any) => {
+        return { ...outputData, z: inputData.a + inputData.b };
+      },
+    });
+
+    const instance = new interceptor();
+    instance
+      .intercept(mockExecutionContext, mockCallHandler)
+      .subscribe((result) => {
+        expect(result).toEqual({
+          x: 'A',
+          y: 'B',
+          z: 'AB',
+        });
+        done();
+      });
+  });
+});