Get webdriver tests working

Author: sam-gc

packages-exp/auth-compat-exp/scripts/run_node_tests.ts

@@ -33,13 +33,14 @@ const nyc = resolve(__dirname, '../../../node_modules/.bin/nyc');
 const mocha = resolve(__dirname, '../../../node_modules/.bin/mocha');
 
 process.env.TS_NODE_COMPILER_OPTIONS = '{"module":"commonjs", "target": "es6"}';
+process.env.COMPAT_LAYER = 'true';
 
 let testConfig = ['src/**/*.test.ts'];
 
 if (argv.integration) {
   testConfig = ['test/integration/flows/**.test.ts'];
 } else if (argv.webdriver) {
-  testConfig = ['../auth-exp/test/integration/webdriver/anonymous.test.ts', '--delay'];
+  testConfig = ['../auth-exp/test/integration/webdriver/*.test.ts', '--delay'];
 }
 
 let args = [

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

@@ -219,7 +219,7 @@ export class Auth
         break;
       case Persistence.LOCAL:
         // Not using isIndexedDBAvailable() since it only checks if indexedDB is defined.
-        const isIndexedDBFullySupported = await (exp.indexedDBLocalPersistence as exp.PersistenceInternal)._isAvailable();
+        const isIndexedDBFullySupported = await exp._getInstance<exp.PersistenceInternal>(exp.indexedDBLocalPersistence)._isAvailable();
         converted = isIndexedDBFullySupported
           ? exp.indexedDBLocalPersistence
           : exp.browserLocalPersistence;

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

@@ -39,23 +39,17 @@ export class CompatPopupRedirectResolver
   ) => Promise<exp.UserCredential | null> = exp._getRedirectResult;
 
   async _initialize(auth: exp.AuthImpl): Promise<exp.EventManager> {
-    if (this.underlyingResolver) {
-      return this.underlyingResolver._initialize(auth);
-    }
-
-    // We haven't yet determined whether or not we're in Cordova; go ahead
-    // and determine that state now.
-    const isCordova = await _isCordova();
-    this.underlyingResolver = isCordova ? CORDOVA_RESOLVER : BROWSER_RESOLVER;
+    await this.selectUnderlyingResolver();
     return this.assertedUnderlyingResolver._initialize(auth);
   }
 
