lesgo 0.7.8 → 2.1.0

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

@@ -1,278 +0,0 @@
-import mysql from 'mysql2/promise';
-import AuroraDbRDSProxyService from '../AuroraDbRDSProxyService';
-import LesgoException from '../../exceptions/LesgoException';
-
-const auroraConfig = {
-  host: 'some-fake-host',
-  user: 'fakeUsername',
-  password: 'fakePassword',
-  database: 'fakeDbName',
-};
-
-const customConfig = {
-  host: 'some-fake-host-2',
-  user: 'fakeUsername2',
-  password: 'fakePassword2',
-  database: 'fakeDbName2',
-};
-
-describe('test AuroraDbRDSProxyService instantiate', () => {
-  it('should not throw exception when instantiating', () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    expect(db.clientOpts).toMatchObject(auroraConfig);
-  });
-
-  it('should allow for empty config', () => {
-    const db = new AuroraDbRDSProxyService();
-    expect(db.clientOpts).toMatchObject({});
-  });
-});
-
-describe('test AuroraDbRDSProxyService connect', () => {
-  it('should be able to connect without custom config', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const conn = await db.connect();
-
-    expect(conn.mocked).toMatchObject(auroraConfig);
-  });
-
-  it('should be able to connect with custom config', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const conn = await db.connect(customConfig);
-
-    expect(conn.mocked).toMatchObject(customConfig);
-  });
-});
-
-describe('test AuroraDbRDSProxyService query', () => {
-  it('should return results object when calling query function', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const resp = await db.query('SELECT_QUERY', {});
-
-    expect(resp).toMatchObject({
-      results: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-        {
-          id: 2,
-          uid: 'some-uid-2',
-        },
-      ],
-    });
-
-    expect(mysql.createConnection).toHaveBeenCalled();
-  });
-
-  it('should return results object when calling querying with connection options passed', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const resp = await db.query('SELECT_QUERY', {}, auroraConfig);
-
-    expect(resp).toMatchObject({
-      results: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-        {
-          id: 2,
-          uid: 'some-uid-2',
-        },
-      ],
-    });
-
-    expect(mysql.createConnection).toHaveBeenCalled();
-  });
-
-  it('should return results object when calling querying with no connection options passed and persistent conn', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    await db.pConnect();
-    const resp = await db.query('SELECT_QUERY', {});
-
-    expect(resp).toMatchObject({
-      results: [
-        {
-          id: 1,
-          uid: 'some-uid-1',
-        },
-        {
-          id: 2,
-          uid: 'some-uid-2',
-        },
-      ],
-    });
-
-    expect(mysql.createConnection).toHaveBeenCalled();
-  });
-});
-
-describe('test AuroraDbRDSProxyService select', () => {
-  it('should return array results when calling select function', async () => {
-    const db = new AuroraDbRDSProxyService(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 AuroraDbRDSProxyService(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 AuroraDbRDSProxyService(auroraConfig);
-    return expect(
-      db.select('RANDOM_QUERY', 'INVALID_QUERY_PARAMETERS')
-    ).rejects.toMatchObject(error);
-  });
-});
-
-describe('test AuroraDbRDSProxyService selectPaginate', () => {
-  it('should return paginated results when calling selectPaginate function', async () => {
-    const db = new AuroraDbRDSProxyService(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 results when calling selectPaginate with defined total', async () => {
-    const db = new AuroraDbRDSProxyService(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 AuroraDbRDSProxyService selectFirst', () => {
-  it('should only return the first record when calling selectFirst', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.selectFirst('SELECT_QUERY', {})).resolves.toMatchObject({
-      id: 1,
-      uid: 'some-uid-1',
-    });
-  });
-});
-
-describe('test AuroraDbRDSProxyService insert', () => {
-  it('should return recordId when inserting record', async () => {
-    const db = new AuroraDbRDSProxyService(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 AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.insert('INVALID_INSERT_QUERY', {})).rejects.toMatchObject(
-      error
-    );
-  });
-});
-
-describe('test AuroraDbRDSProxyService update', () => {
-  it('should return success when making update query', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.update('UPDATE_QUERY', {})).resolves.not.toThrow();
-  });
-
-  it('should throw not exception when caliing update with invalid query', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    return expect(db.update('INVALID_UPDATE_QUERY', {})).resolves.not.toThrow();
-  });
-});
-
-describe('test AuroraDbRDSProxyService pConnect', () => {
-  it('should be able to connect without custom config', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    await db.pConnect();
-
-    expect(db.conn.mocked).toMatchObject(auroraConfig);
-  });
-
-  it('should be able to connect with custom config', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    await db.pConnect(customConfig);
-
-    expect(db.conn.mocked).toMatchObject(customConfig);
-  });
-});
-
-describe('test AuroraDbRDSProxyService end', () => {
-  it('should end the connection when passed', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    const conn = await db.connect();
-    await db.end(conn);
-
-    expect(conn.end).toHaveBeenCalledTimes(1);
-  });
-
-  it('should end the persisted connection when none is passed', async () => {
-    const db = new AuroraDbRDSProxyService(auroraConfig);
-    await db.pConnect();
-    await db.end();
-
-    expect(db.conn.end).toHaveBeenCalledTimes(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!',
-      });
-    });
-  });
-});