Finish emulator implementation

Author: sam-gc

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

@@ -25,12 +25,9 @@ import { mockEndpoint } from '../../test/helpers/api/helper';
 import { testAuth, TestAuth } from '../../test/helpers/mock_auth';
 import * as mockFetch from '../../test/helpers/mock_fetch';
 import { AuthErrorCode } from '../core/errors';
+import { ConfigInternal } from '../model/auth';
 import {
-  _performApiRequest,
-  DEFAULT_API_TIMEOUT_MS,
-  Endpoint,
-  HttpHeader,
-  HttpMethod
+    _getFinalTarget, _performApiRequest, DEFAULT_API_TIMEOUT_MS, Endpoint, HttpHeader, HttpMethod
 } from './';
 import { ServerError } from './errors';
 
@@ -327,4 +324,18 @@ describe('api/_performApiRequest', () => {
       }
     });
   });
+
+  context('_getFinalTarget', () => {
+    it('works properly with a non-emulated environment', () => {
+      expect(_getFinalTarget(auth, 'host', '/path', 'query=test')).to.eq('mock://host/path?query=test');
+    });
+
+    it('works properly with an emulated environment', () => {
+      (auth.config as ConfigInternal).emulator = {
+        hostname: 'localhost',
+        port: 5000,
+      };
+      expect(_getFinalTarget(auth, 'host', '/path', 'query=test')).to.eq('http://localhost:5000/host/path?query=test');
+    });
+  });
 });

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

@@ -17,13 +17,10 @@
 
 import { FirebaseError, querystring } from '@firebase/util';
 
-import {
-  AUTH_ERROR_FACTORY,
-  AuthErrorCode,
-  NamedErrorParams
-} from '../core/errors';
+import { AUTH_ERROR_FACTORY, AuthErrorCode, NamedErrorParams } from '../core/errors';
 import { fail } from '../core/util/assert';
 import { Delay } from '../core/util/delay';
+import { _emulatorUrl } from '../core/util/emulator';
 import { FetchProvider } from '../core/util/fetch_provider';
 import { Auth, AuthCore } from '../model/auth';
 import { IdTokenResponse, TaggedWithTokenResponse } from '../model/id_token';
@@ -191,14 +188,13 @@ export function _getFinalTarget(
   path: string,
   query: string
 ): string {
-  const { emulator } = auth.config;
   const base = `${host}${path}?${query}`;
 
-  if (!emulator) {
+  if (!auth.config.emulator) {
     return `${auth.config.apiScheme}://${base}`;
   }
 
-  return `http://${emulator.hostname}:${emulator.port}/${base}`;
+  return _emulatorUrl(auth.config, base);
 }
 
 function makeNetworkTimeout<T>(appName: string): Promise<T> {

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

@@ -23,19 +23,18 @@ import * as sinonChai from 'sinon-chai';
 import { FirebaseApp } from '@firebase/app-types-exp';
 import { FirebaseError } from '@firebase/util';
 
-import { testUser } from '../../../test/helpers/mock_auth';
+import { endpointUrl, mockEndpoint } from '../../../test/helpers/api/helper';
+import { testAuth, TestAuth, testUser } from '../../../test/helpers/mock_auth';
+import * as fetch from '../../../test/helpers/mock_fetch';
+import { Endpoint } from '../../api';
 import { Auth } from '../../model/auth';
 import { User } from '../../model/user';
 import { Persistence } from '../persistence';
 import { inMemoryPersistence } from '../persistence/in_memory';
 import { _getInstance } from '../util/instantiator';
 import * as navigator from '../util/navigator';
 import {
-  _castAuth,
-  AuthImpl,
-  DEFAULT_API_HOST,
-  DEFAULT_API_SCHEME,
-  DEFAULT_TOKEN_API_HOST
+    _castAuth, AuthImpl, DEFAULT_API_HOST, DEFAULT_API_SCHEME, DEFAULT_TOKEN_API_HOST
 } from './auth_impl';
 import { _initializeAuthInstance } from './initialize';
 
@@ -388,3 +387,47 @@ describe('core/auth/auth_impl', () => {
     });
   });
 });
