Add unit tests for handleRecaptchaFlow

packages/auth/src/platform_browser/recaptcha/recaptcha_enterprise_verifier.test.ts

@@ -20,17 +20,27 @@ import chaiAsPromised from 'chai-as-promised';
 import * as sinon from 'sinon';
 import sinonChai from 'sinon-chai';
 
-import { Endpoint, RecaptchaClientType, RecaptchaVersion } from '../../api';
+import {
+  Endpoint,
+  RecaptchaClientType,
+  RecaptchaVersion,
+  RecaptchaActionName
+} from '../../api';
 import { mockEndpointWithParams } from '../../../test/helpers/api/helper';
 import { testAuth, TestAuth } from '../../../test/helpers/mock_auth';
 import * as mockFetch from '../../../test/helpers/mock_fetch';
 import { ServerError } from '../../api/errors';
+import { AuthInternal } from '../../model/auth';
 
 import { MockGreCAPTCHATopLevel } from './recaptcha_mock';
 import {
   RecaptchaEnterpriseVerifier,
-  FAKE_TOKEN
+  FAKE_TOKEN,
+  handleRecaptchaFlow
 } from './recaptcha_enterprise_verifier';
+import { RecaptchaConfig } from './recaptcha';
+import { AuthErrorCode } from '../../core/errors';
+import { _createError } from '../../core/util/assert';
 
 use(chaiAsPromised);
 use(sinonChai);
@@ -39,6 +49,29 @@ describe('platform_browser/recaptcha/recaptcha_enterprise_verifier', () => {
   let auth: TestAuth;
   let verifier: RecaptchaEnterpriseVerifier;
 
+  const recaptchaConfigResponseEnforce = {
+    recaptchaKey: 'foo/bar/to/site-key',
+    recaptchaEnforcementState: [
+      {
+        provider: 'EMAIL_PASSWORD_PROVIDER',
+        enforcementState: 'ENFORCE'
+      }
+    ]
+  };
+  const recaptchaConfigEnforce = new RecaptchaConfig(
+    recaptchaConfigResponseEnforce
+  );
+  const recaptchaConfigResponseOff = {
+    recaptchaKey: 'foo/bar/to/site-key',
+    recaptchaEnforcementState: [
+      {
+        provider: 'EMAIL_PASSWORD_PROVIDER',
+        enforcementState: 'OFF'
+      }
+    ]
+  };
+  const recaptchaConfigOff = new RecaptchaConfig(recaptchaConfigResponseOff);
+
   beforeEach(async () => {
     auth = await testAuth();
     mockFetch.setUp();
@@ -51,16 +84,6 @@ describe('platform_browser/recaptcha/recaptcha_enterprise_verifier', () => {
   });
 
   context('#verify', () => {
-    const recaptchaConfigResponseEnforce = {
-      recaptchaKey: 'foo/bar/to/site-key',
-      recaptchaEnforcementState: [
-        {
-          provider: 'EMAIL_PASSWORD_PROVIDER',
-          enforcementState: 'ENFORCE'
-        }
-      ]
-    };
-
     const request = {
       clientType: RecaptchaClientType.WEB,
       version: RecaptchaVersion.ENTERPRISE
@@ -117,4 +140,110 @@ describe('platform_browser/recaptcha/recaptcha_enterprise_verifier', () => {
       expect(await verifier.verify()).to.eq(FAKE_TOKEN);
     });
   });
+
+  context('handleRecaptchaFlow', () => {
+    let mockAuthInstance: AuthInternal;
+    let mockRequest: any;
+    let mockActionMethod: sinon.SinonStub;
+
+    beforeEach(async () => {
+      mockAuthInstance = await testAuth();
+      mockRequest = {};
+      mockActionMethod = sinon.stub();
+    });
+
+    afterEach(() => {
+      sinon.restore();
+    });
+
+    it('should call actionMethod with request if emailPasswordEnabled is true', async () => {
+      if (typeof window === 'undefined') {
+        return;
+      }
+      sinon
+        .stub(mockAuthInstance, '_getRecaptchaConfig')
+        .returns(recaptchaConfigEnforce);
+      sinon
+        .stub(RecaptchaEnterpriseVerifier.prototype, 'verify')
+        .resolves('recaptcha-response');
+      mockRequest = { foo: 'bar' };
+      mockActionMethod = sinon.stub().resolves('testResponse');
+      const response = await handleRecaptchaFlow(
+        mockAuthInstance,
+        mockRequest,
+        RecaptchaActionName.SIGN_IN_WITH_PASSWORD,
+        mockActionMethod
+      );
+      expect(mockActionMethod).to.have.been.calledOnce;
+      expect(response).to.equal('testResponse');
+    });
+
+    // "Errors like "MISSING_RECAPTCHA_TOKEN" will be handled irrespective of the enablement status of "emailPasswordEnabled", but this test verifies the more likely scenario where emailPasswordEnabled is false"
+    it('should handle MISSING_RECAPTCHA_TOKEN error when emailPasswordEnabled is false', async () => {
+      if (typeof window === 'undefined') {
+        return;
+      }
+      sinon
+        .stub(mockAuthInstance, '_getRecaptchaConfig')
+        .returns(recaptchaConfigOff);
+      sinon
+        .stub(RecaptchaEnterpriseVerifier.prototype, 'verify')
+        .resolves('recaptcha-response');
+      mockRequest = { foo: 'bar' };
+      let callCount = 0;
+      mockActionMethod = sinon.stub().callsFake(() => {
+        callCount++;
+        if (callCount === 1) {
+          return Promise.reject(
+            _createError(AuthErrorCode.MISSING_RECAPTCHA_TOKEN)
+          );
+        } else {
+          return Promise.resolve('testResponse');
+        }
+      });
+      const response = await handleRecaptchaFlow(
+        mockAuthInstance,
+        mockRequest,
+        RecaptchaActionName.SIGN_IN_WITH_PASSWORD,
+        mockActionMethod
+      );
+      expect(mockActionMethod).to.have.been.calledTwice;
+      expect(response).to.equal('testResponse');
+    });
+
+    it('should handle non MISSING_RECAPTCHA_TOKEN error when emailPasswordEnabled is false', async () => {
+      if (typeof window === 'undefined') {
+        return;
+      }
+      sinon
+        .stub(mockAuthInstance, '_getRecaptchaConfig')
+        .returns(recaptchaConfigOff);
+      sinon
+        .stub(RecaptchaEnterpriseVerifier.prototype, 'verify')
+        .resolves('recaptcha-response');
+      mockRequest = { foo: 'bar' };
+      let callCount = 0;
+      mockActionMethod = sinon.stub().callsFake(() => {
+        callCount++;
+        if (callCount === 1) {
+          return Promise.reject(
+            _createError(AuthErrorCode.RECAPTCHA_NOT_ENABLED)
+          );
+        } else {
+          return Promise.resolve('testResponse');
+        }
+      });
+
+      const response = handleRecaptchaFlow(
+        mockAuthInstance,
+        mockRequest,
+        RecaptchaActionName.SIGN_IN_WITH_PASSWORD,
+        mockActionMethod
+      );
+      await expect(response).to.be.rejectedWith(
+        AuthErrorCode.RECAPTCHA_NOT_ENABLED
+      );
+      expect(mockActionMethod).to.have.been.calledOnce;
+    });
+  });
 });