Rename all v9 modular useEmulator functions to connectEmulator (#5179)

* Update useEmulator function names

* update function name

Co-authored-by: Feiyang1 <plane1113@gmail.com>

Author: sam-gc

common/api-review/auth-exp.api.md

@@ -173,6 +173,11 @@ export interface ConfirmationResult {
 // @public
 export function confirmPasswordReset(auth: Auth, oobCode: string, newPassword: string): Promise<void>;
 
+// @public
+export function connectAuthEmulator(auth: Auth, url: string, options?: {
+    disableWarnings: boolean;
+}): void;
+
 // @public
 export function createUserWithEmailAndPassword(auth: Auth, email: string, password: string): Promise<UserCredential>;
 
@@ -644,11 +649,6 @@ export function updateProfile(user: User, { displayName, photoURL: photoUrl }: {
     photoURL?: string | null;
 }): Promise<void>;
 
-// @public
-export function useAuthEmulator(auth: Auth, url: string, options?: {
-    disableWarnings: boolean;
-}): void;
-
 // @public
 export function useDeviceLanguage(auth: Auth): void;
 

common/api-review/database.api.md

@@ -10,6 +10,11 @@ import { FirebaseApp } from '@firebase/app';
 // @public
 export function child(parent: Reference, path: string): Reference;
 
+// @public
+export function connectDatabaseEmulator(db: FirebaseDatabase, host: string, port: number, options?: {
+    mockUserToken?: EmulatorMockTokenOptions;
+}): void;
+
 // @public
 export class DataSnapshot {
     child(path: string): DataSnapshot;
@@ -229,10 +234,5 @@ export type Unsubscribe = () => void;
 // @public
 export function update(ref: Reference, values: object): Promise<void>;
 
-// @public
-export function useDatabaseEmulator(db: FirebaseDatabase, host: string, port: number, options?: {
-    mockUserToken?: EmulatorMockTokenOptions;
-}): void;
-
 
 ```

common/api-review/functions-exp.api.md

@@ -7,6 +7,9 @@
 import { FirebaseApp } from '@firebase/app-exp';
 import { FirebaseError } from '@firebase/util';
 
+// @public
+export function connectFunctionsEmulator(functionsInstance: Functions, host: string, port: number): void;
+
 // @public
 export interface Functions {
     app: FirebaseApp;
@@ -42,8 +45,5 @@ export interface HttpsCallableResult<ResponseData = unknown> {
     readonly data: ResponseData;
 }
 
-// @public
-export function useFunctionsEmulator(functionsInstance: Functions, host: string, port: number): void;
-
 
 ```

common/api-review/storage.api.md

@@ -15,6 +15,9 @@ import { Provider } from '@firebase/component';
 import { Subscribe } from '@firebase/util';
 import { Unsubscribe } from '@firebase/util';
 
+// @public
+export function connectStorageEmulator(storage: StorageService, host: string, port: number): void;
+
 // @public
 export function deleteObject(ref: StorageReference): Promise<void>;
 
@@ -254,8 +257,5 @@ export interface UploadTaskSnapshot {
     totalBytes: number;
 }
 
-// @public
-export function useStorageEmulator(storage: StorageService, host: string, port: number): void;
-
 
 ```

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

@@ -127,7 +127,7 @@ export class Auth
     return this._delegate.signOut();
   }
   useEmulator(url: string, options?: { disableWarnings: boolean }): void {
-    exp.useAuthEmulator(this._delegate, url, options);
+    exp.connectAuthEmulator(this._delegate, url, options);
   }
   applyActionCode(code: string): Promise<void> {
     return exp.applyActionCode(this._delegate, code);

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

@@ -28,7 +28,7 @@ import * as fetch from '../../../test/helpers/mock_fetch';
 import { Endpoint } from '../../api';
 import { UserInternal } from '../../model/user';
 import { _castAuth } from './auth_impl';
-import { useAuthEmulator } from './emulator';
+import { connectAuthEmulator } from './emulator';
 
 use(sinonChai);
 use(chaiAsPromised);
@@ -67,48 +67,49 @@ describe('core/auth/emulator', () => {
     }
   });
 
-  context('useAuthEmulator', () => {
+  context('connectAuthEmulator', () => {
     it('fails if a network request has already been made', async () => {
       await user.delete();
-      expect(() => useAuthEmulator(auth, 'http://localhost:2020')).to.throw(
+      expect(() => connectAuthEmulator(auth, 'http://localhost:2020')).to.throw(
         FirebaseError,
         'auth/emulator-config-failed'
       );
     });
 
     it('updates the endpoint appropriately', async () => {
-      useAuthEmulator(auth, 'http://localhost:2020');
+      connectAuthEmulator(auth, 'http://localhost:2020');
       await user.delete();
       expect(normalEndpoint.calls.length).to.eq(0);
       expect(emulatorEndpoint.calls.length).to.eq(1);
     });
 
     it('updates the endpoint appropriately with trailing slash', async () => {
-      useAuthEmulator(auth, 'http://localhost:2020/');
+      connectAuthEmulator(auth, 'http://localhost:2020/');
       await user.delete();
       expect(normalEndpoint.calls.length).to.eq(0);
       expect(emulatorEndpoint.calls.length).to.eq(1);
     });
 
     it('checks the scheme properly', () => {
-      expect(() => useAuthEmulator(auth, 'http://localhost:2020')).not.to.throw;
+      expect(() => connectAuthEmulator(auth, 'http://localhost:2020')).not.to
+        .throw;
       delete auth.config.emulator;
-      expect(() => useAuthEmulator(auth, 'https://localhost:2020')).not.to
+      expect(() => connectAuthEmulator(auth, 'https://localhost:2020')).not.to
         .throw;
       delete auth.config.emulator;
-      expect(() => useAuthEmulator(auth, 'ssh://localhost:2020')).to.throw(
+      expect(() => connectAuthEmulator(auth, 'ssh://localhost:2020')).to.throw(
         FirebaseError,
         'auth/invalid-emulator-scheme'
       );
       delete auth.config.emulator;
-      expect(() => useAuthEmulator(auth, 'localhost:2020')).to.throw(
+      expect(() => connectAuthEmulator(auth, 'localhost:2020')).to.throw(
         FirebaseError,
         'auth/invalid-emulator-scheme'
       );
     });
 
     it('attaches a banner to the DOM', () => {
-      useAuthEmulator(auth, 'http://localhost:2020');
+      connectAuthEmulator(auth, 'http://localhost:2020');
       if (typeof document !== 'undefined') {
         const el = document.querySelector('.firebase-emulator-warning')!;
         expect(el).not.to.be.null;
@@ -121,7 +122,7 @@ describe('core/auth/emulator', () => {
 
     it('logs out a warning to the console', () => {
       sinon.stub(console, 'info');
-      useAuthEmulator(auth, 'http://localhost:2020');
+      connectAuthEmulator(auth, 'http://localhost:2020');
       expect(console.info).to.have.been.calledWith(
         'WARNING: You are using the Auth Emulator,' +
           ' which is intended for local testing only.  Do not use with' +
@@ -131,7 +132,9 @@ describe('core/auth/emulator', () => {
 
     it('logs out the warning but has no banner if disableBanner true', () => {
       sinon.stub(console, 'info');
-      useAuthEmulator(auth, 'http://localhost:2020', { disableWarnings: true });
+      connectAuthEmulator(auth, 'http://localhost:2020', {
+        disableWarnings: true
+      });
       expect(console.info).to.have.been.calledWith(
         'WARNING: You are using the Auth Emulator,' +
           ' which is intended for local testing only.  Do not use with' +
@@ -143,7 +146,7 @@ describe('core/auth/emulator', () => {
     });
 
     it('sets emulatorConfig on the Auth object', async () => {
-      useAuthEmulator(auth, 'http://localhost:2020');
+      connectAuthEmulator(auth, 'http://localhost:2020');
       expect(auth.emulatorConfig).to.eql({
         protocol: 'http',
         host: 'localhost',
@@ -153,7 +156,7 @@ describe('core/auth/emulator', () => {
     });
 
     it('sets disableWarnings in emulatorConfig accordingly', async () => {
-      useAuthEmulator(auth, 'https://127.0.0.1', { disableWarnings: true });
+      connectAuthEmulator(auth, 'https://127.0.0.1', { disableWarnings: true });
       expect(auth.emulatorConfig).to.eql({
         protocol: 'https',
         host: '127.0.0.1',
@@ -163,7 +166,7 @@ describe('core/auth/emulator', () => {
     });
 
     it('quotes IPv6 address in emulatorConfig', async () => {
-      useAuthEmulator(auth, 'http://[::1]:2020/');
+      connectAuthEmulator(auth, 'http://[::1]:2020/');
       expect(auth.emulatorConfig).to.eql({
         protocol: 'http',
         host: '[::1]',
@@ -181,9 +184,9 @@ describe('core/auth/emulator', () => {
     });
 
     it('also stringifies the current user', () => {
-      auth.currentUser = ({
+      auth.currentUser = {
         toJSON: (): object => ({ foo: 'bar' })
-      } as unknown) as UserInternal;
+      } as unknown as UserInternal;
       expect(JSON.stringify(auth)).to.eq(
         '{"apiKey":"test-api-key","authDomain":"localhost",' +
           '"appName":"test-app","currentUser":{"foo":"bar"}}'

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

@@ -31,7 +31,7 @@ import { _castAuth } from './auth_impl';
  *
  * @example
  * ```javascript
- * useAuthEmulator(auth, 'http://127.0.0.1:9099', { disableWarnings: true });
+ * connectAuthEmulator(auth, 'http://127.0.0.1:9099', { disableWarnings: true });
  * ```
  *
  * @param auth - The Auth instance.
@@ -40,7 +40,7 @@ import { _castAuth } from './auth_impl';
  *
  * @public
  */
-export function useAuthEmulator(
+export function connectAuthEmulator(
   auth: Auth,
   url: string,
   options?: { disableWarnings: boolean }

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

@@ -169,7 +169,7 @@ function _debugErrorMap(): ErrorMap<AuthErrorCode> {
     [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 ' +
-      '"useAuthEmulator()" sooner.',
+      '"connectAuthEmulator()" 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/core/index.ts

@@ -150,7 +150,7 @@ export function signOut(auth: Auth): Promise<void> {
 }
 
 export { initializeAuth } from './auth/initialize';
-export { useAuthEmulator } from './auth/emulator';
+export { connectAuthEmulator } from './auth/emulator';
 
 // credentials
 export { AuthCredential } from './credentials';

packages-exp/auth-exp/test/helpers/integration/helpers.ts

@@ -19,7 +19,7 @@ import * as sinon from 'sinon';
 import { deleteApp, initializeApp } from '@firebase/app-exp';
 import { Auth, User } from '../../../src/model/public_types';
 
-import { getAuth, useAuthEmulator } from '../../../'; // Use browser OR node dist entrypoint depending on test env.
+import { getAuth, connectAuthEmulator } from '../../../'; // Use browser OR node dist entrypoint depending on test env.
 import { _generateEventId } from '../../../src/core/util/event_id';
 import { getAppConfig, getEmulatorUrl } from './settings';
 import { resetEmulator } from './emulator_rest_helpers';
@@ -42,7 +42,7 @@ export function getTestInstance(requireEmulator = false): Auth {
 
   if (emulatorUrl) {
     const stub = stubConsoleToSilenceEmulatorWarnings();
-    useAuthEmulator(auth, emulatorUrl, { disableWarnings: true });
+    connectAuthEmulator(auth, emulatorUrl, { disableWarnings: true });
     stub.restore();
   } else if (requireEmulator) {
     /* Emulator wasn't configured but test must use emulator */