Formatting

Author: sam-gc

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

@@ -19,15 +19,21 @@ import { expect, use } from 'chai';
 import * as sinon from 'sinon';
 import * as sinonChai from 'sinon-chai';
 
-import { AuthEvent, AuthEventConsumer, AuthEventType } from '../../model/popup_redirect';
+import {
+  AuthEvent,
+  AuthEventConsumer,
+  AuthEventType
+} from '../../model/popup_redirect';
 import { AuthEventManager } from './auth_event_manager';
 
 use(sinonChai);
 
 describe('src/core/auth/auth_event_manager', () => {
   let manager: AuthEventManager;
 
-  function makeConsumer(filter: AuthEventType ): sinon.SinonStubbedInstance<AuthEventConsumer> {
+  function makeConsumer(
+    filter: AuthEventType
+  ): sinon.SinonStubbedInstance<AuthEventConsumer> {
     const stub = sinon.stub({
       filter,
       isMatchingEvent: () => true,
@@ -43,7 +49,7 @@ describe('src/core/auth/auth_event_manager', () => {
   function makeEvent(type: AuthEventType, eventId = 'event'): AuthEvent {
     return {
       type,
-      eventId,
+      eventId
     } as AuthEvent;
   }
 
@@ -101,4 +107,4 @@ describe('src/core/auth/auth_event_manager', () => {
     expect(consumer.onAuthEvent).not.to.have.been.called;
     expect(consumer.isMatchingEvent).to.have.been.called;
   });
-});
+});

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

@@ -15,7 +15,11 @@
  * limitations under the License.
  */
 
-import { AuthEvent, AuthEventConsumer, EventManager } from '../../model/popup_redirect';
+import {
+  AuthEvent,
+  AuthEventConsumer,
+  EventManager
+} from '../../model/popup_redirect';
 
 export class AuthEventManager implements EventManager {
   private readonly consumers: Set<AuthEventConsumer> = new Set();
@@ -30,7 +34,10 @@ export class AuthEventManager implements EventManager {
 
   onEvent(event: AuthEvent): void {
     this.consumers.forEach(consumer => {
-      if (consumer.filter === event.type && consumer.isMatchingEvent(event.eventId)) {
+      if (
+        consumer.filter === event.type &&
+        consumer.isMatchingEvent(event.eventId)
+      ) {
         consumer.onAuthEvent(event);
       }
     });

packages-exp/auth-exp/src/model/popup_redirect.d.ts

@@ -80,4 +80,4 @@ export interface PopupRedirectResolver extends externs.PopupRedirectResolver {
     authType: AuthEventType,
     eventId?: string
   ): Promise<AuthPopup>;
-}
+}

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

@@ -28,7 +28,11 @@ 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 { Auth } from '../model/auth';
-import { AuthEvent, AuthEventType, GapiAuthEvent } from '../model/popup_redirect';
+import {
+  AuthEvent,
+  AuthEventType,
+  GapiAuthEvent
+} from '../model/popup_redirect';
 import * as gapiLoader from './iframe/gapi';
 import { BrowserPopupRedirectResolver } from './popup_redirect';
 
@@ -38,7 +42,7 @@ use(sinonChai);
 describe('src/platform_browser/popup_redirect', () => {
   let resolver: BrowserPopupRedirectResolver;
   let auth: Auth;
-  
+
   beforeEach(async () => {
     auth = await testAuth();
     resolver = new BrowserPopupRedirectResolver();
@@ -49,7 +53,7 @@ describe('src/platform_browser/popup_redirect', () => {
   });
 
   context('#openPopup', () => {
-    let popupUrl: string|undefined;
+    let popupUrl: string | undefined;
     let provider: OAuthProvider;
     const event = AuthEventType.LINK_VIA_POPUP;
 
@@ -64,43 +68,53 @@ describe('src/platform_browser/popup_redirect', () => {
     it('builds the correct url', async () => {
       provider.addScope('some-scope-a');
       provider.addScope('some-scope-b');
-      provider.setCustomParameters({foo: 'bar'});
+      provider.setCustomParameters({ foo: 'bar' });
 
       await resolver.openPopup(auth, provider, event);
-      expect(popupUrl).to.include(`https://${TEST_AUTH_DOMAIN}/__/auth/handler`);
+      expect(popupUrl).to.include(
+        `https://${TEST_AUTH_DOMAIN}/__/auth/handler`
+      );
       expect(popupUrl).to.include(`apiKey=${TEST_KEY}`);
       expect(popupUrl).to.include('appName=test-app');
       expect(popupUrl).to.include(`authType=${AuthEventType.LINK_VIA_POPUP}`);
       expect(popupUrl).to.include(`v=${SDK_VERSION}`);
       expect(popupUrl).to.include('scopes=some-scope-a%2Csome-scope-b');
-      expect(popupUrl).to.include('customParameters=%7B%22foo%22%3A%22bar%22%7D');
+      expect(popupUrl).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.openPopup(auth, provider, event)).to.be.rejectedWith(
-        FirebaseError, 'auth/auth-domain-config-required',
-      );
+      await expect(
+        resolver.openPopup(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.openPopup(auth, provider, event)).to.be.rejectedWith(
-        FirebaseError, 'auth/invalid-api-key',
-      );
+      await expect(
+        resolver.openPopup(auth, provider, event)
+      ).to.be.rejectedWith(FirebaseError, 'auth/invalid-api-key');
     });
   });
 
   context('#initialize', () => {
     let onIframeMessage: (event: GapiAuthEvent) => Promise<void>;
     beforeEach(() => {
-      sinon.stub(gapiLoader, '_loadGapi').returns(Promise.resolve({
-        open: () => Promise.resolve({
-          register: (_message: string, cb: (event: GapiAuthEvent) => Promise<void>) => onIframeMessage = cb
-        })
-      } as unknown as gapi.iframes.Context));
+      sinon.stub(gapiLoader, '_loadGapi').returns(
+        Promise.resolve(({
+          open: () =>
+            Promise.resolve({
+              register: (
+                _message: string,
+                cb: (event: GapiAuthEvent) => Promise<void>
+              ) => (onIframeMessage = cb)
+            })
+        } as unknown) as gapi.iframes.Context)
+      );
     });
 
     it('only registers once, returns same event manager', async () => {
@@ -109,19 +123,19 @@ describe('src/platform_browser/popup_redirect', () => {
     });
 
     it('iframe event goes through to the manager', async () => {
-      const manager = await resolver.initialize(auth) as AuthEventManager;
+      const manager = (await resolver.initialize(auth)) as AuthEventManager;
       sinon.spy(manager, 'onEvent');
       const response = await onIframeMessage({
         type: 'authEvent',
-        authEvent: {type: AuthEventType.LINK_VIA_POPUP} as AuthEvent
+        authEvent: { type: AuthEventType.LINK_VIA_POPUP } as AuthEvent
       });
 
-      expect(manager.onEvent).to.have.been.calledWith(
-        {type: AuthEventType.LINK_VIA_POPUP}
-      );
+      expect(manager.onEvent).to.have.been.calledWith({
+        type: AuthEventType.LINK_VIA_POPUP
+      });
       expect(response).to.eql({
-        status: 'ACK',
+        status: 'ACK'
       });
     });
   });
-});
+});

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

@@ -28,7 +28,11 @@ import { _getCurrentUrl } from '../core/util/location';
 import { _open, AuthPopup } from '../core/util/popup';
 import { ApiKey, AppName, Auth } from '../model/auth';
 import {
-    AuthEventType, EventManager, GapiAuthEvent, GapiOutcome, PopupRedirectResolver
+  AuthEventType,
+  EventManager,
+  GapiAuthEvent,
+  GapiOutcome,
+  PopupRedirectResolver
 } from '../model/popup_redirect';
 import { _openIframe } from './iframe/iframe';
 
@@ -38,7 +42,7 @@ import { _openIframe } from './iframe/iframe';
 const WIDGET_URL = '__/auth/handler';
 
 export class BrowserPopupRedirectResolver implements PopupRedirectResolver {
-  private eventManager: EventManager|null = null;
+  private eventManager: EventManager | null = null;
 
   // Wrapping in async even though we don't await anywhere in order
   // to make sure errors are raised as promise rejections
@@ -59,7 +63,8 @@ export class BrowserPopupRedirectResolver implements PopupRedirectResolver {
 
     const iframe = await _openIframe(auth);
     const eventManager = new AuthEventManager();
-    iframe.register<GapiAuthEvent>('authEvent',
+    iframe.register<GapiAuthEvent>(
+      'authEvent',
       async (message: GapiAuthEvent) => {
         await eventManager.onEvent(message.authEvent);
 
@@ -129,8 +134,10 @@ function getRedirectUrl(
   // TODO: maybe set fw as Frameworks.join(",")
 
   const url = new URL(
-    `https://${auth.config.authDomain}/${WIDGET_URL}?${querystring(params as Record<string, string|number>).slice(1)}`
+    `https://${auth.config.authDomain}/${WIDGET_URL}?${querystring(
+      params as Record<string, string | number>
+    ).slice(1)}`
   );
 
   return url.toString();
-}
+}