lesgo 1.0.0 → 2.1.1

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',
-        },
-      },
-    });
-  });
-});

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

@@ -1,47 +0,0 @@
-import aws from 'Config/aws'; // eslint-disable-line import/no-unresolved
-import { SQS } from 'aws-sdk';
-import SQSService from '../SQSService';
-
-describe('ServicesGroup: test SQSService instantiation', () => {
-  it('test instantiate default SQSService', () => {
-    // eslint-disable-next-line no-unused-vars
-    const sqs = new SQSService();
-
-    expect(SQS).toHaveBeenCalledWith({});
-  });
-
-  it('test instantiate SQSService with custom options', () => {
-    // eslint-disable-next-line no-unused-vars
-    const sqs = new SQSService({
-      accessKeyId: 'aws.sqs.options.accessKeyId',
-      secretAccessKey: 'aws.sqs.options.secretAccessKey',
-      region: 'aws.sqs.options.region',
-    });
-
-    expect(SQS).toHaveBeenCalledWith({
-      accessKeyId: 'aws.sqs.options.accessKeyId',
-      secretAccessKey: 'aws.sqs.options.secretAccessKey',
-      region: 'aws.sqs.options.region',
-    });
-  });
-});
-
-describe('ServicesGroup: test SQSService usage', () => {
-  it('test dispatch', () => {
-    // eslint-disable-next-line no-unused-vars
-    const sqs = new SQSService({}, aws.sqs.queues);
-
-    return expect(
-      sqs.dispatch({ someData: 'someValue' }, 'pingQueue')
-    ).resolves.toMatchObject({
-      MessageId: 'MessageId',
-      mocked: {
-        opts: {},
-        params: {
-          MessageBody: '{"someData":"someValue"}',
-          QueueUrl: `${aws.sqs.queues.pingQueue.url}`,
-        },
-      },
-    });
-  });
-});

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

@@ -1,103 +0,0 @@
-/* eslint-disable no-console */
-/* eslint-disable no-unused-vars */
-import AWS from 'aws-sdk';
-import {
-  initialize,
-  handleSuccess,
-  handleFail,
-  sendRequest,
-  signedRequest,
-} from '../aws/SignedRequest';
-
-const httpResp = {
-  statusCode: 0,
-  on: (key, cb) => {
-    if (key === 'data') {
-      cb('{"data": "mockedData"}');
-    } else if (key === 'end') {
-      cb();
-    }
-  },
-};
-
-const wrongHttpResp = {
-  statusCode: 0,
-  on: (key, cb) => {
-    if (key === 'data') {
-      cb('notJsonFormat');
-    } else if (key === 'end') {
-      cb();
-    }
-  },
-};
-
-// mock the process.nextTick
-process.nextTick = jest.fn().mockImplementation(cb => {
-  cb();
-});
-
-describe('ServicesGroup: test SignedRequest', () => {
-  it('test handleSuccess', () => {
-    httpResp.statusCode = 200;
-    handleSuccess(httpResp, true, (key, body) => {});
-    handleSuccess(httpResp, false, (key, body) => {});
-    httpResp.statusCode = 500;
-    handleSuccess(httpResp, false, (key, body) => {});
-
-    // should throw error 'Invalid JSON response'
-    wrongHttpResp.statusCode = 200;
-    handleSuccess(wrongHttpResp, false, (key, body) => {});
-    wrongHttpResp.statusCode = 500;
-    handleSuccess(wrongHttpResp, false, (key, body) => {});
-
-    handleSuccess(
-      {
-        statusCode: 200,
-        on: (key, cb) => {
-          if (key === 'data') {
-            cb('notJsonFormat');
-          } else if (key === 'end') {
-            cb();
-          }
-        },
-      },
-      false,
-      (key, body) => {}
-    );
-  });
-
-  it('test handleFail', () => {
-    const cb = error => {
-      console.log(error);
-    };
-    handleFail('mockingErrorAsString', cb);
-    handleFail(new Error('mockingErrorAsInstance'), cb);
-  });
-
-  it('test initialize', () => {
-    initialize(AWS, {
-      awsCreds: null,
-    });
-  });
-
-  it('test sendRequest', () => {
-    sendRequest({ rawResponse: false, method: 'POST' }, () => {});
-  });
-
-  it('test signedRequest', () => {
-    // null params
-    signedRequest(AWS, {}).send(null, () => {});
-
-    // no method params
-    signedRequest(AWS, {}).send({}, () => {});
-
-    // with method params
-    // no AWS
-    signedRequest(AWS, {}).send(
-      {
-        method: 'POST',
-      },
-      () => {}
-    );
-  });
-});

package/src/services/aws/AwsElasticsearchConnection.js

@@ -1,59 +0,0 @@
-import AWS from 'aws-sdk'; // eslint-disable-line import/no-extraneous-dependencies
-import { Connection } from '@elastic/elasticsearch';
-import SignedRequest from './SignedRequest';
-import LesgoException from '../../exceptions/LesgoException';
-
-/* eslint-disable class-methods-use-this */
-export default class AwsElasticsearchConnection extends Connection {
-  constructor(opts) {
-    super(opts);
-
-    this.opts = opts;
-  }
-
-  async request(params, cb) {
-    try {
-      const awsCreds = await this.getCredentials();
-
-      /* istanbul ignore else */
-      if (!this.opts.awsRegion) {
-        throw new LesgoException('Please provide the awsRegion!');
-      }
-
-      const httpClient = SignedRequest(AWS, {
-        endpoint: this.opts.url.host,
-        region: this.opts.awsRegion,
-        service: 'es',
-        awsCreds,
-      });
-
-      httpClient.send(
-        {
-          method: params.method,
-          path: params.path,
-          message: params.body,
-          headers: params.headers,
-          rawResponse: true, // @elastic search expect Raw Response
-        },
-        cb
-      );
-    } catch (err) {
-      cb(err);
-    }
-  }
-
-  getCredentials() {
-    // eslint-disable-next-line consistent-return
-    return new Promise((resolve, reject) => {
-      if (AWS.config.credentials === null) {
-        return reject(new Error('Invalid AWS Credentials'));
-      }
-
-      AWS.config.getCredentials((err, creds) => {
-        if (err) return reject(err);
-
-        return resolve(creds);
-      });
-    });
-  }
-}