lesgo 1.0.0 → 2.1.1

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

@@ -1,211 +0,0 @@
-import dataApiClient from 'data-api-client';
-import dbConfig from 'Config/db'; // eslint-disable-line import/no-unresolved
-import AuroraDbService from '../AuroraDbService';
-import LesgoException from '../../exceptions/LesgoException';
-
-const auroraConfig = {
-  secretArn: 'fakeSecretArn',
-  resourceArn: 'fakeResourceArn',
-  database: 'fakeDbName',
-};
-
-describe('test AuroraDbService instantiate', () => {
-  it('should not throw exception when instantiating', () => {
-    const db = new AuroraDbService();
-
-    expect(dataApiClient).toHaveBeenCalledWith({});
-    expect(db.client.mocked).toMatchObject({});
-  });
-
-  it('should not throw exception with custom config', () => {
-    const db = new AuroraDbService(auroraConfig);
-
-    expect(dataApiClient).toHaveBeenCalledWith(auroraConfig);
-    expect(db.client.mocked).toMatchObject(auroraConfig);
-  });
-
-  it('should not throw exception with custom region', () => {
-    const db = new AuroraDbService({
-      ...auroraConfig,
-      region: 'ap-southeast-1',
-    });
-
-    expect(dataApiClient).toHaveBeenCalledWith(auroraConfig);
-    expect(db.client.mocked).toMatchObject(auroraConfig);
-  });
-});
-
-describe('test AuroraDbService connect', () => {
-  it('should have updated credentials when calling connect', () => {
-    const db = new AuroraDbService(auroraConfig);
-    db.connect({
-      secretArn: dbConfig.secretCommandArn,
-    });
-
-    expect(db.client.mocked).toMatchObject({
-      secretArn: dbConfig.secretCommandArn,
-    });
-  });
-});
-
-describe('test AuroraDbService query', () => {
-  it('should return records object when calling query function', async () => {
-    const db = new AuroraDbService(auroraConfig);
-    return expect(db.query('SELECT_QUERY', {})).resolves.toMatchObject({
-      records: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-        {
-          id: 2,
-          uid: 'some-uid-2',
-        },
-      ],
-    });
-  });
-});
-
-describe('test AuroraDbService select', () => {
-  it('should return array records when calling select function', async () => {
-    const db = new AuroraDbService(auroraConfig);
-    return expect(db.select('SELECT_QUERY', {})).resolves.toMatchObject([
-      {
-        id: 1,
-        uid: 'some-uid-1',
-      },
-      {
-        id: 2,
-        uid: 'some-uid-2',
-      },
-    ]);
-  });
-
-  it('should throw an exception when writing with invalid query', async () => {
-    const error = new LesgoException(
-      'Exception caught executing SQL Statement',
-      'AURORADBSERVICE_QUERY_EXCEPTION',
-      500,
-      {
-        err: {
-          code: 'BadRequestException',
-        },
-      }
-    );
-
-    const db = new AuroraDbService(auroraConfig);
-    return expect(db.select('INVALID_QUERY', {})).rejects.toMatchObject(error);
-  });
-
-  it('should throw an exception when calling select with invalid query parameters', async () => {
-    const error = new LesgoException(
-      'Exception caught executing SQL Statement',
-      'AURORADBSERVICE_QUERY_EXCEPTION',
-      500,
-      {
-        err: {
-          code: 'BadRequestException',
-        },
-      }
-    );
-
-    const db = new AuroraDbService(auroraConfig);
-    return expect(
-      db.select('RANDOM_QUERY', 'INVALID_QUERY_PARAMETERS')
-    ).rejects.toMatchObject(error);
-  });
-});
-
-describe('test AuroraDbService selectPaginate', () => {
-  it('should return paginated records when calling selectPaginate function', async () => {
-    const db = new AuroraDbService(auroraConfig);
-    return expect(db.selectPaginate('SELECT_QUERY', {})).resolves.toMatchObject(
-      {
-        count: 2,
-        previous_page: false,
-        current_page: 1,
-        next_page: false,
-        per_page: 10,
-        items: [
-          {
-            id: 1,
-            uid: 'some-uid-1',
-          },
-          {
-            id: 2,
-            uid: 'some-uid-2',
-          },
-        ],
-      }
-    );
-  });
-
-  it('should return paginated records when calling selectPaginate with defined total', async () => {
-    const db = new AuroraDbService(auroraConfig);
-    return expect(
-      db.selectPaginate('SELECT_QUERY', {}, 1, 2, 1)
-    ).resolves.toMatchObject({
-      count: 1,
-      previous_page: 1,
-      current_page: 2,
-      next_page: 3,
-      per_page: 1,
-      items: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-      ],
-    });
-  });
-});
-
-describe('test AuroraDbService selectFirst', () => {
-  it('should only return the first record when calling selectFirst', async () => {
-    const db = new AuroraDbService(auroraConfig);
-    return expect(db.selectFirst('SELECT_QUERY', {})).resolves.toMatchObject({
-      id: 1,
-      uid: 'some-uid-1',
-    });
-  });
-});
-
-describe('test AuroraDbService insert', () => {
-  it('should return recordId when inserting record', async () => {
-    const db = new AuroraDbService(auroraConfig);
-    return expect(db.insert('INSERT_QUERY', {})).resolves.toEqual(20);
-  });
-
-  it('should throw exception when calling insert with invalid query', async () => {
-    const error = new LesgoException(
-      'No records inserted from INSERT query',
-      'AURORADBSERVICE_NO_RECORDS_INSERTED',
-      400
-    );
-
-    const db = new AuroraDbService(auroraConfig);
-    return expect(db.insert('INVALID_INSERT_QUERY', {})).rejects.toMatchObject(
-      error
-    );
-  });
-});
-
-describe('test AuroraDbService update', () => {
-  it('should return success when making update query', async () => {
-    const db = new AuroraDbService(auroraConfig);
-    return db.update('UPDATE_QUERY', {});
-  });
-
-  it('should throw exception when caliing update with invalid query', async () => {
-    const error = new LesgoException(
-      'No records updated from UPDATE query',
-      'AURORADBSERVICE_NO_RECORDS_UPDATED',
-      400
-    );
-
-    const db = new AuroraDbService(auroraConfig);
-    return expect(db.update('INVALID_UPDATE_QUERY', {})).rejects.toMatchObject(
-      error
-    );
-  });
-});

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

