lesgo 0.7.8 → 2.1.0

package/src/utils/__tests__/objectStore.spec.js

@@ -1,67 +0,0 @@
-import s3, { getObject } from '../objectStore';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('UtilsGroup: test objectStore utils', () => {
-  it('test objectStore.getObject', () => {
-    return expect(
-      // eslint-disable-next-line import/no-named-as-default-member
-      s3.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',
-        },
-      },
-    });
-  });
-
-  it('test objectStore getObject', () => {
-    return expect(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',
-        },
-      },
-    });
-  });
-
-  it('test objectStore getObject with empty key', () => {
-    return expect(() => getObject()).toThrow(
-      new LesgoException(
-        'Key is undefined in S3Service.getObject()',
-        'S3SERVICE_GETOBJECT_KEY_UNDEFINED'
-      )
-    );
-  });
-
-  it('test objectStore getObject with empty bucket', () => {
-    return expect(() => getObject('someKey')).toThrow(
-      new LesgoException(
-        'Bucket is undefined in S3Service.getObject()',
-        'S3SERVICE_GETOBJECT_BUCKET_UNDEFINED'
-      )
-    );
-  });
-});

package/src/utils/__tests__/prepSQLInsertParams.spec.js

@@ -1,46 +0,0 @@
-import prepSQLInsertParams from '../prepSQLInsertParams';
-
-const columns = [
-  { key: 'uid', type: 'string', required: true },
-  {
-    key: 'type',
-    type: 'enum',
-    enumValues: ['photo', 'video'],
-    required: true,
-  },
-  { key: 'table_name', type: 'string', required: false },
-  { key: 'row_id', type: 'number', required: false },
-  { key: 'id', type: 'number', required: true },
-];
-
-describe('test prepSQLInsertParams util', () => {
-  test('should return all the fields if provided', () => {
-    const params = {
-      uid: 'sample-123123',
-      type: 'photo',
-      table_name: 'medias',
-      row_id: 123,
-      id: 123,
-    };
-
-    expect(prepSQLInsertParams(params, columns)).toMatchObject({
-      insertColumns: 'uid,type,table_name,row_id,id',
-      insertValues: ':uid,:type,:table_name,:row_id,:id',
-      insertFields: params,
-    });
-  });
-
-  test('should return only the given fields', () => {
-    const params = {
-      uid: 'sample-123123',
-      type: 'photo',
-      id: 123,
-    };
-
-    expect(prepSQLInsertParams(params, columns)).toMatchObject({
-      insertColumns: 'uid,type,id',
-      insertValues: ':uid,:type,:id',
-      insertFields: params,
-    });
-  });
-});

package/src/utils/__tests__/prepSQLUpdateParams.spec.js

@@ -1,36 +0,0 @@
-import prepSQLUpdateParams from '../prepSQLUpdateParams';
-
-const columns = [
-  { key: 'id', type: 'number', required: true },
-  { key: 'table_name', type: 'string', required: false },
-  { key: 'row_id', type: 'number', required: false },
-];
-
-describe('test prepSQLUpdateParams util', () => {
-  test('should return all the fields if provided', () => {
-    const params = {
-      id: 123,
-      table_name: 'users',
-      row_id: 123,
-    };
-
-    expect(prepSQLUpdateParams(params, columns)).toMatchObject({
-      updateColumnValues: 'table_name=:table_name,row_id=:row_id',
-      wherePrimaryKey: 'id=:id',
-      updateFields: params,
-    });
-  });
-
-  test('should return only the provided fields', () => {
-    const params = {
-      id: 123,
-      row_id: 124,
-    };
-
-    expect(prepSQLUpdateParams(params, columns)).toMatchObject({
-      updateColumnValues: 'row_id=:row_id',
-      wherePrimaryKey: 'id=:id',
-      updateFields: params,
-    });
-  });
-});

package/src/utils/__tests__/queue.spec.js

@@ -1,54 +0,0 @@
-import aws from 'Config/aws'; // eslint-disable-line import/no-unresolved
-import queue, { dispatch } from '../queue';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('UtilsGroup: test queue utils', () => {
-  it('test queue.dispatch', () => {
-    return expect(
-      // eslint-disable-next-line import/no-named-as-default-member
-      queue.dispatch({ someData: 'someValue' }, 'pingQueue')
-    ).resolves.toMatchObject({
-      MessageId: 'MessageId',
-      mocked: {
-        opts: {},
-        params: {
-          MessageBody: '{"someData":"someValue"}',
-          QueueUrl: `${aws.sqs.queues.pingQueue.url}`,
-        },
-      },
-    });
-  });
-
-  it('test queue dispatch', () => {
-    return expect(
-      dispatch({ someData: 'someValue' }, 'pingQueue')
-    ).resolves.toMatchObject({
-      MessageId: 'MessageId',
-      mocked: {
-        opts: {},
-        params: {
-          MessageBody: '{"someData":"someValue"}',
-          QueueUrl: `${aws.sqs.queues.pingQueue.url}`,
-        },
-      },
-    });
-  });
-
-  it('test queue dispatch with empty payload', () => {
-    return expect(() => dispatch()).toThrow(
-      new LesgoException(
-        'payload is undefined in dispatch()',
-        'SQSSERVICE_DISPATCH_PAYLOAD_UNDEFINED'
-      )
-    );
-  });
-
-  it('test queue dispatch with empty queueName', () => {
-    return expect(() => dispatch({ someData: 'someValue' })).toThrow(
-      new LesgoException(
-        'queueName is undefined in dispatch()',
-        'SQSSERVICE_DISPATCH_QUEUENAME_UNDEFINED'
-      )
-    );
-  });
-});

