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

* Update useEmulator function names

* update function name

Co-authored-by: Feiyang1 <[email protected]>

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 */

packages-exp/auth-exp/test/integration/webdriver/static/index.js

@@ -22,7 +22,7 @@ import * as popup from './popup';
 import * as email from './email';
 import * as persistence from './persistence';
 import { initializeApp } from '@firebase/app-exp';
-import { getAuth, useAuthEmulator } from '@firebase/auth-exp';
+import { getAuth, connectAuthEmulator } from '@firebase/auth-exp';
 
 window.core = core;
 window.anonymous = anonymous;
@@ -39,7 +39,7 @@ window.legacyAuth = null;
 window.startAuth = async () => {
   const app = initializeApp(firebaseConfig);
   const auth = getAuth(app);
-  useAuthEmulator(auth, emulatorUrl);
+  connectAuthEmulator(auth, emulatorUrl);
   window.auth = auth;
 };
 

packages-exp/functions-compat/src/service.test.ts

@@ -31,7 +31,7 @@ describe('Firebase Functions > Service', () => {
   let httpsCallableStub: SinonStub = stub();
 
   before(() => {
-    functionsEmulatorStub = stub(functionsExp, 'useFunctionsEmulator');
+    functionsEmulatorStub = stub(functionsExp, 'connectFunctionsEmulator');
     httpsCallableStub = stub(functionsExp, 'httpsCallable');
   });
 

packages-exp/functions-compat/src/service.ts

@@ -18,7 +18,7 @@
 import { FirebaseFunctions, HttpsCallable } from '@firebase/functions-types';
 import {
   httpsCallable as httpsCallableExp,
-  useFunctionsEmulator as useFunctionsEmulatorExp,
+  connectFunctionsEmulator as useFunctionsEmulatorExp,
   HttpsCallableOptions,
   Functions as FunctionsServiceExp
 } from '@firebase/functions-exp';

packages-exp/functions-exp/src/api.ts

@@ -23,7 +23,7 @@ import { Functions, HttpsCallableOptions, HttpsCallable } from './public-types';
 import {
   FunctionsService,
   DEFAULT_REGION,
-  useFunctionsEmulator as _useFunctionsEmulator,
+  connectFunctionsEmulator as _connectFunctionsEmulator,
   httpsCallable as _httpsCallable
 } from './service';
 import { getModularInstance } from '@firebase/util';
@@ -62,12 +62,12 @@ export function getFunctions(
  * @param port - The emulator port (ex: 5001)
  * @public
  */
-export function useFunctionsEmulator(
+export function connectFunctionsEmulator(
   functionsInstance: Functions,
   host: string,
   port: number
 ): void {
-  _useFunctionsEmulator(
+  _connectFunctionsEmulator(
     getModularInstance<FunctionsService>(functionsInstance as FunctionsService),
     host,
     port

packages-exp/functions-exp/src/service.test.ts

@@ -16,7 +16,7 @@
  */
 import { assert } from 'chai';
 import { createTestService } from '../test/utils';
-import { FunctionsService, useFunctionsEmulator } from './service';
+import { FunctionsService, connectFunctionsEmulator } from './service';
 
 describe('Firebase Functions > Service', () => {
   describe('simple constructor', () => {
@@ -41,7 +41,7 @@ describe('Firebase Functions > Service', () => {
 
     it('can use emulator', () => {
       service = createTestService(app);
-      useFunctionsEmulator(service, 'localhost', 5005);
+      connectFunctionsEmulator(service, 'localhost', 5005);
       assert.equal(
         service._url('foo'),
         'http://localhost:5005/my-project/us-central1/foo'
@@ -58,7 +58,7 @@ describe('Firebase Functions > Service', () => {
 
     it('correctly sets region with emulator', () => {
       service = createTestService(app, 'my-region');
-      useFunctionsEmulator(service, 'localhost', 5005);
+      connectFunctionsEmulator(service, 'localhost', 5005);
       assert.equal(
         service._url('foo'),
         'http://localhost:5005/my-project/my-region/foo'
@@ -72,7 +72,7 @@ describe('Firebase Functions > Service', () => {
 
     it('prefers emulator to custom domain', () => {
       const service = createTestService(app, 'https://mydomain.com');
-      useFunctionsEmulator(service, 'localhost', 5005);
+      connectFunctionsEmulator(service, 'localhost', 5005);
       assert.equal(
         service._url('foo'),
         'http://localhost:5005/my-project/us-central1/foo'

packages-exp/functions-exp/src/service.ts

@@ -147,7 +147,7 @@ export class FunctionsService implements _FirebaseService {
  * @param port The emulator port (ex: 5001)
  * @public
  */
-export function useFunctionsEmulator(
+export function connectFunctionsEmulator(
   functionsInstance: FunctionsService,
   host: string,
   port: number

packages-exp/functions-exp/test/utils.ts

@@ -21,7 +21,7 @@ import { FirebaseAuthInternalName } from '@firebase/auth-interop-types';
 import { FirebaseMessagingName } from '@firebase/messaging-types';
 import { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';
 import { FunctionsService } from '../src/service';
-import { useFunctionsEmulator } from '../src/api';
+import { connectFunctionsEmulator } from '../src/api';
 import nodeFetch from 'node-fetch';
 
 export function makeFakeApp(options: FirebaseOptions = {}): FirebaseApp {
@@ -71,7 +71,7 @@ export function createTestService(
   const useEmulator = !!process.env.FIREBASE_FUNCTIONS_EMULATOR_ORIGIN;
   if (useEmulator) {
     const url = new URL(process.env.FIREBASE_FUNCTIONS_EMULATOR_ORIGIN!);
-    useFunctionsEmulator(
+    connectFunctionsEmulator(
       functions,
       url.hostname,
       Number.parseInt(url.port, 10)