lesgo 0.7.8 → 2.1.0

package/src/services/__tests__/LoggerService.spec.js

@@ -1,252 +0,0 @@
-/* eslint no-console: 0 */
-
-import LoggerService from '../LoggerService';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('ServicesGroup: test LoggerService instantiation', () => {
-  it('test instantiate default LoggerService', () => {
-    const logger = new LoggerService();
-
-    expect(logger.logger).toBe('lesgo-logger');
-    expect(logger.meta).toMatchObject({});
-    expect(logger.transports).toEqual(expect.arrayContaining([]));
-    expect(logger.logLevels).toMatchObject({
-      error: 0,
-      warn: 1,
-      info: 2,
-      debug: 3,
-    });
-  });
-
-  it('test instantiate LoggerService with console transport', () => {
-    const logger = new LoggerService({
-      transports: [
-        {
-          logType: 'console',
-          level: 'info',
-          config: {
-            getCreatedAt: true,
-          },
-        },
-      ],
-    });
-
-    expect(logger.logger).toBe('lesgo-logger');
-    expect(logger.meta).toMatchObject({});
-    expect(logger.transports[0]).toMatchObject({
-      logType: 'console',
-      level: 'info',
-      config: {
-        getCreatedAt: true,
-      },
-    });
-  });
-
-  it('test instantiate LoggerService with default meta', () => {
-    const logger = new LoggerService({
-      defaultMeta: {
-        someMeta1: 'someMeta1',
-        someMeta2: 'someMeta2',
-      },
-    });
-
-    expect(logger.logger).toBe('lesgo-logger');
-    expect(logger.meta).toMatchObject({
-      someMeta1: 'someMeta1',
-      someMeta2: 'someMeta2',
-    });
-  });
-});
-
-describe('ServicesGroup: test log LoggerService with console transport', () => {
-  const consoleTransportConfig = {
-    transports: [
-      {
-        logType: 'console',
-        level: 'info',
-        config: {
-          tags: {
-            addTag: 'config.tags.addTag',
-          },
-          meta: {
-            addMeta: 'config.meta.addMeta',
-          },
-        },
-      },
-    ],
-  };
-
-  it('test log with undefined level', () => {
-    const logger = new LoggerService();
-    expect(() => logger.log('invalidLevel', 'some message')).toThrow(
-      new LesgoException('Invalid level provided in log()')
-    );
-  });
-
-  it('test log with undefined transport', () => {
-    const logger = new LoggerService();
-    logger.log('info', 'some info log');
-
-    expect(console.info).not.toHaveBeenCalled();
-  });
-
-  it('test log with log method', () => {
-    const logger = new LoggerService({ transports: [{ logType: 'console' }] });
-    logger.log('info', 'some info log');
-
-    expect(console.info).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'info',
-        message: 'some info log',
-        logger: 'lesgo-logger',
-        extra: {},
-      })
-    );
-  });
-
-  it('test log with info level', () => {
-    const logger = new LoggerService({ transports: [{ logType: 'console' }] });
-    logger.info('some info log');
-
-    expect(console.info).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'info',
-        message: 'some info log',
-        logger: 'lesgo-logger',
-        extra: {},
-      })
-    );
-  });
-
-  it('test log with debug level', () => {
-    const logger = new LoggerService({ transports: [{ logType: 'console' }] });
-    logger.debug('some debug log');
-
-    expect(console.debug).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'debug',
-        message: 'some debug log',
-        logger: 'lesgo-logger',
-        extra: {},
-      })
-    );
-  });
-
-  it('test log with warn level', () => {
-    const logger = new LoggerService({ transports: [{ logType: 'console' }] });
-    logger.warn('some warn log');
-
-    expect(console.warn).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'warn',
-        message: 'some warn log',
-        logger: 'lesgo-logger',
-        extra: {},
-      })
-    );
-  });
-
-  it('test log with error level', () => {
-    const logger = new LoggerService({ transports: [{ logType: 'console' }] });
-    logger.error('some error log');
-
-    expect(console.error).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'error',
-        message: 'some error log',
-        logger: 'lesgo-logger',
-        extra: {},
-      })
-    );
-  });
-
-  it('test log with custom meta', () => {
-    const logger = new LoggerService({ transports: [{ logType: 'console' }] });
-    logger.addMeta({
-      someMeta: 'someMeta',
-    });
-    logger.log('info', 'some info log');
-
-    expect(console.info).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'info',
-        message: 'some info log',
-        logger: 'lesgo-logger',
-        extra: {
-          someMeta: 'someMeta',
-        },
-      })
-    );
-  });
-
-  it('test log with custom empty meta', () => {
-    console.info = jest.fn();
-
-    const logger = new LoggerService({ transports: [{ logType: 'console' }] });
-    logger.addMeta();
-    logger.log('info', 'some info log');
-
-    expect(console.info).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'info',
-        message: 'some info log',
-        logger: 'lesgo-logger',
-        extra: {},
-      })
-    );
-  });
-
-  it('test log with lower level', () => {
-    console.info = jest.fn();
-
-    const logger = new LoggerService({
-      transports: [{ logType: 'console', level: 'error' }],
-    });
-    logger.log('info', 'some info log');
-
-    expect(console.info).not.toHaveBeenCalled();
-  });
-
-  it('test log with additional meta in config', () => {
-    const logger = new LoggerService(consoleTransportConfig);
-    logger.log('info', 'some info log');
-
-    expect(console.info).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'info',
-        message: 'some info log',
-        logger: 'lesgo-logger',
-        extra: {
-          addMeta: 'config.meta.addMeta',
-        },
-        tags: {
-          addTag: 'config.tags.addTag',
-        },
-      })
-    );
-  });
-
-  it('test log with additional tag and meta in message log', () => {
-    const logger = new LoggerService(consoleTransportConfig);
-    logger.log('info', 'some info log', {
-      tags: { addTag2: 'someTag' },
-      someMoreMeta: 'someMetaAdded',
-    });
-
-    expect(console.info).toHaveBeenCalledWith(
-      JSON.stringify({
-        level: 'info',
-        message: 'some info log',
-        logger: 'lesgo-logger',
-        extra: {
-          someMoreMeta: 'someMetaAdded',
-          addMeta: 'config.meta.addMeta',
-        },
-        tags: {
-          addTag: 'config.tags.addTag',
-          addTag2: 'someTag',
-        },
-      })
-    );
-  });
-});