package/src/utils/__tests__/validateFields.spec.js

@@ -1,374 +0,0 @@
-import LesgoException from '../../exceptions/LesgoException';
-import validateFields from '../validateFields';
-
-const FILE = 'Utils/validateFields';
-
-const params = {
-  Id: 99,
-  name: 'name',
-  email: 'email@mail.com',
-  roles: { admin: 'admin' },
-  listItem: ['apple', 'banana'],
-  status: 'active',
-  decimalCheck: 1.99,
-  totalRecord: 99,
-  functionCheck: () => {},
-  jsonCheck: JSON.stringify({
-    test: 'json value',
-    testArray: ['withvalues', 'here'],
-    testNum: 1,
-  }),
-  statusCollection: ['active', 'inactive', 'active'],
-};
-
-const validFields = [
-  { key: 'Id', type: 'number', required: true },
-  { key: 'name', type: 'string', required: true },
-  { key: 'email', type: 'email', required: true },
-  { key: 'roles', type: 'object', required: true },
-  { key: 'listItem', type: 'array', required: true },
-  {
-    key: 'status',
-    type: 'enum',
-    enumValues: ['active', 'inactive'],
-    required: true,
-  },
-  {
-    key: 'decimalCheck',
-    type: 'decimal',
-    required: true,
-  },
-  { key: 'totalRecord', type: 'number', required: true },
-  {
-    key: 'functionCheck',
-    type: 'function',
-    required: true,
-  },
-  {
-    key: 'jsonCheck',
-    type: 'json',
-    required: true,
-  },
-  {
-    key: 'statusCollection',
-    type: 'enum',
-    enumValues: ['active', 'inactive'],
-    required: true,
-    isCollection: true,
-  },
-];
-
-describe('test Utils/validateFields', () => {
-  it('should return validated fields', () => {
-    expect(validateFields(params, validFields)).toMatchObject(params);
-  });
-
-  it('should throw missing required field when not present', () => {
-    const newParams = { ...params };
-    delete newParams.email;
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual("Missing required 'email'");
-      expect(e.code).toEqual(`${FILE}::MISSING_REQUIRED_EMAIL`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[2],
-      });
-    }
-  });
-
-  it('should throw invalid type when non-string value check', () => {
-    const newParams = { ...params, name: 123 };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(`Invalid type for 'name', expecting 'string'`);
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_NAME`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[1],
-        value: 123,
-      });
-    }
-  });
-
-  it('should throw invalid type when non-object value check', () => {
-    const newParams = { ...params, roles: 1597929335 };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(`Invalid type for 'roles', expecting 'object'`);
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_ROLES`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[3],
-        value: 1597929335,
-      });
-    }
-  });
-
-  it('should throw invalid type when non-number value check', () => {
-    const newParams = { ...params, Id: '123' };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(`Invalid type for 'Id', expecting 'number'`);
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_ID`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[0],
-        value: '123',
-      });
-    }
-  });
-
-  it('should throw invalid type when non-array value check', () => {
-    const newParams = { ...params, listItem: { created_at: 1597929335 } };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Invalid type for 'listItem', expecting 'array'`
-      );
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_LISTITEM`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[4],
-        value: { created_at: 1597929335 },
-      });
-    }
-  });
-
-  it('should throw required when array value is empty but required', () => {
-    const newParams = { ...params, listItem: [] };
-
-    expect(() => validateFields(newParams, validFields)).toThrow(
-      new LesgoException(
-        `Missing required 'listItem'`,
-        `${FILE}::MISSING_REQUIRED_LISTITEM`
-      )
-    );
-  });
-
-  it('should not throw invalid type when array value is empty and not required', () => {
-    const newParams = { ...params, listItem: [] };
-    const newValidFields = [
-      { key: 'listItem', type: 'array', required: false },
-    ];
-
-    expect(validateFields(newParams, newValidFields)).toMatchObject({
-      listItem: [],
-    });
-  });
-
-  it('should throw invalid type when non-enum value check', async () => {
-    const newParams = { ...params, status: 'private' };
-
-    expect(() => validateFields(newParams, validFields)).toThrow(
-      new LesgoException(
-        `Invalid type for 'status', expecting 'enum'`,
-        `Invalid type for 'status', expecting 'enum'`
-      )
-    );
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(`Invalid type for 'status', expecting 'enum'`);
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_STATUS`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[5],
-        value: 'private',
-      });
-    }
-  });
-
-  it('should throw invalid type when non-function value check', async () => {
-    const newParams = {
-      ...params,
-      functionCheck: { not: 'function' },
-    };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Invalid type for 'functionCheck', expecting 'function'`
-      );
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_FUNCTIONCHECK`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[8],
-        value: { not: 'function' },
-      });
-    }
-  });
-
-  it.each`
-    value
-    ${'not a json'}
-    ${3}
-    ${'"invalid'}
-    ${{ not: 'json' }}
-    ${'{"missing":"bracket"}}'}
-  `(
-    'should throw invalid type when non-json $value check',
-    async ({ value }) => {
-      const newParams = {
-        ...params,
-        jsonCheck: value,
-      };
-
-      try {
-        const validated = validateFields(newParams, validFields);
-
-        expect(validated).toThrow();
-      } catch (e) {
-        expect(e.name).toEqual('LesgoException');
-        expect(e.message).toEqual(
-          `Invalid type for 'jsonCheck', expecting 'json'`
-        );
-        expect(e.code).toEqual(`${FILE}::INVALID_TYPE_JSONCHECK`);
-        expect(e.extra).toStrictEqual({
-          field: validFields[9],
-          value,
-        });
-      }
-    }
-  );
-
-  it('should throw invalid type when non-collection value check', async () => {
-    const newParams = {
-      ...params,
-      statusCollection: 'active',
-    };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Invalid type for 'statusCollection', expecting collection of 'enum'`
-      );
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_STATUSCOLLECTION`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[10],
-        value: 'active',
-      });
-    }
-  });
-
-  it('should ignore type when collection value check is non-required', async () => {
-    const newParams = { ...params };
-    const newValidFields = [...validFields];
-    delete newParams.statusCollection;
-    newValidFields[10].required = false;
-
-    const validated = validateFields(newParams, newValidFields);
-
-    expect(validated).toStrictEqual(newParams);
-  });
-
-  it('should throw invalid type when non-enum collection value check', async () => {
-    const newParams = {
-      ...params,
-      statusCollection: ['archive'],
-    };
-
-    try {
-      const validated = validateFields(newParams, validFields);
-
-      expect(validated).toThrow();
-    } catch (e) {
-      expect(e.name).toEqual('LesgoException');
-      expect(e.message).toEqual(
-        `Invalid type for 'statusCollection', expecting collection of 'enum'`
-      );
-      expect(e.code).toEqual(`${FILE}::INVALID_TYPE_STATUSCOLLECTION`);
-      expect(e.extra).toStrictEqual({
-        field: validFields[10],
-        value: 'archive',
-      });
-    }
-  });
-
-  it('should return only valid and allowed fields when other fields are received', () => {
-    const newParams = { ...params, someOtherKey: 'someOtherValue' };
-    const validated = validateFields(newParams, validFields);
-
-    expect(validated).toMatchObject(params);
-    expect(validated.Id).toBeDefined();
-    expect(validated.someOtherKey).toBeUndefined();
-  });
-
-  it('should return success with validated data for non-required fields', () => {
-    const newParams = { ...params };
-    delete newParams.listItem;
-
-    validFields[4].required = false;
-    const validated = validateFields(newParams, validFields);
-
-    expect(validated).toMatchObject(newParams);
-    expect(validated.Id).toBeDefined();
-    expect(validated.listItem).toBeUndefined();
-
-    validFields[4].required = true;
-  });
-
-  it('should return success with validated data for 0 number', () => {
-    const newParams = { ...params, totalRecord: 0 };
-    const validated = validateFields(newParams, validFields);
-
-    expect(validated).toMatchObject(newParams);
-    expect(validated.totalRecord).toBeDefined();
-    expect(validated.totalRecord).toEqual(0);
-  });
-
-  it('should return success with validated data for number without required', () => {
-    const newParams = { ...params };
-    validFields[7].required = false;
-
-    const validated = validateFields(newParams, validFields);
-
-    expect(validated).toMatchObject(newParams);
-    expect(validated.totalRecord).toBeDefined();
-    expect(validated.totalRecord).toEqual(99);
-
-    validFields[7].required = true;
-  });
-
-  it('should return error with missing required number', () => {
-    const newParams = { ...params };
-    delete newParams.totalRecord;
-
-    expect(() => validateFields(newParams, validFields)).toThrow(
-      new LesgoException(
-        `Missing required 'totalRecord'`,
-        `${FILE}::MISSING_REQUIRED_TOTALRECORD`
-      )
-    );
-  });
-});