lesgo 0.7.8 → 2.1.0

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

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

@@ -1,223 +0,0 @@
-import LengthAwarePaginator from '../pagination/LengthAwarePaginator';
-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/LengthAwarePaginator';
-
-describe('test LengthAwarePaginator instantiate', () => {
-  it('should not throw exception when instantiating', async () => {
-    const paginator = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-        total: 30,
-      }
-    );
-
-    expect(await paginator.count()).toEqual(5);
-    expect(paginator.currentPage()).toEqual(1);
-    expect(await paginator.firstItem()).toMatchObject(mockDataFirstItem);
-    expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
-    expect(paginator.perPage()).toEqual(5);
-    expect(await paginator.total()).toEqual(30);
-
-    expect(db.select).toHaveBeenCalled();
-  });
-  it('should not throw exception when instantiating with current page', async () => {
-    const paginator = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 2,
-        total: 30,
-      }
-    );
-
-    expect(await paginator.count()).toEqual(5);
-    expect(paginator.currentPage()).toEqual(2);
-    expect(await paginator.firstItem()).toMatchObject(mockDataFirstItem);
-    expect(await paginator.lastItem()).toMatchObject(mockDataLastItem);
-    expect(paginator.perPage()).toEqual(5);
-    expect(await paginator.total()).toEqual(30);
-
-    expect(db.select).toHaveBeenCalled();
-  });
-  it('should default perPage to 10 when instantiating without perPage', async () => {
-    const paginator = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        total: 30,
-      }
-    );
-
-    expect(await paginator.count()).toEqual(10);
-    expect(paginator.currentPage()).toEqual(1);
-    expect(paginator.perPage()).toEqual(10);
-    expect(await paginator.total()).toEqual(30);
-
-    expect(db.select).toHaveBeenCalled();
-  });
-  it('should throw exception if total is not a number', async () => {
-    try {
-      expect(
-        new LengthAwarePaginator(
-          db,
-          'SELECT * FROM tests',
-          {},
-          {
-            perPage: 5,
-            currentPage: 1,
-            total: 'test',
-          }
-        )
-      ).toThrow();
-    } catch (err) {
-      expect(err.name).toEqual('LesgoException');
-      expect(err.message).toEqual(
-        "Invalid type for 'total', expecting 'number'"
-      );
-      expect(err.code).toEqual(`${FILE}::FIELD_VALIDATION_EXCEPTION`);
-      expect(err.statusCode).toEqual(500);
-    }
-  });
-  it('should return the object version of the paginator', async () => {
-    const paginator = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        perPage: 5,
-        total: 30,
-      }
-    );
-    expect(await paginator.toObject()).toMatchObject({
-      count: 5,
-      previous_page: false,
-      current_page: 1,
-      next_page: 2,
-      per_page: 5,
-      last_page: 6,
-      total: 30,
-      items: [
-        { ...mockDataFirstItem },
-        { ...mockData },
-        { ...mockData },
-        { ...mockData },
-        { ...mockDataLastItem },
-      ],
-    });
-
-    expect(db.select).toHaveBeenCalled();
-  });
-
-  it('should simply return an empty paginator object if total is explicitly zero', async () => {
-    const paginator = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 1,
-        total: 0,
-      }
-    );
-
-    expect(await paginator.count()).toEqual(0);
-    expect(await paginator.previousPage()).toEqual(false);
-    expect(paginator.currentPage()).toEqual(1);
-    expect(await paginator.nextPage()).toEqual(false);
-    expect(await paginator.firstItem()).toBe(undefined);
-    expect(await paginator.lastItem()).toBe(undefined);
-    expect(paginator.perPage()).toEqual(5);
-    expect(await paginator.total()).toEqual(0);
-
-    expect(await paginator.toObject()).toMatchObject({
-      count: 0,
-      previous_page: false,
-      current_page: 1,
-      next_page: false,
-      per_page: 5,
-      last_page: 0,
-      total: 0,
-      items: [],
-    });
-
-    expect(db.select).not.toHaveBeenCalled();
-  });
-});
-
-describe('test total() usage', () => {
-  it('should get total number of data using supplied paramater', async () => {
-    const paginator = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        perPage: 10,
-        currentPage: 1,
-        total: 30,
-      }
-    );
-
-    expect(await paginator.total()).toEqual(30);
-    expect(db.select).not.toHaveBeenCalled();
-  });
-});
-
-describe('test lastPage() usage', () => {
-  it('should get the last page using supplied parameter as total data', async () => {
-    const paginator1 = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        perPage: 10,
-        currentPage: 1,
-        total: 30,
-      }
-    );
-    expect(await paginator1.lastPage()).toEqual(3);
-
-    const paginator2 = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        perPage: 5,
-        currentPage: 1,
-        total: 30,
-      }
-    );
-    expect(await paginator2.lastPage()).toEqual(6);
-
-    const paginator3 = new LengthAwarePaginator(
-      db,
-      'SELECT * FROM total_tests',
-      {},
-      {
-        perPage: 7,
-        currentPage: 1,
-        total: 30,
-      }
-    );
-    expect(await paginator3.lastPage()).toEqual(5);
-
-    expect(db.select).not.toHaveBeenCalled();
-  });
-});