package/src/services/__tests__/Paginator.spec.js

@@ -1,383 +0,0 @@
-import Paginator from '../pagination/Paginator';
-import {
-  mockData,
-  mockDataFirstItem,
-  mockDataLastItem,
-} from '../../utils/__mocks__/db';
-import db from '../../utils/db';
-
-jest.mock('../../utils/db');
-
-beforeEach(() => {
-  db.select.mockClear();
-});
-
-const FILE = 'Services/pagination/Paginator';
-
-describe('test Paginator instantiate', () => {
-  it.each`
-    currentPage  | perPage      | expectedCount | firstItem            | lastItem
-    ${undefined} | ${undefined} | ${10}         | ${mockData}          | ${mockData}
-    ${undefined} | ${5}         | ${5}          | ${mockDataFirstItem} | ${mockDataLastItem}
-  `(
-    'should not throw exception if page is $page and perPage is $perPage',
-    async ({ currentPage, perPage, expectedCount, firstItem, lastItem }) => {
-      const paginator = new Paginator(
-        db,
-        'SELECT * FROM tests',
-        {},
-        {
-          perPage,
-          currentPage,
-        }
-      );
-
-      expect(await paginator.count()).toEqual(expectedCount);
-      expect(paginator.currentPage()).toEqual(1);
-      expect(await paginator.firstItem()).toMatchObject(firstItem);
-      expect(await paginator.lastItem()).toMatchObject(lastItem);
-      expect(paginator.perPage()).toEqual(expectedCount);
-      expect(await paginator.total()).toEqual(10);
-    }
-  );
-
-  it('should be instantiated without options', async () => {
-    const paginator = new Paginator(db, 'SELECT * FROM tests', {});
-
-    expect(await paginator.count()).toEqual(10);
-    expect(paginator.currentPage()).toEqual(1);
-    expect(await paginator.firstItem()).toMatchObject(mockData);
-    expect(await paginator.lastItem()).toMatchObject(mockData);
-    expect(paginator.perPage()).toEqual(10);
-    expect(await paginator.total()).toEqual(10);
-  });
-
-  it.each`
-    currentPage | perPage     | errorName           | errorMessage                                            | errorCode                                | errorStatusCode
-    ${'sample'} | ${10}       | ${'LesgoException'} | ${"Invalid type for 'currentPage', expecting 'number'"} | ${`${FILE}::FIELD_VALIDATION_EXCEPTION`} | ${500}
-    ${1}        | ${'sample'} | ${'LesgoException'} | ${"Invalid type for 'perPage', expecting 'number'"}     | ${`${FILE}::FIELD_VALIDATION_EXCEPTION`} | ${500}
-  `(
-    'should throw $errorMessage when page is $page and perPage is $perPage',
-    ({
-      currentPage,
-      perPage,
-      errorName,
-      errorMessage,
-      errorCode,
-      errorStatusCode,
-    }) => {
-      try {
-        const values = new Paginator(
-          db,
-          'SELECT * FROM tests',
-          {},
-          {
-            perPage,
-            currentPage,
-          }
-        );
-        expect(values).toThrow();
-      } catch (err) {
-        expect(err.name).toEqual(errorName);
-        expect(err.message).toEqual(errorMessage);
-        expect(err.code).toEqual(errorCode);
-        expect(err.statusCode).toEqual(errorStatusCode);
-      }
-    }
-  );
-
-  it('should return the first item of the result', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    expect(await paginator.firstItem()).toMatchObject(mockDataFirstItem);
-  });
-  it('should return the last item of the result', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
-  });
-  it('should return the defined per page', () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    expect(paginator.perPage()).toEqual(5);
-  });
-  it('should return the previous page if exist', () => {
-    const paginator1 = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 2,
-      }
-    );
-    expect(paginator1.previousPage()).toEqual(1);
-
-    const paginator2 = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 1,
-      }
-    );
-    expect(paginator2.previousPage()).toEqual(false);
-  });
-  it('should return the next page if exist', async () => {
-    const paginator1 = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-    expect(await paginator1.nextPage()).toEqual(2);
-
-    const paginator2 = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 2,
-      }
-    );
-    expect(await paginator2.nextPage()).toEqual(3);
-
-    const paginator3 = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 3,
-      }
-    );
-    expect(await paginator3.nextPage()).toEqual(false);
-  });
-});
-
-describe('test count() usage', () => {
-  it('should count number of items of the current page', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    expect(await paginator.count()).toEqual(5);
-  });
-  it('should only run executeQuery once', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    await paginator.count();
-    await paginator.count();
-    await paginator.count();
-    await paginator.count();
-    await paginator.count();
-
-    expect(db.select).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('test currentPage() usage', () => {
-  it('should return 1 as current page if no currentPage is defined', () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    expect(paginator.currentPage()).toEqual(1);
-  });
-  it('should return the defined current page on instantiation', () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 2,
-      }
-    );
-
-    expect(paginator.currentPage()).toEqual(2);
-  });
-});
-
-describe('test items() usage', () => {
-  it('should return all results from the current page', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    expect(await paginator.items()).toMatchObject([
-      { ...mockDataFirstItem },
-      { ...mockData },
-      { ...mockData },
-      { ...mockData },
-      { ...mockDataLastItem },
-    ]);
-  });
-
-  it('should only run executeQuery once', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    await paginator.items();
-    await paginator.items();
-    await paginator.items();
-    await paginator.items();
-
-    expect(db.select).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('test toObject() usage', () => {
-  it('should return object version of the paginator', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    expect(await paginator.toObject()).toMatchObject({
-      count: 5,
-      previous_page: false,
-      current_page: 1,
-      next_page: 2,
-      last_page: 2,
-      per_page: 5,
-      total: 10,
-      items: [
-        { ...mockDataFirstItem },
-        { ...mockData },
-        { ...mockData },
-        { ...mockData },
-        { ...mockDataLastItem },
-      ],
-    });
-  });
-
-  it('should only run executeQuery twice', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-      }
-    );
-
-    await paginator.toObject();
-    await paginator.toObject();
-    await paginator.toObject();
-    await paginator.toObject();
-
-    expect(db.select).toHaveBeenCalledTimes(2);
-  });
-});
-
-describe('test total() usage', () => {
-  it('should get total number of data using default countTotalItems method', async () => {
-    const paginator = new Paginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        currentPage: 1,
-      }
-    );
-
-    expect(await paginator.total()).toEqual(30);
-    expect(db.select).toHaveBeenCalled();
-  });
-});
-
-describe('test lastPage() usage', () => {
-  it('should get the last page using default countTotalItems method when getting total data', async () => {
-    const paginator1 = new Paginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        currentPage: 1,
-      }
-    );
-    expect(await paginator1.lastPage()).toEqual(3);
-
-    const paginator2 = new Paginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 1,
-      }
-    );
-    expect(await paginator2.lastPage()).toEqual(6);
-
-    const paginator3 = new Paginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        perPage: 7,
-        currentPage: 1,
-      }
-    );
-    expect(await paginator3.lastPage()).toEqual(5);
-
-    expect(db.select).toHaveBeenCalled();
-  });
-});

