Update the phone tests to work with the emulator (#4574)

* Add custom auth test

* Formatting

* es lint

* Update some stuff

* Formatting

* Allow phone tests to run against emulator as well

* Formatting, license

* es lint

Author: sam-gc

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

@@ -0,0 +1,59 @@
+/**
+ * @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.
+ */
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Auth } from '@firebase/auth-exp';
+import { getApps } from '@firebase/app-exp';
+
+interface VerificationSession {
+  code: string;
+  phoneNumber: string;
+  sessionInfo: string;
+}
+
+interface VerificationCodesResponse {
+  verificationCodes: VerificationSession[];
+}
+
+export async function getPhoneVerificationCodes(
+  auth: Auth
+): Promise<Record<string, VerificationSession>> {
+  assertEmulator(auth);
+  const url = getEmulatorUrl(auth, 'verificationCodes');
+  const response: VerificationCodesResponse = await (await fetch(url)).json();
+
+  return response.verificationCodes.reduce((accum, session) => {
+    accum[session.sessionInfo] = session;
+    return accum;
+  }, {} as Record<string, VerificationSession>);
+}
+
+function getEmulatorUrl(auth: Auth, endpoint: string): string {
+  const { host, port, protocol } = auth.emulatorConfig!;
+  const projectId = getProjectId(auth);
+  return `${protocol}://${host}:${port}/emulator/v1/projects/${projectId}/${endpoint}`;
+}
+
+function getProjectId(auth: Auth): string {
+  return getApps().find(app => app.name === auth.name)!.options.projectId!;
+}
+
+function assertEmulator(auth: Auth): void {
+  if (!auth.emulatorConfig) {
+    throw new Error("Can't fetch OOB codes against prod API");
+  }
+}

packages-exp/auth-exp/test/integration/flows/phone.test.ts

@@ -30,7 +30,8 @@ import {
   Auth,
   OperationType,
   ProviderId,
-  UserCredential
+  UserCredential,
+  ConfirmationResult
   // eslint-disable-next-line import/no-extraneous-dependencies
 } from '@firebase/auth-exp';
 import { FirebaseError } from '@firebase/util';
@@ -39,6 +40,7 @@ import {
   cleanUpTestInstance,
   getTestInstance
 } from '../../helpers/integration/helpers';
+import { getPhoneVerificationCodes } from '../../helpers/integration/emulator_rest_helpers';
 
 use(chaiAsPromised);
 
@@ -80,9 +82,23 @@ describe('Integration test: phone auth', () => {
     document.body.removeChild(fakeRecaptchaContainer);
   });
 
