test(core): add test for some providers, increase coverage (#50)

Author: akshatdubeysf

.eslintignore

@@ -2,6 +2,7 @@ node_modules/
 dist/
 coverage/
 api-docs/
+typing/
 
 index.*
 .cz-config.js

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,30 @@
+## Description
+
+Please include a summary of the change and which issue is fixed. Please also include relevant motivation and context. List any dependencies that are required for this change.
+
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
+- [ ] Intermediate change (work in progress)
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration
+
+- [ ] Test A
+- [ ] Test B
+
+## Checklist:
+
+- [ ] Performed a self-review of my own code
+- [ ] npm test passes on your machine
+- [ ] New tests added or existing tests modified to cover all changes
+- [ ] Code conforms with the style guide
+- [ ] API Documentation in code was updated
+- [ ] Any dependent changes have been merged and published in downstream modules

.nycrc

@@ -1,5 +1,7 @@
 {
-    "extends": "@istanbuljs/nyc-config-typescript",
-    "all": true,
-    "reporter": ["html"]
+  "include": ["dist"],
+  "exclude": ["dist/__tests__/"],
+  "extension": [".js", ".ts"],
+  "reporter": ["text", "html"],
+  "exclude-after-remap": false
 }

package.json

@@ -16,7 +16,6 @@
     "build": "npm run clean && lb-tsc",
     "build:watch": "lb-tsc --watch",
     "clean": "lb-clean dist *.tsbuildinfo",
-    "coverage": "nyc --reporter=html npm run test",
     "lint": "npm run prettier:check && npm run eslint",
     "lint:fix": "npm run eslint:fix && npm run prettier:fix",
     "prettier:cli": "lb-prettier \"**/*.ts\" \"**/*.js\"",
@@ -26,6 +25,8 @@
     "eslint:fix": "npm run eslint -- --fix",
     "pretest": "npm run build",
     "test": "lb-mocha --allow-console-logs \"dist/__tests__\"",
+    "coverage": "lb-nyc npm run test",
+    "coverage:ci": "lb-nyc report --reporter=text-lcov | coveralls",
     "posttest": "npm run lint",
     "test:dev": "lb-mocha --allow-console-logs dist/__tests__/**/*.js && npm run posttest",
     "prepublishOnly": "npm run test",

src/__tests__/integration/passport-apple-oauth2/apple-oauth2.integration.ts

@@ -0,0 +1,81 @@
+import {Client, createClientForHandler} from '@loopback/testlab';
+import {RestServer} from '@loopback/rest';
+import {Application, Provider} from '@loopback/core';
+import {get} from '@loopback/openapi-v3';
+import {authenticate} from '../../../decorators';
+import {STRATEGY} from '../../../strategy-name.enum';
+import {getApp} from '../helpers/helpers';
+import {MyAuthenticationSequence} from '../../fixtures/sequences/authentication.sequence';
+import {Strategies} from '../../../strategies/keys';
+import {VerifyFunction} from '../../../strategies';
+import {userWithoutReqObj} from '../../fixtures/data/bearer-data';
+import {Request} from '@loopback/rest';
+import AppleStrategy, {DecodedIdToken} from 'passport-apple';
+
+describe('getting apple oauth2 strategy with options', () => {
+  let app: Application;
+  let server: RestServer;
+  beforeEach(givenAServer);
+  beforeEach(givenAuthenticatedSequence);
+  afterEach(closeServer);
+
+  it('should return 200 when client id is passed and passReqToCallback is set true', async () => {
+    getAuthVerifier();
+    class TestController {
+      @get('/test')
+      @authenticate(STRATEGY.APPLE_OAUTH2, {
+        clientID: 'string',
+        clientSecret: 'string',
+        passReqToCallback: true,
+      })
+      test() {
+        return 'test successful';
+      }
+    }
+
+    app.controller(TestController);
+
+    await whenIMakeRequestTo(server).get('/test').expect(200);
+  });
+
+  function whenIMakeRequestTo(restServer: RestServer): Client {
+    return createClientForHandler(restServer.requestHandler);
+  }
+
+  async function givenAServer() {
+    app = getApp();
+    server = await app.getServer(RestServer);
+  }
+
+  function getAuthVerifier() {
+    app
+      .bind(Strategies.Passport.APPLE_OAUTH2_VERIFIER)
+      .toProvider(AppleAuthVerifyProvider);
+  }
+
+  function closeServer() {
+    app.close();
+  }
+
+  function givenAuthenticatedSequence() {
+    // bind user defined sequence
+    server.sequence(MyAuthenticationSequence);
+  }
+});
+
+class AppleAuthVerifyProvider implements Provider<VerifyFunction.AppleAuthFn> {
+  constructor() {}
+
+  value(): VerifyFunction.AppleAuthFn {
+    return async (
+      accessToken: string,
+      refreshToken: string,
+      decodedIdToken: DecodedIdToken,
+      profile: AppleStrategy.Profile,
+      cd: AppleStrategy.VerifyCallback,
+      req?: Request,
+    ) => {
+      return userWithoutReqObj;
+    };
+  }
+}

src/__tests__/integration/passport-keycloak/keycloak.integration.ts

@@ -0,0 +1,82 @@
+import {Client, createClientForHandler} from '@loopback/testlab';
+import {RestServer} from '@loopback/rest';
+import {Application, Provider} from '@loopback/core';
+import {get} from '@loopback/openapi-v3';
+import {authenticate} from '../../../decorators';
+import {STRATEGY} from '../../../strategy-name.enum';
+import {getApp} from '../helpers/helpers';
+import {MyAuthenticationSequence} from '../../fixtures/sequences/authentication.sequence';
+import {Strategies} from '../../../strategies/keys';
+import {Keycloak, VerifyFunction} from '../../../strategies';
+import {userWithoutReqObj} from '../../fixtures/data/bearer-data';
+import {Request} from '@loopback/rest';
+import {IAuthUser} from '../../../types';
+
+describe('getting keycloak oauth2 strategy with options', () => {
+  let app: Application;
+  let server: RestServer;
+  beforeEach(givenAServer);
+  beforeEach(givenAuthenticatedSequence);
+  beforeEach(getAuthVerifier);
+
+  it('should return 200 when host and client id is passed and passReqToCallback is set true', async () => {
+    class TestController {
+      @get('/test')
+      @authenticate(STRATEGY.KEYCLOAK, {
+        host: 'localhost',
+        realm: 'localhost',
+        callbackURL: 'localhost',
+        authorizationURL: 'localhost',
+        tokenURL: 'localhost',
+        userInfoURL: 'localhost',
+        clientID: 'string',
+        clientSecret: 'string',
+        passReqToCallback: true,
+      })
+      test() {
+        return 'test successful';
+      }
+    }
+
+    app.controller(TestController);
+
+    await whenIMakeRequestTo(server).get('/test').expect(200);
+  });
+
+  function whenIMakeRequestTo(restServer: RestServer): Client {
+    return createClientForHandler(restServer.requestHandler);
+  }
+
+  async function givenAServer() {
+    app = getApp();
+    server = await app.getServer(RestServer);
+  }
+
+  function getAuthVerifier() {
+    app
+      .bind(Strategies.Passport.KEYCLOAK_VERIFIER)
+      .toProvider(KeycloakAuthVerifyProvider);
+  }
+
+  function givenAuthenticatedSequence() {
+    // bind user defined sequence
+    server.sequence(MyAuthenticationSequence);
+  }
+});
+
+class KeycloakAuthVerifyProvider
+  implements Provider<VerifyFunction.KeycloakAuthFn> {
+  constructor() {}
+
+  value(): VerifyFunction.KeycloakAuthFn {
+    return async (
+      accessToken: string,
+      refreshToken: string,
+      profile: Keycloak.Profile,
+      cd: (err?: string | Error, user?: IAuthUser) => void,
+      req?: Request,
+    ) => {
+      return userWithoutReqObj;
+    };
+  }
+}

src/__tests__/unit/passport-apple-oauth2/apple-auth-strategy.unit.ts

@@ -0,0 +1,78 @@
+import {IAuthUser} from '../../../types';
+import {expect} from '@loopback/testlab';
+import {
+  AppleAuthStrategyFactory,
+  AppleAuthStrategyFactoryProvider,
+} from '../../../strategies';
+import AppleStrategy, {
+  AuthenticateOptions,
+  AuthenticateOptionsWithRequest,
+} from 'passport-apple';
+
+describe('getting apple-auth strategy with options', () => {
+  it('should return strategy by passing options and passReqToCallback as true', async () => {
+    const strategyVerifier: AppleAuthStrategyFactory = await getStrategy();
+
+    const options: AuthenticateOptions | AuthenticateOptionsWithRequest = {
+      scope: '',
+      teamID: '',
+      keyID: '',
+      clientID: 'string',
+      clientSecret: 'string',
+      passReqToCallback: true,
+    };
+
+    const appleAuthStrategyVerifier = strategyVerifier(options);
+
+    expect(appleAuthStrategyVerifier).to.have.property('name');
+    expect(appleAuthStrategyVerifier)
+      .to.have.property('authenticate')
+      .which.is.a.Function();
+  });
+
+  it('should return strategy by passing options and passReqToCallback as false', async () => {
+    const strategyVerifier: AppleAuthStrategyFactory = await getStrategy();
+
+    const options: AuthenticateOptions | AuthenticateOptionsWithRequest = {
+      scope: '',
+      teamID: '',
+      keyID: '',
+      clientID: 'string',
+      clientSecret: 'string',
+      passReqToCallback: true,
+    };
+
+    const appleAuthStrategyVerifier = strategyVerifier(options);
+
+    expect(appleAuthStrategyVerifier).to.have.property('name');
+    expect(appleAuthStrategyVerifier)
+      .to.have.property('authenticate')
+      .which.is.a.Function();
+  });
+});
+
+async function getStrategy() {
+  const provider = new AppleAuthStrategyFactoryProvider(verifierBearer);
+
+  //this fuction will return a function which will then accept options.
+  return provider.value();
+}
+
+//returning a user
+function verifierBearer(
+  accessToken: string,
+  refreshToken: string,
+  profile: AppleStrategy.Profile,
+): Promise<IAuthUser | null> {
+  const userToPass: IAuthUser = {
+    id: 1,
+    username: 'xyz',
+    password: 'pass',
+  };
+
+  return new Promise(function (resolve, reject) {
+    if (userToPass) {
+      resolve(userToPass);
+    }
+  });
+}

src/__tests__/unit/passport-keycloak-oauth2/keycloak-auth-strategy.unit.ts

@@ -0,0 +1,57 @@
+import {IAuthUser} from '../../../types';
+import {expect} from '@loopback/testlab';
+import {
+  Keycloak,
+  KeycloakStrategyFactory,
+  KeycloakStrategyFactoryProvider,
+} from '../../../strategies';
+
+describe('getting keycloak-auth strategy with options', () => {
+  it('should return strategy by passing required options', async () => {
+    const strategyVerifier: KeycloakStrategyFactory = await getStrategy();
+
+    const options: Keycloak.StrategyOptions = {
+      host: 'localhost',
+      realm: '/',
+      clientID: 'string',
+      clientSecret: 'string',
+      callbackURL: 'localhost',
+      authorizationURL: 'localhost',
+      tokenURL: 'localhost',
+      userInfoURL: 'localhost',
+    };
+
+    const keycloakAuthStrategyVerifier = strategyVerifier(options);
+
+    expect(keycloakAuthStrategyVerifier).to.have.property('name');
+    expect(keycloakAuthStrategyVerifier)
+      .to.have.property('authenticate')
+      .which.is.a.Function();
+  });
+});
+
+async function getStrategy() {
+  const provider = new KeycloakStrategyFactoryProvider(verifierBearer);
+
+  //this fuction will return a function which will then accept options.
+  return provider.value();
+}
+
+//returning a user
+function verifierBearer(
+  accessToken: string,
+  refreshToken: string,
+  profile: Keycloak.Profile,
+): Promise<IAuthUser | null> {
+  const userToPass: IAuthUser = {
+    id: 1,
+    username: 'xyz',
+    password: 'pass',
+  };
+
+  return new Promise(function (resolve, reject) {
+    if (userToPass) {
+      resolve(userToPass);
+    }
+  });
+}