package/src/services/__tests__/S3Service.spec.js

@@ -1,55 +0,0 @@
-import { S3 } from 'aws-sdk';
-
-import S3Service from '../S3Service';
-
-describe('ServicesGroup: test S3Service instantiation', () => {
-  it('test instantiate default S3Service', () => {
-    // eslint-disable-next-line no-unused-vars
-    const s3Instance = new S3Service();
-
-    expect(S3).toHaveBeenCalledWith({});
-  });
-
-  it('test instantiate S3Service with custom options', () => {
-    // eslint-disable-next-line no-unused-vars
-    const s3Instance = new S3Service({
-      accessKeyId: 'aws.s3.options.accessKeyId',
-      secretAccessKey: 'aws.s3.options.secretAccessKey',
-      region: 'aws.s3.options.region',
-    });
-
-    expect(S3).toHaveBeenCalledWith({
-      accessKeyId: 'aws.s3.options.accessKeyId',
-      secretAccessKey: 'aws.s3.options.secretAccessKey',
-      region: 'aws.s3.options.region',
-    });
-  });
-});
-
-describe('ServicesGroup: test S3Service usage', () => {
-  it('test getObject', () => {
-    // eslint-disable-next-line no-unused-vars
-    const s3Instance = new S3Service();
-
-    return expect(
-      s3Instance.getObject('someKey', 'someBucket')
-    ).resolves.toMatchObject({
-      LastModified: '2019-09-04T05:00:57.000Z',
-      ContentLength: 27892,
-      ETag: '38e6c8a510f49edec0ad4244a7665312',
-      ContentType: '.jpg',
-      Metadata: {},
-      Body: {
-        type: 'Buffer',
-        data: [],
-      },
-      mocked: {
-        opts: {},
-        params: {
-          Key: 'someKey',
-          Bucket: 'someBucket',
-        },
-      },
-    });
-  });
-});