lesgo 1.0.0 → 2.1.1

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

@@ -1,201 +0,0 @@
-import config from 'Config/elasticsearch'; // eslint-disable-line import/no-unresolved
-import ElasticsearchService from '../ElasticsearchService';
-
-// TODO we'll need to add more expected response
-
-describe('ServicesGroup: test ElasticsearchService', () => {
-  it('test instantiate default ElasticsearchService connection', () => {
-    const es = new ElasticsearchService(config.adapters.mocked);
-    expect(es.getClient()).toMatchObject({
-      mocked: {
-        conn: undefined,
-      },
-    });
-  });
-
-  it('test search', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    return expect(es.search({ someKey: 'someValue' })).resolves.toMatchObject({
-      mocked: {
-        param: {
-          body: {
-            someKey: 'someValue',
-          },
-          index: 'lesgo',
-          type: '_doc',
-        },
-      },
-    });
-  });
-
-  it('test msearch', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    const params = [
-      { index: config.adapters.aws.index },
-      {
-        query: {
-          bool: {
-            must: { id: 123 },
-            must_not: { is_deleted: 1 },
-          },
-        },
-      },
-    ];
-
-    return expect(es.msearch(params)).resolves.toMatchObject({
-      mocked: {
-        params: {
-          body: [
-            { index: config.adapters.aws.index },
-            {
-              query: {
-                bool: {
-                  must: { id: 123 },
-                  must_not: { is_deleted: 1 },
-                },
-              },
-            },
-          ],
-        },
-      },
-    });
-  });
-
-  it('test get', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    return expect(es.get(1)).resolves.toMatchObject({
-      mocked: {
-        params: {
-          id: 1,
-        },
-      },
-    });
-  });
-
-  it('test create', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    return expect(
-      es.create(1, { someKey: 'someValue' })
-    ).resolves.toMatchObject({
-      mocked: {
-        params: {
-          id: 1,
-          body: {
-            someKey: 'someValue',
-          },
-        },
-      },
-    });
-  });
-
-  it('test indexOrCreateById', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    return expect(
-      es.indexOrCreateById({ id: 1, someKey: 'someValue' })
-    ).resolves.toMatchObject({
-      mocked: {
-        params: {
-          id: 1,
-          body: {
-            someKey: 'someValue',
-          },
-        },
-      },
-    });
-  });
-
-  it('test updateById', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    return expect(es.updateById(1)).resolves.toMatchObject({
-      mocked: {
-        params: {
-          id: 1,
-        },
-      },
-    });
-  });
-
-  it('test bulkIndex', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    const bodies = [
-      {
-        profile_id: 1,
-        someKey1: 'someValue1',
-      },
-      {
-        profile_id: 2,
-        someKey2: 'someValue2',
-      },
-    ];
-
-    return expect(es.bulkIndex(bodies)).resolves.toMatchObject({
-      mocked: {
-        bodies: {
-          body: [
-            {
-              index: {
-                _id: 1,
-              },
-            },
-            {
-              profile_id: 1,
-              someKey1: 'someValue1',
-            },
-            {
-              index: {
-                _id: 2,
-              },
-            },
-            {
-              profile_id: 2,
-              someKey2: 'someValue2',
-            },
-          ],
-        },
-      },
-    });
-  });
-
-  it('test deleteIndices', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    return expect(
-      es.deleteIndices(config.adapters.aws.index)
-    ).resolves.toMatchObject({
-      mocked: {
-        params: {
-          index: config.adapters.aws.index,
-        },
-      },
-    });
-  });
-
-  it('test existIndeces', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    return expect(
-      es.existIndices(config.adapters.aws.index)
-    ).resolves.toMatchObject({
-      mocked: {
-        params: {
-          index: config.adapters.aws.index,
-        },
-      },
-    });
-  });
-
-  it('test putMapping', () => {
-    const es = new ElasticsearchService(config.adapters.aws);
-    return expect(
-      es.putMapping(config.adapters.aws.index, 'mockType', 'mockBody')
-    ).resolves.toMatchObject({
-      mocked: {
-        params: {
-          index: config.adapters.aws.index,
-          type: 'mockType',
-          body: {
-            properties: 'mockBody',
-          },
-        },
-      },
-    });
-  });
-});

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

