Merge 87410b7 into aef653d

Author: sam-gc

packages-exp/auth-exp/demo/src/index.js

@@ -50,11 +50,26 @@ import {
   signInWithCustomToken,
   signInWithEmailAndPassword,
   unlink,
+<<<<<<< HEAD
   updateEmail,
   updatePassword,
   updateProfile,
   verifyPasswordResetCode
 } from '@firebase/auth-exp';
+=======
+  getMultiFactorResolver,
+  multiFactor,
+  PhoneMultiFactorGenerator,
+  OAuthProvider,
+  signInWithPopup,
+  linkWithPopup,
+  reauthenticateWithPopup,
+  BrowserPopupRedirectResolver
+} from '@firebase/auth-exp';
+
+const browserPopupRedirectResolver = new BrowserPopupRedirectResolver();
+
+>>>>>>> ad6dfaac7... Popup strategy implementation
 import { config } from './config';
 import {
   alertError,
@@ -1182,10 +1197,9 @@ function onPopupRedirectAddCustomParam(_event) {
  * Performs the corresponding popup/redirect action for a generic provider.
  */
 function onPopupRedirectGenericProviderClick() {
-  alertNotImplemented();
-  // var providerId = $('#popup-redirect-generic-providerid').val();
-  // var provider = new OAuthProvider(providerId);
-  // signInWithPopupRedirect(provider);
+  var providerId = $('#popup-redirect-generic-providerid').val();
+  var provider = new OAuthProvider(providerId);
+  signInWithPopupRedirect(provider);
 }
 
 /**
@@ -1231,11 +1245,16 @@ function onPopupRedirectProviderClick(_event) {
  *     sign in.
  */
 function signInWithPopupRedirect(provider) {
-  const action = $('input[name=popup-redirect-action]:checked').val();
-  const type = $('input[name=popup-redirect-type]:checked').val();
+  const glob = {
+    signInWithPopup,
+    linkWithPopup,
+    reauthenticateWithPopup,
+  }
+  let action = $('input[name=popup-redirect-action]:checked').val();
+  let type = $('input[name=popup-redirect-type]:checked').val();
   let method = null;
   let inst = null;
-  if (action === 'link' || action === 'reauthenticate') {
+  if (action == 'link' || action == 'reauthenticate') {
     if (!activeUser()) {
       alertError('No user logged in.');
       return;
@@ -1285,21 +1304,23 @@ function signInWithPopupRedirect(provider) {
   }
   console.log('Provider:');
   console.log(provider);
-  if (type === 'popup') {
-    inst[method](provider).then(response => {
+  if (type == 'popup') {
+    glob[method](inst, provider, browserPopupRedirectResolver).then(response => {
       console.log('Popup response:');
       console.log(response);
       alertSuccess(action + ' with ' + provider['providerId'] + ' successful!');
       logAdditionalUserInfo(response);
       onAuthSuccess(activeUser());
-    }, onAuthError);
+    },
+    onAuthError);
   } else {
-    try {
-      inst[method](provider).catch(onAuthError);
-    } catch (error) {
-      console.log('Error while calling ' + method);
-      console.error(error);
-    }
+    alertNotImplemented();
+    // try {
+    //   inst[method](provider).catch(onAuthError);
+    // } catch (error) {
+    //   console.log('Error while calling ' + method);
+    //   console.error(error);
+    // }
   }
 }
 

packages-exp/auth-exp/src/core/strategies/abstract_popup_redirect_operation.test.ts

@@ -0,0 +1,240 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { expect, use } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+import * as sinon from 'sinon';
+import * as sinonChai from 'sinon-chai';
+
+import { OperationType } from '@firebase/auth-types-exp';
+import { FirebaseError } from '@firebase/util';
+
+import { delay } from '../../../test/delay';
+import { authEvent, BASE_AUTH_EVENT } from '../../../test/iframe_event';
+import { testAuth, testUser } from '../../../test/mock_auth';
+import { makeMockPopupRedirectResolver } from '../../../test/mock_popup_redirect_resolver';
+import { Auth } from '../../model/auth';
+import {
+  AuthEvent,
+  AuthEventType,
+  EventManager,
+  PopupRedirectResolver
+} from '../../model/popup_redirect';
+import { AuthEventManager } from '../auth/auth_event_manager';
+import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
+import { UserCredentialImpl } from '../user/user_credential_impl';
+import { _getInstance } from '../util/instantiator';
+import { AbstractPopupRedirectOperation } from './abstract_popup_redirect_operation';
+import * as idp from './idp';
+
+use(sinonChai);
+use(chaiAsPromised);
+
+const ERROR = AUTH_ERROR_FACTORY.create(AuthErrorCode.INTERNAL_ERROR, {
+  appName: 'test'
+});
+
+/**
+ * A real class is needed to instantiate the action
+ */
+class WrapperOperation extends AbstractPopupRedirectOperation {
+  eventId = '100';
+  onExecution = sinon.stub().returns(Promise.resolve());
+  cleanUp = sinon.stub();
+}
+
+describe('src/core/strategies/abstract_popup_redirect_operation', () => {
+  let auth: Auth;
+  let resolver: PopupRedirectResolver;
+  let eventManager: EventManager;
+  let idpStubs: sinon.SinonStubbedInstance<typeof idp>;
+
+  beforeEach(async () => {
+    auth = await testAuth();
+    eventManager = new AuthEventManager(auth.name);
+    resolver = _getInstance(makeMockPopupRedirectResolver(eventManager));
+    idpStubs = sinon.stub(idp);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  context('#execute', () => {
+    let operation: WrapperOperation;
+
+    beforeEach(() => {
+      operation = new WrapperOperation(
+        auth,
+        AuthEventType.LINK_VIA_POPUP,
+        resolver
+      );
+      idpStubs._signIn.returns(
+        Promise.resolve(
+          new UserCredentialImpl(
+            testUser(auth, 'uid'),
+            null,
+            OperationType.SIGN_IN
+          )
+        )
+      );
+    });
+
+    /** Finishes out the promise */
+    function finishPromise(outcome: AuthEvent | FirebaseError): void {
+      delay((): void => {
+        if (outcome instanceof FirebaseError) {
+          operation.onError(outcome);
+        } else {
+          // eslint-disable-next-line @typescript-eslint/no-floating-promises
+          operation.onAuthEvent(outcome);
+        }
+      });
+    }
+
+    it('initializes the resolver', async () => {
+      sinon.spy(resolver, '_initialize');
+      const promise = operation.execute();
+      finishPromise(authEvent());
+      await promise;
+      expect(resolver._initialize).to.have.been.calledWith(auth);
+    });
+
+    it('calls subclass onExecution', async () => {
+      finishPromise(authEvent());
+      await operation.execute();
+      expect(operation.onExecution).to.have.been.called;
+    });
+
+    it('registers and unregisters itself with the event manager', async () => {
+      sinon.spy(eventManager, 'registerConsumer');
+      sinon.spy(eventManager, 'unregisterConsumer');
+      finishPromise(authEvent());
+      await operation.execute();
+      expect(eventManager.registerConsumer).to.have.been.calledWith(operation);
+      expect(eventManager.unregisterConsumer).to.have.been.calledWith(
+        operation
+      );
+    });
+
+    it('unregisters itself in case of error', async () => {
+      sinon.spy(eventManager, 'unregisterConsumer');
+      finishPromise(ERROR);
+      try {
+        await operation.execute();
+      } catch {}
+      expect(eventManager.unregisterConsumer).to.have.been.calledWith(
+        operation
+      );
+    });
+
+    it('emits the user credential returned from idp task', async () => {
+      finishPromise(authEvent());
+      const cred = await operation.execute();
+      expect(cred.user.uid).to.eq('uid');
+      expect(cred.credential).to.be.null;
+      expect(cred.operationType).to.eq(OperationType.SIGN_IN);
+    });
+
+    it('bubbles up any error', done => {
+      finishPromise(ERROR);
+      operation.execute().catch(e => {
+        expect(e).to.eq(ERROR);
+        done();
+      });
+    });
+
+    it('calls cleanUp on error', async () => {
+      finishPromise(ERROR);
+      try {
+        await operation.execute();
+      } catch {}
+      expect(operation.cleanUp).to.have.been.called;
+    });
+
+    it('calls cleanUp on success', async () => {
+      finishPromise(authEvent());
+      await operation.execute();
+      expect(operation.cleanUp).to.have.been.called;
+    });
+
+    context('idp tasks', () => {
+      function updateFilter(type: AuthEventType): void {
+        ((operation as unknown) as Record<string, unknown>).filter = type;
+      }
+
+      function expectedIdpTaskParams(): idp.IdpTaskParams {
+        return {
+          auth,
+          requestUri: BASE_AUTH_EVENT.urlResponse!,
+          sessionId: BASE_AUTH_EVENT.sessionId!,
+          tenantId: BASE_AUTH_EVENT.tenantId || undefined,
+          postBody: BASE_AUTH_EVENT.postBody || undefined,
+          user: undefined
+        };
+      }
+
+      it('routes SIGN_IN_VIA_POPUP', async () => {
+        const type = AuthEventType.SIGN_IN_VIA_POPUP;
+        updateFilter(type);
+        finishPromise(authEvent({ type }));
+        await operation.execute();
+        expect(idp._signIn).to.have.been.calledWith(expectedIdpTaskParams());
+      });
+
+      it('routes SIGN_IN_VIA_REDIRECT', async () => {
+        const type = AuthEventType.SIGN_IN_VIA_REDIRECT;
+        updateFilter(type);
+        finishPromise(authEvent({ type }));
+        await operation.execute();
+        expect(idp._signIn).to.have.been.calledWith(expectedIdpTaskParams());
+      });
+
+      it('routes LINK_VIA_POPUP', async () => {
+        const type = AuthEventType.LINK_VIA_POPUP;
+        updateFilter(type);
+        finishPromise(authEvent({ type }));
+        await operation.execute();
+        expect(idp._link).to.have.been.calledWith(expectedIdpTaskParams());
+      });
+
+      it('routes LINK_VIA_REDIRECT', async () => {
+        const type = AuthEventType.LINK_VIA_REDIRECT;
+        updateFilter(type);
+        finishPromise(authEvent({ type }));
+        await operation.execute();
+        expect(idp._link).to.have.been.calledWith(expectedIdpTaskParams());
+      });
+
+      it('routes REAUTH_VIA_POPUP', async () => {
+        const type = AuthEventType.REAUTH_VIA_POPUP;
+        updateFilter(type);
+        finishPromise(authEvent({ type }));
+        await operation.execute();
+        expect(idp._reauth).to.have.been.calledWith(expectedIdpTaskParams());
+      });
+
+      it('routes REAUTH_VIA_REDIRECT', async () => {
+        const type = AuthEventType.REAUTH_VIA_REDIRECT;
+        updateFilter(type);
+        finishPromise(authEvent({ type }));
+        await operation.execute();
+        expect(idp._reauth).to.have.been.calledWith(expectedIdpTaskParams());
+      });
+    });
+  });
+});