Add hooks into emulator for auth-next

Author: sam-gc

packages-exp/auth-exp/src/api/authentication/token.ts

@@ -19,9 +19,9 @@
 
 import { querystring } from '@firebase/util';
 
-import { _performFetchWithErrorHandling, HttpMethod } from '../';
-import { AuthCore } from '../../model/auth';
+import { _getFinalTarget, _performFetchWithErrorHandling, HttpMethod } from '../';
 import { FetchProvider } from '../../core/util/fetch_provider';
+import { AuthCore } from '../../model/auth';
 
 export const _ENDPOINT = 'v1/token';
 const GRANT_TYPE = 'refresh_token';
@@ -51,7 +51,7 @@ export async function requestStsToken(
       'refresh_token': refreshToken
     }).slice(1);
     const { apiScheme, tokenApiHost, apiKey, sdkClientVersion } = auth.config;
-    const url = `${apiScheme}://${tokenApiHost}/${_ENDPOINT}`;
+    const url = _getFinalTarget(auth, `${apiScheme}://${tokenApiHost}/${_ENDPOINT}`);
 
     return FetchProvider.fetch()(`${url}?key=${apiKey}`, {
       method: HttpMethod.POST,

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

@@ -17,6 +17,7 @@
 
 import { FirebaseError, querystring } from '@firebase/util';
 
+<<<<<<< HEAD
 import {
   AUTH_ERROR_FACTORY,
   AuthErrorCode,
@@ -26,6 +27,13 @@ import { fail } from '../core/util/assert';
 import { Delay } from '../core/util/delay';
 import { FetchProvider } from '../core/util/fetch_provider';
 import { AuthCore } from '../model/auth';
+=======
+import { AUTH_ERROR_FACTORY, AuthErrorCode, NamedErrorParams } from '../core/errors';
+import { fail } from '../core/util/assert';
+import { Delay } from '../core/util/delay';
+import { FetchProvider } from '../core/util/fetch_provider';
+import { Auth, AuthCore } from '../model/auth';
+>>>>>>> be103af54 (Add hooks into emulator for auth-next)
 import { IdTokenResponse, TaggedWithTokenResponse } from '../model/id_token';
 import { IdTokenMfaResponse } from './authentication/mfa';
 import { SERVER_ERROR_MAP, ServerError, ServerErrorMap } from './errors';
@@ -99,7 +107,7 @@ export async function _performApiRequest<T, V>(
     }
 
     return FetchProvider.fetch()(
-      `${auth.config.apiScheme}://${auth.config.apiHost}${path}?${query}`,
+      _getFinalTarget(auth, `${auth.config.apiScheme}://${auth.config.apiHost}${path}?${query}`),
       {
         method,
         headers,
@@ -115,6 +123,7 @@ export async function _performFetchWithErrorHandling<V>(
   customErrorMap: Partial<ServerErrorMap<ServerError>>,
   fetchFn: () => Promise<Response>
 ): Promise<V> {
+  (auth as Auth)._canInitEmulator = false;
   const errorMap = { ...SERVER_ERROR_MAP, ...customErrorMap };
   try {
     const response: Response = await Promise.race<Promise<Response>>([
@@ -183,6 +192,16 @@ export async function _performSignInRequest<T, V extends IdTokenResponse>(
   return serverResponse;
 }
 
+export function _getFinalTarget(auth: AuthCore, url: string): string {
+  const {emulator} = auth.config;
+  if (!emulator) {
+    return url;
+  }
+
+  const urlWithoutScheme = url.replace(/^.*:\/\//, '');
+  return `http://${emulator.hostname}:${emulator.port}/${urlWithoutScheme}`;
+}
+
 function makeNetworkTimeout<T>(appName: string): Promise<T> {
   return new Promise((_, reject) =>
     setTimeout(() => {

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

@@ -18,13 +18,7 @@
 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';
@@ -33,8 +27,7 @@ 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';
@@ -63,6 +56,10 @@ export class AuthImplCompat<T extends User> implements Auth, _FirebaseService {
   private idTokenSubscription = new Subscription<T>(this);
   private redirectUser: T | null = null;
   private isProactiveRefreshEnabled = false;
+  
+  // Any network calls will set this to true and prevent subsequent emulator
+  // initialization
+  _canInitEmulator = true;
   _isInitialized = false;
   _initializationPromise: Promise<void> | null = null;
   _popupRedirectResolver: PopupRedirectResolver | null = null;

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

@@ -0,0 +1,61 @@
+/**
+ * @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 } from 'chai';
+
+import { Auth, User } from '@firebase/auth-types-exp';
+import { FirebaseError } from '@firebase/util';
+
+import { endpointUrl, mockEndpoint } from '../../../test/helpers/api/helper';
+import { testAuth, testUser } from '../../../test/helpers/mock_auth';
+import * as fetch from '../../../test/helpers/mock_fetch';
+import { _getFinalTarget, Endpoint } from '../../api';
+import { _castAuth } from './auth_impl';
+import { useEmulator } from './initialize';
+
+describe('core/auth/initialize', () => {
+  let auth: Auth;
+  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(() => useEmulator(auth, 'localhost', 2020)).to.throw(FirebaseError, 'auth/emulator-config-failed');
+    });
+
+    it('updates the endpoint appropriately', async () => {
+      useEmulator(auth, '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/initialize.ts

@@ -20,9 +20,11 @@ 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 { fail } from '../util/assert';
 import { _getInstance } from '../util/instantiator';
-import { AuthImpl } from './auth_impl';
+import { _castAuth, AuthImpl } from './auth_impl';
 
 export function initializeAuth(
   app: FirebaseApp = getApp(),
@@ -34,6 +36,24 @@ export function initializeAuth(
   return auth;
 }
 
+export function useEmulator(
+  authExtern: externs.Auth,
+  hostname: string,
+  port: number,
+): void {
+  const auth = _castAuth(authExtern);
+  if (!auth._canInitEmulator) {
+    fail(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/errors.ts

@@ -19,8 +19,8 @@
 import * as externs from '@firebase/auth-types-exp';
 import { ErrorFactory, ErrorMap } from '@firebase/util';
 
-import { AppName } from '../model/auth';
 import { IdTokenMfaResponse } from '../api/authentication/mfa';
+import { AppName } from '../model/auth';
 
 /*
  * Developer facing Firebase Auth error codes.
@@ -40,6 +40,7 @@ export const enum AuthErrorCode {
   DYNAMIC_LINK_NOT_ACTIVATED = 'dynamic-link-not-activated',
   EMAIL_CHANGE_NEEDS_VERIFICATION = 'email-change-needs-verification',
   EMAIL_EXISTS = 'email-already-in-use',
+  EMULATOR_CONFIG_FAILED = 'emulator-config-failed',
   EXPIRED_OOB_CODE = 'expired-action-code',
   EXPIRED_POPUP_REQUEST = 'cancelled-popup-request',
   INTERNAL_ERROR = 'internal-error',
@@ -116,7 +117,7 @@ export const enum AuthErrorCode {
   USER_MISMATCH = 'user-mismatch',
   USER_SIGNED_OUT = 'user-signed-out',
   WEAK_PASSWORD = 'weak-password',
-  WEB_STORAGE_UNSUPPORTED = 'web-storage-unsupported'
+  WEB_STORAGE_UNSUPPORTED = 'web-storage-unsupported',
 }
 
 const ERRORS: ErrorMap<AuthErrorCode> = {
@@ -154,6 +155,10 @@ const ERRORS: ErrorMap<AuthErrorCode> = {
     'Multi-factor users must always have a verified email.',
   [AuthErrorCode.EMAIL_EXISTS]:
     'The email address is already in use by another account.',
+  [AuthErrorCode.EMULATOR_CONFIG_FAILED]:
+    'Auth instance has already been used to make a network call. Auth can ' +
+    'no longer be configured to use the emulator. Try calling ' +
+    '"useEmulator()" sooner.',
   [AuthErrorCode.EXPIRED_OOB_CODE]: 'The action code has expired.',
   [AuthErrorCode.EXPIRED_POPUP_REQUEST]:
     'This operation has been cancelled due to another conflicting popup being opened.',

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

@@ -25,13 +25,20 @@ export type AppName = string;
 export type ApiKey = string;
 export type AuthDomain = string;
 
+interface ConfigInternal extends externs.Config {
+  emulator?: {
+    hostname: string;
+    port: number;
+  }
+}
+
 /**
  * Core implementation of the Auth object, the signatures here should match across both legacy
  * and modern implementations
  */
 export interface AuthCore {
   readonly name: AppName;
-  readonly config: externs.Config;
+  readonly config: ConfigInternal;
   languageCode: string | null;
   tenantId: string | null;
   readonly settings: externs.AuthSettings;
@@ -42,6 +49,7 @@ export interface AuthCore {
 
 export interface Auth extends AuthCore {
   currentUser: User | null;
+  _canInitEmulator: boolean;
   _isInitialized: boolean;
   _initializationPromise: Promise<void> | null;
   updateCurrentUser(user: User | null): Promise<void>;

packages-exp/auth-exp/test/helpers/api/helper.ts

@@ -19,13 +19,17 @@ import { Endpoint } from '../../../src/api';
 import { TEST_HOST, TEST_KEY, TEST_SCHEME } from '../mock_auth';
 import { mock, Route } from '../mock_fetch';
 
+export function endpointUrl(endpoint: Endpoint):string {
+  return `${TEST_SCHEME}://${TEST_HOST}${endpoint}?key=${TEST_KEY}`;
+}
+
 export function mockEndpoint(
   endpoint: Endpoint,
   response: object,
   status = 200
 ): Route {
   return mock(
-    `${TEST_SCHEME}://${TEST_HOST}${endpoint}?key=${TEST_KEY}`,
+    endpointUrl(endpoint),
     response,
     status
   );