@@ -1,89 +0,0 @@
-import AWS from 'aws-sdk';
-import { URL } from 'url';
-import AwsElasticsearchConnection from '../aws/AwsElasticsearchConnection';
-
-const commonConn = new AwsElasticsearchConnection();
-
-describe('ServicesGroup: test AwsElasticsearchConnection Credentails', () => {
-  it('test getCredentials AwsElasticsearchConnection', async () => {
-    await expect(commonConn.getCredentials()).resolves.toMatchObject({
-      mocked: {
-        credentials: 'mockedCredentials',
-      },
-    });
-  });
-
-  it('test getCredentails and throws rejects promise', async () => {
-    const oldConfig = AWS.config;
-
-    AWS.config = {
-      ...AWS.config,
-      getCredentials: jest.fn().mockImplementation(callback => {
-        return callback(
-          {
-            mocked: {
-              error: 'mockedError',
-            },
-          },
-          null
-        );
-      }),
-    };
-
-    await expect(commonConn.getCredentials()).rejects.toMatchObject({
-      mocked: {
-        error: 'mockedError',
-      },
-    });
-
-    // return it back the old config
-    AWS.config = oldConfig;
-  });
-
-  it('should throw error if credential is empty', async () => {
-    const oldConfig = AWS.config.credentials;
-    AWS.config.credentials = null;
-
-    await expect(commonConn.getCredentials()).rejects.toThrow(
-      new Error('Invalid AWS Credentials')
-    );
-
-    // return it back the old config
-    AWS.config.credentials = oldConfig;
-  });
-});
-
-describe('ServicesGroup: test AwsElasticsearchConnection Request', () => {
-  it('should call the request method', async () => {
-    const conn = new AwsElasticsearchConnection({
-      awsRegion: 'us-east-1',
-      url: new URL('http://localhost'),
-    });
-
-    await conn.request({ method: 'POST' }, () => {}); // using no body
-    await conn.request({ method: 'POST', body: 'Yow' }, () => {}); // using string to body
-    await conn.request({ method: 'POST', body: ['Yow'] }, () => {}); // using array to body
-
-    await conn.request(
-      {
-        method: 'POST',
-        body: ['Yow'],
-      },
-      err => {
-        throw err;
-      }
-    );
-  });
-
-  it('should call the request method and throw awsRegion Error', async () => {
-    const conn = new AwsElasticsearchConnection({
-      awsRegion: null,
-    });
-
-    await conn.request({}, err => {
-      return expect(err).toMatchObject({
-        message: 'Please provide the awsRegion!',
-      });
-    });
-  });
-});

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