+
+// These tests are separate because they are using a different auth with
+// separate setup and config
+describe('core/auth/auth_impl useEmulator', () => {
+  let auth: TestAuth;
+  let user: User;
+  let normalEndpoint: fetch.Route;
+  let emulatorEndpoint: fetch.Route;
+
+  beforeEach(async () => {
+    auth = await testAuth();
+    user = testUser(_castAuth(auth), 'uid', 'email', true);
+    fetch.setUp();
+    normalEndpoint = mockEndpoint(Endpoint.DELETE_ACCOUNT, {});
+    emulatorEndpoint = fetch.mock(
+      `http://localhost:2020/${endpointUrl(Endpoint.DELETE_ACCOUNT).replace(
+        /^.*:\/\//,
+        ''
+      )}`,
+      {}
+    );
+  });
+
+  afterEach(() => {
+    fetch.tearDown();
+  });
+
+  context('useEmulator', () => {
+    it('fails if a network request has already been made', async () => {
+      await user.delete();
+      expect(() => auth.useEmulator('localhost', 2020)).to.throw(
+        FirebaseError,
+        'auth/emulator-config-failed'
+      );
+    });
+
+    it('updates the endpoint appropriately', async () => {
+      auth.useEmulator('localhost', 2020);
+      await user.delete();
+      expect(normalEndpoint.calls.length).to.eq(0);
+      expect(emulatorEndpoint.calls.length).to.eq(1);
+    });
+  });
+});

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

@@ -18,23 +18,16 @@
 import { _FirebaseService, FirebaseApp } from '@firebase/app-types-exp';
 import * as externs from '@firebase/auth-types-exp';
 import {
-  CompleteFn,
-  createSubscribe,
-  ErrorFn,
-  NextFn,
-  Observer,
-  Subscribe,
-  Unsubscribe
+    CompleteFn, createSubscribe, ErrorFn, NextFn, Observer, Subscribe, Unsubscribe
 } from '@firebase/util';
 
-import { Auth, AuthCore } from '../../model/auth';
+import { Auth, AuthCore, ConfigInternal } from '../../model/auth';
 import { PopupRedirectResolver } from '../../model/popup_redirect';
 import { User, UserParameters } from '../../model/user';
 import { AuthErrorCode } from '../errors';
 import { Persistence } from '../persistence';
 import {
-  _REDIRECT_USER_KEY_NAME,
-  PersistenceUserManager
+    _REDIRECT_USER_KEY_NAME, PersistenceUserManager
 } from '../persistence/persistence_user_manager';
 import { _reloadWithoutSaving } from '../user/reload';
 import { UserImpl } from '../user/user_impl';
