Tests

Author: sam-gc

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

@@ -50,26 +50,17 @@ import {
   signInWithCustomToken,
   signInWithEmailAndPassword,
   unlink,
-<<<<<<< HEAD
   updateEmail,
   updatePassword,
   updateProfile,
-  verifyPasswordResetCode
-} from '@firebase/auth-exp';
-=======
-  getMultiFactorResolver,
-  multiFactor,
-  PhoneMultiFactorGenerator,
+  verifyPasswordResetCode,
   OAuthProvider,
   signInWithPopup,
   linkWithPopup,
   reauthenticateWithPopup,
-  BrowserPopupRedirectResolver
+  browserPopupRedirectResolver
 } from '@firebase/auth-exp';
 
-const browserPopupRedirectResolver = new BrowserPopupRedirectResolver();
-
->>>>>>> ad6dfaac7... Popup strategy implementation
 import { config } from './config';
 import {
   alertError,

packages-exp/auth-exp/src/core/auth/auth_event_manager.test.ts

@@ -20,10 +20,7 @@ import * as sinon from 'sinon';
 import * as sinonChai from 'sinon-chai';
 
 import {
-  AuthEvent,
-  AuthEventConsumer,
-  AuthEventError,
-  AuthEventType
+    AuthEvent, AuthEventConsumer, AuthEventError, AuthEventType
 } from '../../model/popup_redirect';
 import { AuthErrorCode } from '../errors';
 import { AuthEventManager } from './auth_event_manager';
@@ -34,18 +31,15 @@ describe('src/core/auth/auth_event_manager', () => {
   let manager: AuthEventManager;
 
   function makeConsumer(
-    filter: AuthEventType
+    filter: AuthEventType|AuthEventType[]
   ): sinon.SinonStubbedInstance<AuthEventConsumer> {
     const stub = sinon.stub({
-      filter,
-      isMatchingEvent: () => true,
+      filter: Array.isArray(filter) ? filter : [filter],
       onAuthEvent: () => {},
-      onError: () => {}
+      onError: () => {},
+      eventId: null,
     });
 
-    // Make isMatchingEvent call through by default
-    stub.isMatchingEvent.returns(true);
-
     return stub;
   }
 
@@ -94,21 +88,22 @@ describe('src/core/auth/auth_event_manager', () => {
     expect(consumer.onAuthEvent).not.to.have.been.called;
   });
 
-  it('calls isMatchingEvent with the event id', () => {
+  it('does not call through if eventId does not match', () => {
     const consumer = makeConsumer(AuthEventType.REAUTH_VIA_POPUP);
+    consumer.eventId = 'not-event-id';
     manager.registerConsumer(consumer);
+
     manager.onEvent(makeEvent(AuthEventType.REAUTH_VIA_POPUP, 'event-id'));
-    expect(consumer.isMatchingEvent).to.have.been.calledWith('event-id');
+    expect(consumer.onAuthEvent).not.to.have.been.called;
   });
 
-  it('does not call through if isMatchingEvent is false', () => {
+  it('does call through if eventId is null', () => {
     const consumer = makeConsumer(AuthEventType.REAUTH_VIA_POPUP);
+    consumer.eventId = null;
     manager.registerConsumer(consumer);
-    consumer.isMatchingEvent.returns(false);
 
-    manager.onEvent(makeEvent(AuthEventType.REAUTH_VIA_POPUP));
-    expect(consumer.onAuthEvent).not.to.have.been.called;
-    expect(consumer.isMatchingEvent).to.have.been.called;
+    manager.onEvent(makeEvent(AuthEventType.REAUTH_VIA_POPUP, 'event-id'));
+    expect(consumer.onAuthEvent).to.have.been.called;
   });
 
   it('converts errors into FirebaseError if the type matches', () => {
@@ -139,4 +134,54 @@ describe('src/core/auth/auth_event_manager', () => {
     const error = consumer.onError.getCall(0).args[0];
     expect(error.code).to.eq(`auth/${AuthErrorCode.INTERNAL_ERROR}`);
   });
+
+  context('redirect consumers', () => {
+    let consumer: AuthEventConsumer;
+
+    beforeEach(() => {
+      consumer = makeConsumer([AuthEventType.SIGN_IN_VIA_REDIRECT, AuthEventType.LINK_VIA_REDIRECT, AuthEventType.REAUTH_VIA_REDIRECT]);
+    });
+
+    it('redirect events are queued until the future', () => {
+      const event = makeEvent(AuthEventType.REAUTH_VIA_REDIRECT);
+      expect(manager.onEvent(event)).to.be.true;
+
+      manager.registerConsumer(consumer);
+      expect(consumer.onAuthEvent).to.have.been.calledWith(event);
+    });
+
+    it('queued redirects only work for the first new consumer', () => {
+      const event = makeEvent(AuthEventType.REAUTH_VIA_REDIRECT);
+      expect(manager.onEvent(event)).to.be.true;
+
+      manager.registerConsumer(consumer);
+      expect(consumer.onAuthEvent).to.have.been.calledWith(event);
+
+      const consumerB = makeConsumer(AuthEventType.REAUTH_VIA_REDIRECT);
+      manager.registerConsumer(consumerB);
+      expect(consumerB.onAuthEvent).not.to.have.been.called;
+    });
+
+    it('does not queue a redirect event if it was handled immediately', () => {
+      const event = makeEvent(AuthEventType.REAUTH_VIA_REDIRECT);
+      manager.registerConsumer(consumer);
+
+      expect(manager.onEvent(event)).to.be.true;
+      expect(consumer.onAuthEvent).to.have.been.calledWith(event);
+
+      const consumerB = makeConsumer(AuthEventType.REAUTH_VIA_REDIRECT);
+      manager.registerConsumer(consumerB);
+      expect(consumerB.onAuthEvent).not.to.have.been.called;
+    });
+
+    it('unknown auth error prevents consumption of future redirect events', () => {
+      const event = makeEvent(AuthEventType.UNKNOWN);
+      event.error = {code: 'auth/no-auth-event'} as AuthEventError;
+      expect(manager.onEvent(event)).to.be.true;
+      expect(manager.onEvent(makeEvent(AuthEventType.SIGN_IN_VIA_REDIRECT))).to.be.false;
+
+      manager.registerConsumer(consumer);
+      expect(consumer.onAuthEvent).not.to.have.been.called;
+    });
+  });
 });

packages-exp/auth-exp/src/core/auth/auth_event_manager.ts

@@ -41,6 +41,13 @@ export class AuthEventManager implements EventManager {
   }
 
   onEvent(event: AuthEvent): boolean {
+    if (isNullRedirectEvent(event)) {
+      // A null redirect event comes through as the first event when no pending
+      // redirect actions are in the auth domain
+      this.hasHandledPotentialRedirect = true;
+      return true;
+    }
+
     let handled = false;
     this.consumers.forEach(consumer => {
       if (this.isEventForConsumer(event, consumer)) {
@@ -49,24 +56,20 @@ export class AuthEventManager implements EventManager {
       }
     });
 
-    // The redirect event is always available immediately, unlike popup
-    // events (which happen in the normal app lifetime). Since the user
-    // may open the iframe (through a popup method) before getRedirectResult()
-    // is called, we need to queue up the redirect event so the user has access
-    // to it later. On the other hand, if we get a "unknown" auth event with
-    // the message "no-auth-event", we know there will never be a redirect event
-    // for this session.
-    if (event.type === AuthEventType.UNKNOWN && event.error?.code === `auth/${AuthErrorCode.NO_AUTH_EVENT}`) {
-      this.hasHandledPotentialRedirect = true;
-      return true;
+    if (this.hasHandledPotentialRedirect || !isRedirectEvent(event.type)) {
+      // If we've already seen a redirect before, or this is a popup event,
+      // bail now
+      return handled;
+    }
+
+    this.hasHandledPotentialRedirect = true;
 
-    } else if (!handled && isRedirectEvent(event.type) && !this.hasHandledPotentialRedirect) {
+    // If the redirect wasn't handled, hang on to it
+    if (!handled) {
       this.queuedRedirectEvent = event;
       handled = true;
     }
 
-    this.hasHandledPotentialRedirect = this.hasHandledPotentialRedirect || isRedirectEvent(event.type);
-
     return handled;
   }
 
@@ -92,6 +95,10 @@ export class AuthEventManager implements EventManager {
   }
 }
 
+function isNullRedirectEvent({type, error}: AuthEvent): boolean {
+  return type === AuthEventType.UNKNOWN && error?.code === `auth/${AuthErrorCode.NO_AUTH_EVENT}`;
+}
+
 function isRedirectEvent(type: AuthEventType): boolean {
   switch (type) {
     case AuthEventType.SIGN_IN_VIA_REDIRECT:

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

@@ -95,10 +95,6 @@ export abstract class AbstractPopupRedirectOperation
     this.reject(error);
   }
 
-  isMatchingEvent(eventId: string | null): boolean {
-    return !!eventId && this.eventId === eventId;
-  }
-
   private getIdpTask(type: AuthEventType): IdpTask {
     switch (type) {
       case AuthEventType.SIGN_IN_VIA_POPUP:

packages-exp/auth-exp/src/index.ts

@@ -128,5 +128,4 @@ export { PhoneMultiFactorGenerator } from './mfa/assertions/phone';
 export { getMultiFactorResolver } from './mfa/mfa_resolver';
 export { multiFactor } from './mfa/mfa_user';
 
-// TODO(samhorlbeck): This should be exported as a single const
-export { BrowserPopupRedirectResolver } from './platform_browser/popup_redirect';
+export { browserPopupRedirectResolver } from './platform_browser/popup_redirect';

packages-exp/auth-exp/src/platform_browser/auth_window.ts

@@ -38,3 +38,7 @@ export type AuthWindow = {
 };
 
 export const AUTH_WINDOW = (window as unknown) as AuthWindow;
+
+export function _setWindowLocation(url: string): void {
+  AUTH_WINDOW.location.href = url;
+}

packages-exp/auth-exp/src/platform_browser/popup_redirect.test.ts

@@ -27,26 +27,26 @@ import { FirebaseError } from '@firebase/util';
 import { TEST_AUTH_DOMAIN, TEST_KEY, testAuth } from '../../test/mock_auth';
 import { AuthEventManager } from '../core/auth/auth_event_manager';
 import { OAuthProvider } from '../core/providers/oauth';
+import { SingletonInstantiator } from '../core/util/instantiator';
 import { Auth } from '../model/auth';
 import {
-  AuthEvent,
-  AuthEventType,
-  GapiAuthEvent
+    AuthEvent, AuthEventType, GapiAuthEvent, PopupRedirectResolver
 } from '../model/popup_redirect';
+import * as authWindow from './auth_window';
 import * as gapiLoader from './iframe/gapi';
-import { BrowserPopupRedirectResolver } from './popup_redirect';
+import { browserPopupRedirectResolver } from './popup_redirect';
 
 use(chaiAsPromised);
 use(sinonChai);
 
 describe('src/platform_browser/popup_redirect', () => {
-  let resolver: BrowserPopupRedirectResolver;
+  let resolver: PopupRedirectResolver;
   let auth: Auth;
   let onIframeMessage: (event: GapiAuthEvent) => Promise<void>;
 
   beforeEach(async () => {
     auth = await testAuth();
-    resolver = new BrowserPopupRedirectResolver();
+    resolver = new (browserPopupRedirectResolver as SingletonInstantiator<PopupRedirectResolver>)();
 
     sinon.stub(gapiLoader, '_loadGapi').returns(
       Promise.resolve(({
@@ -65,7 +65,7 @@ describe('src/platform_browser/popup_redirect', () => {
     sinon.restore();
   });
 
-  context('#openPopup', () => {
+  context('#_openPopup', () => {
     let popupUrl: string | undefined;
     let provider: OAuthProvider;
     const event = AuthEventType.LINK_VIA_POPUP;
@@ -115,15 +115,66 @@ describe('src/platform_browser/popup_redirect', () => {
     });
   });
 
-  context('#initialize', () => {
+  context('#_openRedirect', () => {
+    let newWindowLocation: string;
+    let provider: OAuthProvider;
+    const event = AuthEventType.LINK_VIA_POPUP;
+
+    beforeEach(async () => {
+      provider = new OAuthProvider(ProviderId.GOOGLE);
+      await resolver._initialize(auth);
+      sinon.stub(authWindow, '_setWindowLocation').callsFake(url => {
+        newWindowLocation = url;
+      });
+    });
+
+    it('builds the correct url', () => {
+      provider.addScope('some-scope-a');
+      provider.addScope('some-scope-b');
+      provider.setCustomParameters({ foo: 'bar' });
+
+      // This promise will never resolve on purpose
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      resolver._openRedirect(auth, provider, event);
+      expect(newWindowLocation).to.include(
+        `https://${TEST_AUTH_DOMAIN}/__/auth/handler`
+      );
+      expect(newWindowLocation).to.include(`apiKey=${TEST_KEY}`);
+      expect(newWindowLocation).to.include('appName=test-app');
+      expect(newWindowLocation).to.include(`authType=${AuthEventType.LINK_VIA_POPUP}`);
+      expect(newWindowLocation).to.include(`v=${SDK_VERSION}`);
+      expect(newWindowLocation).to.include('scopes=some-scope-a%2Csome-scope-b');
+      expect(newWindowLocation).to.include(
+        'customParameters=%7B%22foo%22%3A%22bar%22%7D'
+      );
+    });
+
+    it('throws an error if authDomain is unspecified', async () => {
+      delete auth.config.authDomain;
+
+      await expect(
+        resolver._openRedirect(auth, provider, event)
+      ).to.be.rejectedWith(FirebaseError, 'auth/auth-domain-config-required');
+    });
+
+    it('throws an error if apiKey is unspecified', async () => {
+      delete auth.config.apiKey;
+
+      await expect(
+        resolver._openRedirect(auth, provider, event)
+      ).to.be.rejectedWith(FirebaseError, 'auth/invalid-api-key');
+    });
+  });
+
+  context('#_initialize', () => {
     it('only registers once, returns same event manager', async () => {
       const manager = await resolver._initialize(auth);
       expect(await resolver._initialize(auth)).to.eq(manager);
     });
 
     it('iframe event goes through to the manager', async () => {
       const manager = (await resolver._initialize(auth)) as AuthEventManager;
-      sinon.spy(manager, 'onEvent');
+      sinon.stub(manager, 'onEvent').returns(true);
       const response = await onIframeMessage({
         type: 'authEvent',
         authEvent: { type: AuthEventType.LINK_VIA_POPUP } as AuthEvent
@@ -136,5 +187,21 @@ describe('src/platform_browser/popup_redirect', () => {
         status: 'ACK'
       });
     });
+
+    it('returns error to the iframe if the event was not handled', async () => {
+      const manager = (await resolver._initialize(auth)) as AuthEventManager;
+      sinon.stub(manager, 'onEvent').returns(false);
+      const response = await onIframeMessage({
+        type: 'authEvent',
+        authEvent: { type: AuthEventType.LINK_VIA_POPUP } as AuthEvent
+      });
+
+      expect(manager.onEvent).to.have.been.calledWith({
+        type: AuthEventType.LINK_VIA_POPUP
+      });
+      expect(response).to.eql({
+        status: 'ERROR'
+      });
+    });
   });
 });