-  _openPopup(
+  async _openPopup(
     auth: exp.AuthImpl,
     provider: exp.AuthProvider,
     authType: exp.AuthEventType,
     eventId?: string
   ): Promise<exp.AuthPopup> {
+    await this.selectUnderlyingResolver();
     return this.assertedUnderlyingResolver._openPopup(
       auth,
       provider,
@@ -64,12 +58,13 @@ export class CompatPopupRedirectResolver
     );
   }
 
-  _openRedirect(
+  async _openRedirect(
     auth: exp.AuthImpl,
     provider: exp.AuthProvider,
     authType: exp.AuthEventType,
     eventId?: string
   ): Promise<void> {
+    await this.selectUnderlyingResolver();
     return this.assertedUnderlyingResolver._openRedirect(
       auth,
       provider,
@@ -97,4 +92,15 @@ export class CompatPopupRedirectResolver
     _assert(this.underlyingResolver, exp.AuthErrorCode.INTERNAL_ERROR);
     return this.underlyingResolver;
   }
+
+  private async selectUnderlyingResolver(): Promise<void> {
+    if (this.underlyingResolver) {
+      return;
+    }
+
+    // We haven't yet determined whether or not we're in Cordova; go ahead
+    // and determine that state now.
+    const isCordova = await _isCordova();
+    this.underlyingResolver = isCordova ? CORDOVA_RESOLVER : BROWSER_RESOLVER;
+  }
 }

packages-exp/auth-compat-exp/test/integration/webdriver/static/anonymous.js

@@ -16,6 +16,5 @@
  */
 
 export async function anonymousSignIn() {
-  console.error('hi');
-  return firebase.auth().signInAnonymously();
+  return compat.auth().signInAnonymously();
 }

packages-exp/auth-compat-exp/test/integration/webdriver/static/core.js

@@ -22,22 +22,30 @@ export function reset() {
 
 export function authInit() {
   return new Promise(resolve => {
-    firebase.auth().onAuthStateChanged(user => {
-      console.error('Init resolution', user);
+    compat.auth().onAuthStateChanged(user => {
       resolve();
     });
   });
 }
 
+export function legacyAuthInit() {
+  return new Promise(resolve => {
+    legacyAuth.onAuthStateChanged(() => resolve());
+  });
+}
+
 export async function userSnap() {
-  console.error('User snap', firebase.auth().currentUser);
-  return firebase.auth().currentUser;
+  return compat.auth().currentUser;
+}
+
+export async function legacyUserSnap() {
+  return legacyAuth.currentUser;
 }
 
 export async function authSnap() {
-  return firebase.auth();
+  return compat.auth();
 }
 
 export function signOut() {
-  return firebase.auth().signOut();
+  return compat.auth().signOut();
 }

packages-exp/auth-compat-exp/test/integration/webdriver/static/email.js

@@ -18,5 +18,5 @@
 const TEST_PASSWORD = 'password';
 
 export function createUser(email) {
-  return firebase.auth().createUserWithEmailAndPassword(email, TEST_PASSWORD);
+  return compat.auth().createUserWithEmailAndPassword(email, TEST_PASSWORD);
 }

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

@@ -15,31 +15,63 @@
  * limitations under the License.
  */
 
-// import * as redirect from './redirect';
+import * as redirect from './redirect';
 import firebase from '@firebase/app-compat';
 import '@firebase/auth-compat';
 import * as anonymous from './anonymous';
 import * as core from './core';
-// import * as popup from './popup';
+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 * as persistence from './persistence';
 
 window.core = core;
 window.anonymous = anonymous;
-// window.redirect = redirect;
-// window.popup = popup;
+window.redirect = redirect;
+window.popup = popup;
 window.email = email;
-// window.persistence = persistence;
+window.persistence = persistence;
 
-// window.auth = null;
+window.compat = null;
+window.legacyAuth = null;
 
 // The config and emulator URL are injected by the test. The test framework
 // calls this function after that injection.
 window.startAuth = async () => {
-  console.warn('Starting auth...');
+  // Make sure we haven't confused our firebase with the old firebase
+  if (!firebase.SDK_VERSION.startsWith('0.9')) {
+    throw new Error('Using legacy SDK version instead of compat version ' + firebase.SDK_VERSION);
+  }
   firebase.initializeApp(firebaseConfig);
   firebase.auth().useEmulator(emulatorUrl);
-  window.firebase = firebase;
+  window.compat = firebase;
 };
+
+
+window.startLegacySDK = async persistence => {
+  return new Promise((resolve, reject) => {
+    const appScript = document.createElement('script');
+    // TODO: Find some way to make the tests work without Internet.
+    appScript.src = 'https://www.gstatic.com/firebasejs/8.3.0/firebase-app.js';
+    appScript.onerror = reject;
+    document.head.appendChild(appScript);
+
+    const authScript = document.createElement('script');
+    authScript.src =
+      'https://www.gstatic.com/firebasejs/8.3.0/firebase-auth.js';
+    authScript.onerror = reject;
+    authScript.onload = function () {
+      window.firebase.initializeApp(firebaseConfig);
+      // Make sure the firebase variable here is the legacy SDK
+      if (window.firebase.SDK_VERSION !== '8.3.0') {
+        reject(new Error('Not using correct legacy version; using ' + window.firebase.SDK_VERSION));
+      }
+      const legacyAuth = window.firebase.auth();
+      legacyAuth.useEmulator(emulatorUrl);
+      legacyAuth.setPersistence(persistence.toLowerCase());
+      window.legacyAuth = legacyAuth;
+      resolve();
+    };
+    document.head.appendChild(authScript);
+  });
+};
+

packages-exp/auth-compat-exp/test/integration/webdriver/static/persistence.js

@@ -25,9 +25,14 @@ const sessionStorage = window.sessionStorage;
 export async function clearPersistence() {
   sessionStorage.clear();
   localStorage.clear();
-  return dbPromise(indexedDB.deleteDatabase(INDEXED_DB_NAME)).catch(
-    () => undefined
-  );
+  // HACK: Deleting databases in Firefox sometimes take a few seconds. Let's just return early.
+  return withTimeout(
+    1000,
+    dbPromise(indexedDB.deleteDatabase(INDEXED_DB_NAME))
+  ).catch(e => {
+    console.error(e);
+    return;
+  });
 }
 
 export async function localStorageSnap() {
@@ -64,6 +69,22 @@ export async function indexedDBSnap() {
   return result;
 }
 
+export async function setPersistenceMemory() {
+  return compat.auth().setPersistence('none');
+}
+
+export async function setPersistenceSession() {
+  return compat.auth().setPersistence('session');
+}
+
+export async function setPersistenceLocalStorage() {
+  return compat.auth().setPersistence('local');
+}
+
+export async function setPersistenceIndexedDB() {
+  return compat.auth().setPersistence('local');
+}
+
 // Mock functions for testing edge cases
 export async function makeIndexedDBReadonly() {
   IDBObjectStore.prototype.add = IDBObjectStore.prototype.put = () => {
@@ -111,3 +132,12 @@ function dbPromise(dbRequest) {
     });
   });
 }
+
+function withTimeout(ms, promise) {
+  return Promise.race([
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new Error('operation timed out')), ms)
+    ),
+    promise
+  ]);
+}

packages-exp/auth-compat-exp/test/integration/webdriver/static/popup.js

@@ -0,0 +1,85 @@
+/**
+ * @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.
+ */
+
+// These functions are a little funky: WebDriver relies on callbacks to
+// pass data back to the main Node process. Because of that setup, we can't
+// return the popup tasks as pending promises as they won't resolve until
+// the WebDriver is allowed to do other stuff. Instead, we'll store the
+// promises in variables and provide a way to retrieve them later, unblocking
+// the WebDriver process.
+let popupPromise = null;
+let popupCred = null;
+let errorCred = null;
+
+export function idpPopup(optProvider) {
+  const provider = optProvider
+    ? new compat.auth.OAuthProvider(optProvider)
+    : new compat.auth.GoogleAuthProvider();
+  popupPromise = compat.auth().signInWithPopup(provider);
+}
+
+export function idpReauthPopup() {
+  popupPromise = compat.auth().currentUser.reauthenticateWithPopup(
+    new compat.auth.GoogleAuthProvider()
+  );
+}
+
+export function idpLinkPopup() {
+  popupPromise = compat.auth().currentUser.linkWithPopup(new compat.auth.GoogleAuthProvider());
+}
+
+export function popupResult() {
+  return popupPromise;
+}
+
+export async function generateCredentialFromResult() {
+  const result = await popupPromise;
+  popupCred = result.credential;
+  return popupCred;
+}
+
+export async function signInWithPopupCredential() {
+  return compat.auth().signInWithCredential(popupCred);
+}
+
+export async function linkWithErrorCredential() {
+  await compat.auth().currentUser.linkWithCredential(errorCred);
+}
+
+// These below are not technically popup functions but they're helpers for
+// the popup tests.
+
+export function createFakeGoogleUser(email) {
+  return compat.auth().signInWithCredential(
+    compat.auth.GoogleAuthProvider.credential(
+      `{"sub": "__${email}__", "email": "${email}", "email_verified": true}`
+    )
+  );
+}
+
+export async function tryToSignInUnverified(email) {
+  try {
+    await compat.auth().signInWithCredential(
+      compat.auth.FacebookAuthProvider.credential(
+        `{"sub": "$$${email}$$", "email": "${email}", "email_verified": false}`
+      )
+    );
+  } catch (e) {
+    errorCred = e.credential;
+    throw e;
+  }
+}