@@ -1,356 +0,0 @@
-import * as firebaseAdmin from 'firebase-admin';
-import firebaseConfig from 'Config/firebase'; // eslint-disable-line import/no-unresolved
-import FirebaseAdminService from '../FirebaseAdminService';
-import LesgoException from '../../exceptions/LesgoException';
-
-describe('test FirebaseAdminService connect', () => {
-  it('should not throw an error when instantiating FirebaseAdminService', () => {
-    // eslint-disable-next-line no-unused-vars
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    expect(firebaseAdmin.initializeApp).toHaveBeenCalledWith({
-      credential: firebaseAdmin.credential.cert(firebaseConfig.serviceAccount),
-      databaseURL: `https://${firebaseConfig.projectName}.firebaseio.com`,
-    });
-
-    expect(firebaseAdmin.credential.cert).toHaveBeenCalledWith(
-      firebaseConfig.serviceAccount
-    );
-  });
-
-  it('should have the new configuration when updating connection credentials', () => {
-    const firebaseAdminConfig = {
-      serviceAccount: JSON.stringify({ someCredKey: 'someCredValue' }),
-      projectName: 'fakeProjectName',
-    };
-
-    const fbAdmin = new FirebaseAdminService(firebaseConfig);
-    fbAdmin.connect(firebaseAdminConfig);
-
-    expect(firebaseAdmin.initializeApp).toHaveBeenCalledWith({
-      credential: firebaseAdmin.credential.cert(
-        firebaseAdminConfig.serviceAccount
-      ),
-      databaseURL: `https://${firebaseAdminConfig.projectName}.firebaseio.com`,
-    });
-  });
-
-  it('should throw an error when instantiating FirebaseAdminService without setting opts', () => {
-    try {
-      expect(new FirebaseAdminService()).toThrow();
-    } catch (err) {
-      expect(err).toMatchObject(
-        new LesgoException(
-          'Missing required parameters serviceAccount and or projectName',
-          'FIREBASEADMIN_MISSING_PARAMETERS',
-          500
-        )
-      );
-    }
-  });
-
-  it('should throw an error when instantiating FirebaseAdminService with missing serviceAccount', () => {
-    try {
-      expect(
-        new FirebaseAdminService({
-          projectName: firebaseConfig.projectName,
-        })
-      ).toThrow();
-    } catch (err) {
-      expect(err).toMatchObject(
-        new LesgoException(
-          'Missing required parameters serviceAccount and or projectName',
-          'FIREBASEADMIN_MISSING_PARAMETERS',
-          500
-        )
-      );
-    }
-  });
-
-  it('should throw an error when instantiating FirebaseAdminService with missing projectName', () => {
-    try {
-      expect(
-        new FirebaseAdminService({
-          serviceAccount: JSON.stringify({ someCredKey: 'someCredValue' }),
-        })
-      ).toThrow();
-    } catch (err) {
-      expect(err).toMatchObject(
-        new LesgoException(
-          'Missing required parameters serviceAccount and or projectName',
-          'FIREBASEADMIN_MISSING_PARAMETERS',
-          500
-        )
-      );
-    }
-  });
-});
-
-describe('test FirebaseAdminService getAllUsers', () => {
-  it('should return list of users with default', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    const firebaseUsers = await fbAdmin.getAllUsers();
-
-    expect(firebaseUsers).toMatchObject([
-      {
-        uid: 'some-uid-001',
-        email: 'some+email001@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser001',
-      },
-      {
-        uid: 'some-uid-002',
-        email: 'some+email002@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser002',
-      },
-      {
-        uid: 'some-uid-003',
-        email: 'some+email003@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser003',
-      },
-    ]);
-  });
-
-  it('should return list of users with maxResults', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    const firebaseUsers = await fbAdmin.getAllUsers(25);
-
-    expect(firebaseUsers).toMatchObject([
-      {
-        uid: 'some-uid-001',
-        email: 'some+email001@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser001',
-      },
-      {
-        uid: 'some-uid-002',
-        email: 'some+email002@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser002',
-      },
-      {
-        uid: 'some-uid-003',
-        email: 'some+email003@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser003',
-      },
-    ]);
-  });
-
-  it('should return list of users when calling calling the function with valid nextPageToken', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    const firebaseUsers = await fbAdmin.getAllUsers(
-      25,
-      'SAMPLE_NEXTPAGE_TOKEN'
-    );
-
-    expect(firebaseUsers).toMatchObject([
-      {
-        uid: 'some-uid-001',
-        email: 'some+email001@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser001',
-      },
-      {
-        uid: 'some-uid-002',
-        email: 'some+email002@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser002',
-      },
-      {
-        uid: 'some-uid-003',
-        email: 'some+email003@mail.com',
-        emailVerified: false,
-        displayName: 'SomeUser003',
-      },
-    ]);
-  });
-
-  it('should throw an exception with invalid maxResults', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    try {
-      await fbAdmin.getAllUsers('asd');
-    } catch (err) {
-      expect(err).toMatchObject(
-        new LesgoException(
-          'Failed to fetch all users from firebase',
-          'FIREBASE_FETCH_USERS',
-          500,
-          {
-            err: {
-              code: 'auth/argument-error',
-              message:
-                'Required "maxResults" must be a positive integer that does not exceed 1000.',
-            },
-          }
-        )
-      );
-    }
-  });
-
-  it('should throw an exception with invalid nextPageToken', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    try {
-      await fbAdmin.getAllUsers(25, {
-        token: 'invalidToken',
-      });
-    } catch (err) {
-      expect(err).toMatchObject(
-        new LesgoException(
-          'Failed to fetch all users from firebase',
-          'FIREBASE_FETCH_USERS',
-          500,
-          {
-            err: {
-              code: 'auth/invalid-page-token',
-              message: 'The page token must be a valid non-empty string.',
-            },
-          }
-        )
-      );
-    }
-  });
-});
-
-describe('test FirebaseAdminService createUser', () => {
-  it('should return success response when calling the function', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    const firebaseUser = await fbAdmin.createUser({
-      uid: 'some-uid',
-      email: 'someemail@mail.com',
-      password: 'somePassword',
-      username: 'someUsername',
-    });
-
-    expect(firebaseUser).toMatchObject({
-      uid: 'some-uid',
-      email: 'someemail@mail.com',
-      emailVerified: false,
-      displayName: 'someUsername',
-    });
-  });
-
-  it('should throw an exception with existing email', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    try {
-      await fbAdmin.createUser({
-        uid: 'some-uid',
-        email: 'existingEmail@mail.com',
-        password: 'somePassword',
-        username: 'someUsername',
-      });
-    } catch (err) {
-      expect(err).toMatchObject(
-        new LesgoException(
-          'Failed to create user on firebase',
-          'FIREBASE_CREATE_USER',
-          400,
-          {
-            err: {
-              code: 'auth/email-already-exists',
-              message:
-                'The email address is already in use by another account.',
-            },
-          }
-        )
-      );
-    }
-  });
-});
-
-describe('test FirebaseAdminService deleteUser', () => {
-  it('should return success response when calling the function', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    const firebaseUser = await fbAdmin.deleteUser('some-uid');
-    expect(firebaseUser).toMatchObject({ uid: 'some-uid' });
-  });
-
-  it('should throw an exception with non-existing uid', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    try {
-      await fbAdmin.deleteUser('non-existing-uid');
-    } catch (err) {
-      expect(err.name).toBe('LesgoException');
-      expect(err.message).toBe('Failed to delete user from firebase');
-      expect(err.statusCode).toBe(400);
-      expect(err.code).toBe('FIREBASE_DELETE_USER');
-      expect(err.extra.err).toMatchObject(
-        new Error(
-          'FAKE-The user does not exist.',
-          'FAKE-auth/user-does-not-exist'
-        )
-      );
-    }
-  });
-});
-
-describe('test FirebaseAdminService delete', () => {
-  it('should return success response when calling the function', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: firebaseConfig.projectName,
-    });
-
-    return expect(fbAdmin.delete()).resolves.toBeDefined();
-  });
-
-  it('should be able to catch thrown exception', async () => {
-    const fbAdmin = new FirebaseAdminService({
-      serviceAccount: firebaseConfig.serviceAccount,
-      projectName: 'fakeError',
-    });
-
-    try {
-      const resp = await fbAdmin.delete();
-      expect(resp).toThrow();
-    } catch (err) {
-      expect(err).toMatchObject(
-        new LesgoException(
-          'Failed to delete firebase app',
-          'FIREBASE_DELETE_APP'
-        )
-      );
-    }
-  });
-});

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

@@ -1,35 +0,0 @@
-import config from 'Config/jwt'; // eslint-disable-line import/no-unresolved
-import jwt from 'jsonwebtoken';
-import JwtService from '../JwtService';
-import { token } from '../../middlewares/verifyJwtMiddleware';
-
-describe('ServicesGroup: test JwtService instantiation', () => {
-  it('test instantiate default JwtService', () => {
-    const headers = {
-      Authorization:
-        'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJpc3MiOiJkb21haW4uY29tIiwiZGVwYXJ0bWVudF9pZCI6MX0.pa2TBRqdVSFUhmiglB8SD8ImthqhqZBn0stAdNRcJ3w',
-    };
-
-    const service = new JwtService(token(headers), config);
-
-    expect(service).toMatchObject({
-      decoded: {
-        sub: '1234567890',
-        name: 'John Doe',
-        iss: config.iss.data[0],
-      },
-      settings: {
-        validate: {
-          iss: config.iss.validate,
-          customClaims: config.customClaims.validate,
-        },
-        config: {
-          iss: config.iss.data,
-          customClaims: config.customClaims.data,
-        },
-      },
-    });
-
-    expect(service.jwt()).toMatchObject(jwt);
-  });
-});