@@ -82,7 +75,7 @@ export class AuthImplCompat<T extends User> implements Auth, _FirebaseService {
 
   constructor(
     public readonly app: FirebaseApp,
-    public readonly config: externs.Config,
+    public readonly config: ConfigInternal,
     private readonly _userProvider: UserProvider<T>
   ) {
     this.name = app.name;
@@ -189,6 +182,20 @@ export class AuthImplCompat<T extends User> implements Auth, _FirebaseService {
     this.languageCode = _getUserLanguage();
   }
 
+  useEmulator(
+    hostname: string,
+    port: number
+  ): void {
+    assert(this._canInitEmulator, AuthErrorCode.EMULATOR_CONFIG_FAILED, {
+      appName: this.name
+    });
+  
+    this.config.emulator = {
+      hostname,
+      port
+    };
+  }
+
   async _delete(): Promise<void> {
     // TODO: Determine what we want to do in this case
   }

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

@@ -20,9 +20,7 @@ import { FirebaseApp } from '@firebase/app-types-exp';
 import * as externs from '@firebase/auth-types-exp';
 
 import { Dependencies } from '../../model/auth';
-import { AuthErrorCode } from '../errors';
 import { Persistence } from '../persistence';
-import { assert } from '../util/assert';
 import { _getInstance } from '../util/instantiator';
 import { _castAuth, AuthImpl } from './auth_impl';
 
@@ -36,22 +34,6 @@ export function initializeAuth(
   return auth;
 }
 
-export function useEmulator(
-  authExtern: externs.Auth,
-  hostname: string,
-  port: number
-): void {
-  const auth = _castAuth(authExtern);
-  assert(auth._canInitEmulator, AuthErrorCode.EMULATOR_CONFIG_FAILED, {
-    appName: auth.name
-  });
-
-  auth.config.emulator = {
-    hostname,
-    port
-  };
-}
-
 export function _initializeAuthInstance(
   auth: AuthImpl,
   deps?: Dependencies

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

@@ -0,0 +1,25 @@
+import { expect } from 'chai';
+
+import { ConfigInternal } from '../../model/auth';
+import { _emulatorUrl } from './emulator';
+
+describe('core/util/emulator', () => {
+  const config: ConfigInternal = {
+    emulator: {
+      hostname: 'localhost',
+      port: 4000
+    }
+  } as ConfigInternal;
+
+  it('builds the proper URL with no path', () => {
+    expect(_emulatorUrl(config)).to.eq('http://localhost:4000');
+  });
+
+  it('builds the proper URL with a path', () => {
+    expect(_emulatorUrl(config, '/test/path')).to.eq('http://localhost:4000/test/path');
+  });
+
+  it('builds the proper URL with a path missing separator', () => {
+    expect(_emulatorUrl(config, 'test/path')).to.eq('http://localhost:4000/test/path');
+  });
+});

packages-exp/auth-exp/src/core/util/emulator.test.ts

@@ -0,0 +1,15 @@
+import { ConfigInternal } from '../../model/auth';
+import { debugAssert } from './assert';
+
+export function _emulatorUrl(config: ConfigInternal, path?: string): string {
+  debugAssert(config.emulator, 'Emulator should always be set here');
+  const {hostname, port} = config.emulator;
+
+  const base = `http://${hostname}:${port}`;
+  if (!path) {
+    return base;
+  }
+
+  const sep = path.startsWith('/') ? '' : '/';
+  return `${base}${sep}${path}`;
+}

packages-exp/auth-exp/src/core/util/emulator.ts

@@ -25,6 +25,11 @@ const IP_ADDRESS_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
 const HTTP_REGEX = /^https?/;
 
 export async function _validateOrigin(auth: Auth): Promise<void> {
+  // Skip origin validation if we are in an emulated environment
+  if (auth.config.emulator) {
+    return;
+  }
+  
   const { authorizedDomains } = await _getProjectConfig(auth);
 
   for (const domain of authorizedDomains) {

packages-exp/auth-exp/src/core/util/validate_origin.ts

@@ -25,7 +25,7 @@ export type AppName = string;
 export type ApiKey = string;
 export type AuthDomain = string;
 
-interface ConfigInternal extends externs.Config {
+export interface ConfigInternal extends externs.Config {
   emulator?: {
     hostname: string;
     port: number;

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

@@ -21,11 +21,15 @@ import { querystring } from '@firebase/util';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../../core/errors';
 import { assert } from '../../core/util/assert';
 import { Delay } from '../../core/util/delay';
+import { _emulatorUrl } from '../../core/util/emulator';
 import { AuthCore } from '../../model/auth';
 import { _window } from '../auth_window';
 import * as gapiLoader from './gapi';
 
 const PING_TIMEOUT = new Delay(5000, 15000);
+const IFRAME_PATH = '__/auth/iframe';
+const EMULATED_IFRAME_PATH = 'emulator/auth/iframe';
+
 const IFRAME_ATTRIBUTES = {
   style: {
     position: 'absolute',
@@ -36,10 +40,12 @@ const IFRAME_ATTRIBUTES = {
 };
 
 function getIframeUrl(auth: AuthCore): string {
-  const url = `https://${auth.config.authDomain!}/__/auth/iframe`;
+  const config = auth.config;
+  const url = config.emulator ? _emulatorUrl(config, EMULATED_IFRAME_PATH) :
+  `https://${auth.config.authDomain!}/${IFRAME_PATH}`;
 
   const params = {
-    apiKey: auth.config.apiKey,
+    apiKey: config.apiKey,
     appName: auth.name,
     v: SDK_VERSION
   };