+  /** If in the emulator, search for the code in the API */
+  async function code(
+    crOrId: ConfirmationResult | string,
+    fallback: string
+  ): Promise<string> {
+    if (auth.emulatorConfig) {
+      const codes = await getPhoneVerificationCodes(auth);
+      const vid = typeof crOrId === 'string' ? crOrId : crOrId.verificationId;
+      return codes[vid].code;
+    }
+
+    return fallback;
+  }
+
   it('allows user to sign up', async () => {
     const cr = await signInWithPhoneNumber(auth, PHONE_A.phoneNumber, verifier);
-    const userCred = await cr.confirm(PHONE_A.code);
+    const userCred = await cr.confirm(await code(cr, PHONE_A.code));
 
     expect(auth.currentUser).to.eq(userCred.user);
     expect(userCred.operationType).to.eq(OperationType.SIGN_IN);
@@ -98,7 +114,7 @@ describe('Integration test: phone auth', () => {
     const { uid: anonId } = user;
 
     const cr = await linkWithPhoneNumber(user, PHONE_A.phoneNumber, verifier);
-    const linkResult = await cr.confirm(PHONE_A.code);
+    const linkResult = await cr.confirm(await code(cr, PHONE_A.code));
     expect(linkResult.operationType).to.eq(OperationType.LINK);
     expect(linkResult.user.uid).to.eq(user.uid);
     expect(linkResult.user.phoneNumber).to.eq(PHONE_A.phoneNumber);
@@ -128,7 +144,7 @@ describe('Integration test: phone auth', () => {
         PHONE_A.phoneNumber,
         verifier
       );
-      signUpCred = await cr.confirm(PHONE_A.code);
+      signUpCred = await cr.confirm(await code(cr, PHONE_A.code));
       resetVerifier();
       await auth.signOut();
     });
@@ -139,14 +155,14 @@ describe('Integration test: phone auth', () => {
         PHONE_A.phoneNumber,
         verifier
       );
-      const signInCred = await cr.confirm(PHONE_A.code);
+      const signInCred = await cr.confirm(await code(cr, PHONE_A.code));
 
       expect(signInCred.user.uid).to.eq(signUpCred.user.uid);
     });
 
     it('allows the user to update their phone number', async () => {
       let cr = await signInWithPhoneNumber(auth, PHONE_A.phoneNumber, verifier);
-      const { user } = await cr.confirm(PHONE_A.code);
+      const { user } = await cr.confirm(await code(cr, PHONE_A.code));
 
       resetVerifier();
 
@@ -158,38 +174,48 @@ describe('Integration test: phone auth', () => {
 
       await updatePhoneNumber(
         user,
-        PhoneAuthProvider.credential(verificationId, PHONE_B.code)
+        PhoneAuthProvider.credential(
+          verificationId,
+          await code(verificationId, PHONE_B.code)
+        )
       );
       expect(user.phoneNumber).to.eq(PHONE_B.phoneNumber);
 
       await auth.signOut();
       resetVerifier();
 
       cr = await signInWithPhoneNumber(auth, PHONE_B.phoneNumber, verifier);
-      const { user: secondSignIn } = await cr.confirm(PHONE_B.code);
+      const { user: secondSignIn } = await cr.confirm(
+        await code(cr, PHONE_B.code)
+      );
       expect(secondSignIn.uid).to.eq(user.uid);
     });
 
     it('allows the user to reauthenticate with phone number', async () => {
       let cr = await signInWithPhoneNumber(auth, PHONE_A.phoneNumber, verifier);
-      const { user } = await cr.confirm(PHONE_A.code);
+      const { user } = await cr.confirm(await code(cr, PHONE_A.code));
       const oldToken = await user.getIdToken();
 
       resetVerifier();
 
+      // Wait a bit to ensure the sign in time is different in the token
+      await new Promise((resolve): void => {
+        setTimeout(resolve, 1500);
+      });
+
       cr = await reauthenticateWithPhoneNumber(
         user,
         PHONE_A.phoneNumber,
         verifier
       );
-      await cr.confirm(PHONE_A.code);
+      await cr.confirm(await code(cr, PHONE_A.code));
 
       expect(await user.getIdToken()).not.to.eq(oldToken);
     });
 
     it('prevents reauthentication with wrong phone number', async () => {
       let cr = await signInWithPhoneNumber(auth, PHONE_A.phoneNumber, verifier);
-      const { user } = await cr.confirm(PHONE_A.code);
+      const { user } = await cr.confirm(await code(cr, PHONE_A.code));
 
       resetVerifier();
 
@@ -198,7 +224,7 @@ describe('Integration test: phone auth', () => {
         PHONE_B.phoneNumber,
         verifier
       );
-      await expect(cr.confirm(PHONE_B.code)).to.be.rejectedWith(
+      await expect(cr.confirm(await code(cr, PHONE_B.code))).to.be.rejectedWith(
         FirebaseError,
         'auth/user-mismatch'
       );
@@ -207,7 +233,9 @@ describe('Integration test: phone auth', () => {
       // reauthenticateWithPhoneNumber does not trigger a state change
       resetVerifier();
       cr = await signInWithPhoneNumber(auth, PHONE_B.phoneNumber, verifier);
-      const { user: otherUser } = await cr.confirm(PHONE_B.code);
+      const { user: otherUser } = await cr.confirm(
+        await code(cr, PHONE_B.code)
+      );
       await otherUser.delete();
     });
   });