test(provider): add test cases for Cognito OAuth

src/__tests__/fixtures/providers/cognito-auth.provider.ts

@@ -0,0 +1,32 @@
+import {Provider} from '@loopback/context';
+import {Request} from '@loopback/rest';
+import {Cognito, IAuthUser, VerifyFunction} from '../../../types';
+
+/**
+ * A provider for default implementation of VerifyFunction.CognitoAuthFn
+ *
+ * It will just throw an error saying Not Implemented
+ */
+export class BearerTokenVerifyProvider
+  implements Provider<VerifyFunction.CognitoAuthFn>
+{
+  constructor() {}
+
+  value(): VerifyFunction.CognitoAuthFn {
+    return async (
+      accessToken: string,
+      refreshToken: string,
+      profile: Cognito.Profile,
+      cb: Cognito.VerifyCallback,
+      req?: Request,
+    ) => {
+      const userToPass: IAuthUser = {
+        id: 1,
+        username: 'xyz',
+        password: 'pass',
+      };
+
+      return userToPass;
+    };
+  }
+}

src/__tests__/integration/action-sequence/passport-cognito-oauth2/cognito-oauth2.integration.ts

@@ -0,0 +1,76 @@
+import {Client, createClientForHandler} from '@loopback/testlab';
+import {RestServer, Request} 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 {Cognito} from '../../../../types';
+
+describe('getting cognito oauth2 strategy with options', () => {
+  let app: Application;
+  let server: RestServer;
+  beforeEach(givenAServer);
+  beforeEach(givenAuthenticatedSequence);
+  beforeEach(getAuthVerifier);
+
+  it('should return 302 when client id is passed and passReqToCallback is set true', async () => {
+    class TestController {
+      @get('/test')
+      @authenticate(STRATEGY.COGNITO_OAUTH2, {
+        clientID: 'string',
+        clientSecret: 'string',
+        passReqToCallback: true,
+      })
+      test() {
+        return 'test successful';
+      }
+    }
+
+    app.controller(TestController);
+
+    await whenIMakeRequestTo(server).get('/test').expect(302);
+  });
+
+  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.COGNITO_OAUTH2_VERIFIER)
+      .toProvider(CognitoAuthVerifyProvider);
+  }
+
+  function givenAuthenticatedSequence() {
+    // bind user defined sequence
+    server.sequence(MyAuthenticationSequence);
+  }
+});
+
+class CognitoAuthVerifyProvider
+  implements Provider<VerifyFunction.CognitoAuthFn>
+{
+  constructor() {}
+
+  value(): VerifyFunction.CognitoAuthFn {
+    return async (
+      accessToken: string,
+      refreshToken: string,
+      profile: Cognito.Profile,
+      cd: Cognito.VerifyCallback,
+      req?: Request,
+    ) => {
+      return userWithoutReqObj;
+    };
+  }
+}

src/__tests__/integration/middleware-sequence/passport-cognito-oauth2/cognito-oauth2.integration.ts

@@ -0,0 +1,76 @@
+import {Client, createClientForHandler} from '@loopback/testlab';
+import {RestServer, Request} 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 {Strategies} from '../../../../strategies/keys';
+import {VerifyFunction} from '../../../../strategies';
+import {userWithoutReqObj} from '../../../fixtures/data/bearer-data';
+import {Cognito} from '../../../../types';
+import {MyAuthenticationMiddlewareSequence} from '../../../fixtures/sequences/authentication-middleware.sequence';
+
+describe('getting cognito oauth2 strategy with options using Middleware Sequence', () => {
+  let app: Application;
+  let server: RestServer;
+  beforeEach(givenAServer);
+  beforeEach(givenAuthenticatedSequence);
+  beforeEach(getAuthVerifier);
+
+  it('should return 302 when client id is passed and passReqToCallback is set true', async () => {
+    class TestController {
+      @get('/test')
+      @authenticate(STRATEGY.COGNITO_OAUTH2, {
+        clientID: 'string',
+        clientSecret: 'string',
+        passReqToCallback: true,
+      })
+      test() {
+        return 'test successful';
+      }
+    }
+
+    app.controller(TestController);
+
+    await whenIMakeRequestTo(server).get('/test').expect(302);
+  });
+
+  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.COGNITO_OAUTH2_VERIFIER)
+      .toProvider(CognitoAuthVerifyProvider);
+  }
+
+  function givenAuthenticatedSequence() {
+    // bind user defined sequence
+    server.sequence(MyAuthenticationMiddlewareSequence);
+  }
+});
+
+class CognitoAuthVerifyProvider
+  implements Provider<VerifyFunction.CognitoAuthFn>
+{
+  constructor() {}
+
+  value(): VerifyFunction.CognitoAuthFn {
+    return async (
+      accessToken: string,
+      refreshToken: string,
+      profile: Cognito.Profile,
+      cd: Cognito.VerifyCallback,
+      req?: Request,
+    ) => {
+      return userWithoutReqObj;
+    };
+  }
+}

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

@@ -0,0 +1,74 @@
+import {Cognito, IAuthUser} from '../../../types';
+import {expect} from '@loopback/testlab';
+import {
+  CognitoStrategyFactoryProvider,
+  CognitoAuthStrategyFactory,
+} from '../../../strategies/passport/passport-cognito-oauth2';
+
+describe('getting cognito-auth strategy with options', () => {
+  it('should return strategy by passing options and passReqToCallback as true', async () => {
+    const strategyVerifier: CognitoAuthStrategyFactory = await getStrategy();
+
+    const options: Cognito.StrategyOptions = {
+      callbackURL: 'string',
+      clientDomain: 'string',
+      clientID: 'string',
+      clientSecret: 'string',
+      region: 'string',
+      passReqToCallback: true,
+    };
+
+    const cognitoAuthStrategyVerifier = strategyVerifier(options);
+
+    expect(cognitoAuthStrategyVerifier).to.have.property('name');
+    expect(cognitoAuthStrategyVerifier)
+      .to.have.property('authenticate')
+      .which.is.a.Function();
+  });
+
+  it('should return strategy by passing options and passReqToCallback as false', async () => {
+    const strategyVerifier: CognitoAuthStrategyFactory = await getStrategy();
+
+    const options: Cognito.StrategyOptions = {
+      callbackURL: 'string',
+      clientDomain: 'string',
+      clientID: 'string',
+      clientSecret: 'string',
+      region: 'string',
+      passReqToCallback: false,
+    };
+
+    const cognitoAuthStrategyVerifier = strategyVerifier(options);
+
+    expect(cognitoAuthStrategyVerifier).to.have.property('name');
+    expect(cognitoAuthStrategyVerifier)
+      .to.have.property('authenticate')
+      .which.is.a.Function();
+  });
+});
+
+async function getStrategy() {
+  const provider = new CognitoStrategyFactoryProvider(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: Cognito.Profile,
+): Promise<IAuthUser | null> {
+  const userToPass: IAuthUser = {
+    id: 1,
+    username: 'xyz',
+    password: 'pass',
+  };
+
+  return new Promise(function (resolve, reject) {
+    if (userToPass) {
+      resolve(userToPass);
+    }
+  });
+}