adding skippig of totp tests if emulator is being used

Author: bhparijat

packages/auth/test/integration/flows/totp.test.ts

@@ -37,6 +37,8 @@ import {
   TotpMultiFactorGenerator,
   TotpSecret
 } from '../../../src/mfa/assertions/totp';
+import { _emulatorUrl } from '../../../src/core/util/emulator';
+import { getEmulatorUrl } from '../../helpers/integration/settings';
 
 use(chaiAsPromised);
 use(sinonChai);
@@ -46,116 +48,130 @@ describe(' Integration tests: Mfa TOTP', () => {
   let totpSecret: TotpSecret;
   let displayName: string;
   let totpTimestamp: Date;
+  let emulatorUrl: string | null;
   beforeEach(async () => {
-    auth = getTestInstance();
-    displayName = 'totp-integration-test';
+    emulatorUrl = getEmulatorUrl();
+    if (!emulatorUrl) {
+      auth = getTestInstance();
+      displayName = 'totp-integration-test';
+    }
   });
 
   afterEach(async () => {
-    await cleanUpTestInstance(auth);
+    if (!emulatorUrl) {
+      await cleanUpTestInstance(auth);
+    }
   });
 
   it('should not enroll if incorrect totp supplied', async () => {
-    const cr = await signInWithEmailAndPassword(auth, email, 'password');
-    const mfaUser = multiFactor(cr.user);
-    const session = await mfaUser.getSession();
-    totpSecret = await TotpMultiFactorGenerator.generateSecret(session);
-    const multiFactorAssertion =
-      TotpMultiFactorGenerator.assertionForEnrollment(
-        totpSecret,
-        incorrectTotpCode
-      );
-
-    await expect(
-      mfaUser.enroll(multiFactorAssertion, displayName)
-    ).to.be.rejectedWith('auth/invalid-verification-code');
+    if (!emulatorUrl) {
+      const cr = await signInWithEmailAndPassword(auth, email, 'password');
+      const mfaUser = multiFactor(cr.user);
+      const session = await mfaUser.getSession();
+      totpSecret = await TotpMultiFactorGenerator.generateSecret(session);
+      const multiFactorAssertion =
+        TotpMultiFactorGenerator.assertionForEnrollment(
+          totpSecret,
+          incorrectTotpCode
+        );
+
+      await expect(
+        mfaUser.enroll(multiFactorAssertion, displayName)
+      ).to.be.rejectedWith('auth/invalid-verification-code');
+    }
   });
 
   it('should enroll using correct otp', async () => {
-    const cr = await signInWithEmailAndPassword(auth, email, 'password');
-
-    const mfaUser = multiFactor(cr.user);
+    if (!emulatorUrl) {
+      const cr = await signInWithEmailAndPassword(auth, email, 'password');
 
-    const session = await mfaUser.getSession();
+      const mfaUser = multiFactor(cr.user);
 
-    totpSecret = await TotpMultiFactorGenerator.generateSecret(session);
+      const session = await mfaUser.getSession();
 
-    totpTimestamp = new Date();
+      totpSecret = await TotpMultiFactorGenerator.generateSecret(session);
 
-    const totpVerificationCode = getTotpCode(
-      totpSecret.secretKey,
-      totpSecret.codeIntervalSeconds,
-      totpSecret.codeLength,
-      totpTimestamp
-    );
+      totpTimestamp = new Date();
 
-    const multiFactorAssertion =
-      TotpMultiFactorGenerator.assertionForEnrollment(
-        totpSecret,
-        totpVerificationCode
+      const totpVerificationCode = getTotpCode(
+        totpSecret.secretKey,
+        totpSecret.codeIntervalSeconds,
+        totpSecret.codeLength,
+        totpTimestamp
       );
-    await expect(mfaUser.enroll(multiFactorAssertion, displayName)).to.be
-      .fulfilled;
+
+      const multiFactorAssertion =
+        TotpMultiFactorGenerator.assertionForEnrollment(
+          totpSecret,
+          totpVerificationCode
+        );
+      await expect(mfaUser.enroll(multiFactorAssertion, displayName)).to.be
+        .fulfilled;
+    }
   });
 
   it('should not allow sign-in with incorrect totp', async () => {
     let resolver;
 
-    try {
-      await signInWithEmailAndPassword(auth, email, 'password');
+    if (!emulatorUrl) {
+      try {
+        await signInWithEmailAndPassword(auth, email, 'password');
 
-      throw new Error('Signin should not have been successful');
-    } catch (error) {
-      expect(error).to.be.an.instanceOf(FirebaseError);
-      expect((error as any).code).to.eql('auth/multi-factor-auth-required');
+        throw new Error('Signin should not have been successful');
+      } catch (error) {
+        expect(error).to.be.an.instanceOf(FirebaseError);
+        expect((error as any).code).to.eql('auth/multi-factor-auth-required');
 
-      resolver = getMultiFactorResolver(auth, error as any);
-      expect(resolver.hints).to.have.length(1);
+        resolver = getMultiFactorResolver(auth, error as any);
+        expect(resolver.hints).to.have.length(1);
 
-      const assertion = TotpMultiFactorGenerator.assertionForSignIn(
-        resolver.hints[0].uid,
-        incorrectTotpCode
-      );
+        const assertion = TotpMultiFactorGenerator.assertionForSignIn(
+          resolver.hints[0].uid,
+          incorrectTotpCode
+        );
 
-      await expect(resolver.resolveSignIn(assertion)).to.be.rejectedWith(
-        'auth/invalid-verification-code'
-      );
+        await expect(resolver.resolveSignIn(assertion)).to.be.rejectedWith(
+          'auth/invalid-verification-code'
+        );
+      }
     }
   });
 
   it('should allow sign-in with for correct totp and unenroll successfully', async () => {
     let resolver;
-    try {
-      await signInWithEmailAndPassword(auth, email, 'password');
-
-      throw new Error('Signin should not have been successful');
-    } catch (error) {
-      expect(error).to.be.an.instanceOf(FirebaseError);
-      expect((error as any).code).to.eql('auth/multi-factor-auth-required');
-
-      resolver = getMultiFactorResolver(auth, error as any);
-      expect(resolver.hints).to.have.length(1);
-
-      totpTimestamp.setSeconds(totpTimestamp.getSeconds() + 30);
-
-      const totpVerificationCode = getTotpCode(
-        totpSecret.secretKey,
-        totpSecret.codeIntervalSeconds,
-        totpSecret.codeLength,
-        totpTimestamp
-      );
-
-      const assertion = TotpMultiFactorGenerator.assertionForSignIn(
-        resolver.hints[0].uid,
-        totpVerificationCode
-      );
-      const userCredential = await resolver.resolveSignIn(assertion);
-
-      const mfaUser = multiFactor(userCredential.user);
-
-      await expect(mfaUser.unenroll(resolver.hints[0].uid)).to.be.fulfilled;
-      await expect(signInWithEmailAndPassword(auth, email, 'password')).to.be
-        .fulfilled;
+    if (!emulatorUrl) {
+      try {
+        await signInWithEmailAndPassword(auth, email, 'password');
+
+        throw new Error('Signin should not have been successful');
+      } catch (error) {
+        expect(error).to.be.an.instanceOf(FirebaseError);
+        expect((error as any).code).to.eql('auth/multi-factor-auth-required');
+
+        resolver = getMultiFactorResolver(auth, error as any);
+        expect(resolver.hints).to.have.length(1);
+
+        totpTimestamp.setSeconds(totpTimestamp.getSeconds() + 30);
+
+        const totpVerificationCode = getTotpCode(
+          totpSecret.secretKey,
+          totpSecret.codeIntervalSeconds,
+          totpSecret.codeLength,
+          totpTimestamp
+        );
+
+        const assertion = TotpMultiFactorGenerator.assertionForSignIn(
+          resolver.hints[0].uid,
+          totpVerificationCode
+        );
+        const userCredential = await resolver.resolveSignIn(assertion);
+
+        const mfaUser = multiFactor(userCredential.user);
+
+        await expect(mfaUser.unenroll(resolver.hints[0].uid)).to.be.fulfilled;
+        await expect(signInWithEmailAndPassword(auth, email, 'password')).to.be
+          .fulfilled;
+      }
     }
   });
 });