@@ -1,314 +0,0 @@
-import { DocumentClient } from 'aws-sdk/clients/dynamodb'; // eslint-disable-line import/no-extraneous-dependencies
-import DynamoDbService from '../DynamoDbService';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('test DynamoDbService connect', () => {
-  it('should not throw an error when instantiating DynamoDbService', () => {
-    // eslint-disable-next-line no-unused-vars
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    expect(DocumentClient).toHaveBeenCalledWith({ region: 'ap-southeast-1' });
-  });
-
-  it('should throw an error when instantiating DynamoDbService with missing region', () => {
-    try {
-      expect(new DynamoDbService()).toThrow();
-    } catch (err) {
-      expect(err).toMatchObject(
-        new LesgoException(
-          'Missing required parameter region',
-          'DYNAMODB_MISSING_PARAMETER'
-        )
-      );
-    }
-  });
-});
-
-describe('test DynamoDbService query', () => {
-  it('should return a list of items when calling query', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const keyConditionExpression = 'key = :keyId';
-    const expressionAttributeValues = { ':keyId': 123 };
-    const projectionExpression = ['key', 'value'];
-
-    return expect(
-      db.query(
-        tableName,
-        keyConditionExpression,
-        expressionAttributeValues,
-        projectionExpression
-      )
-    ).resolves.toMatchObject([
-      {
-        key: 123,
-        value: 'abc',
-      },
-    ]);
-  });
-
-  it('should throw exception when tableName is empty', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = '';
-    const keyConditionExpression = 'key = :keyId';
-    const expressionAttributeValues = { ':keyId': 123 };
-    const projectionExpression = ['key', 'value'];
-
-    return expect(
-      db.query(
-        tableName,
-        keyConditionExpression,
-        expressionAttributeValues,
-        projectionExpression
-      )
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB QUERY OPERATION',
-        'DYNAMODB_QUERY_EXCEPTION'
-      )
-    );
-  });
-
-  it('should throw exception when expressionAttributeValues is not an object', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const keyConditionExpression = 'key = :keyId';
-    const expressionAttributeValues = 'someString';
-    const projectionExpression = ['key', 'value'];
-
-    return expect(
-      db.query(
-        tableName,
-        keyConditionExpression,
-        expressionAttributeValues,
-        projectionExpression
-      )
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB QUERY OPERATION',
-        'DYNAMODB_QUERY_EXCEPTION'
-      )
-    );
-  });
-
-  it('should throw exception when projectionExpression is not an array', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const keyConditionExpression = 'key = :keyId';
-    const expressionAttributeValues = { ':keyId': 123 };
-    const projectionExpression = 'someString';
-
-    return expect(
-      db.query(
-        tableName,
-        keyConditionExpression,
-        expressionAttributeValues,
-        projectionExpression
-      )
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB QUERY OPERATION',
-        'DYNAMODB_QUERY_EXCEPTION'
-      )
-    );
-  });
-});
-
-describe('test DynamoDbService queryCount', () => {
-  it('should return count when calling query', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const keyConditionExpression = 'key = :keyId';
-    const expressionAttributeValues = { ':keyId': 123 };
-
-    return expect(
-      db.queryCount(
-        tableName,
-        keyConditionExpression,
-        expressionAttributeValues
-      )
-    ).resolves.toEqual(1);
-  });
-
-  it('should throw exception when tableName is empty', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = '';
-    const keyConditionExpression = 'key = :keyId';
-    const expressionAttributeValues = { ':keyId': 123 };
-
-    return expect(
-      db.queryCount(
-        tableName,
-        keyConditionExpression,
-        expressionAttributeValues
-      )
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB QUERY COUNT OPERATION',
-        'DYNAMODB_QUERY_EXCEPTION'
-      )
-    );
-  });
-
-  it('should throw exception when expressionAttributeValues is not an object', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const keyConditionExpression = 'key = :keyId';
-    const expressionAttributeValues = 'someString';
-
-    return expect(
-      db.queryCount(
-        tableName,
-        keyConditionExpression,
-        expressionAttributeValues
-      )
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB QUERY COUNT OPERATION',
-        'DYNAMODB_QUERY_EXCEPTION'
-      )
-    );
-  });
-});
-
-describe('test DynamoDbService put', () => {
-  it('should return recordCount when calling put', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const item = {
-      key: 123,
-      value: 'abc',
-    };
-
-    return expect(db.put(tableName, item)).resolves.toEqual({
-      recordCount: 1,
-      data: {},
-    });
-  });
-
-  it('should throw exception when tableName is empty', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = '';
-    const item = {
-      key: 123,
-      value: 'abc',
-    };
-
-    return expect(db.put(tableName, item)).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB PUT OPERATION',
-        'DYNAMODB_PUT_EXCEPTION'
-      )
-    );
-  });
-
-  it('should throw exception when item is not an object', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const item = 'someString';
-
-    return expect(db.put(tableName, item)).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB PUT OPERATION',
-        'DYNAMODB_PUT_EXCEPTION'
-      )
-    );
-  });
-});
-
-describe('test DynamoDbService update', () => {
-  it('should return count when calling query', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const key = { key: 123 };
-    const updateExpression = 'SET value = :value';
-    const expressionAttributeValues = { ':value': 'asd' };
-
-    return expect(
-      db.update(tableName, key, updateExpression, expressionAttributeValues)
-    ).resolves.toEqual({ recordCount: 1, data: {} });
-  });
-
-  it('should throw exception when tableName is empty', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = '';
-    const key = { key: 123 };
-    const updateExpression = 'SET value = :value';
-    const expressionAttributeValues = { ':value': 'asd' };
-
-    return expect(
-      db.update(tableName, key, updateExpression, expressionAttributeValues)
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB UPDATE OPERATION',
-        'DYNAMODB_UPDATE_EXCEPTION'
-      )
-    );
-  });
-
-  it('should throw exception when expressionAttributeValues is not an object', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const key = { key: 123 };
-    const updateExpression = 'SET value = :value';
-    const expressionAttributeValues = 'someString';
-
-    return expect(
-      db.update(tableName, key, updateExpression, expressionAttributeValues)
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB UPDATE OPERATION',
-        'DYNAMODB_UPDATE_EXCEPTION'
-      )
-    );
-  });
-
-  it('should throw exception when key is not an object', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const key = 123;
-    const updateExpression = 'SET value = :value';
-    const expressionAttributeValues = { ':value': 'asd' };
-
-    return expect(
-      db.update(tableName, key, updateExpression, expressionAttributeValues)
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB UPDATE OPERATION',
-        'DYNAMODB_UPDATE_EXCEPTION'
-      )
-    );
-  });
-
-  it('should throw exception when updateExpression is not a string', () => {
-    const db = new DynamoDbService({ region: 'ap-southeast-1' });
-
-    const tableName = 'sampleTable';
-    const key = { key: 123 };
-    const updateExpression = { some: 'value' };
-    const expressionAttributeValues = { ':value': 'asd' };
-
-    return expect(
-      db.update(tableName, key, updateExpression, expressionAttributeValues)
-    ).rejects.toThrow(
-      new LesgoException(
-        'EXCEPTION ENCOUNTERED FOR DYNAMODB UPDATE OPERATION',
-        'DYNAMODB_UPDATE_EXCEPTION'
-      )
-    );
-  });
-});