Clean up the test infra a bit

Author: sam-gc

packages-exp/auth-exp/scripts/run-node-tests.js

@@ -49,7 +49,7 @@ if (argv.integration) {
     testConfig.push('test/integration/flows/*.local.test.ts');
   }
 } else if (argv.webdriver) {
-  testConfig = ['test/integration/webdriver/**.test.ts'];
+  testConfig = ['test/integration/webdriver/**.test.ts', '--delay'];
 }
 
 let args = [

packages-exp/auth-exp/scripts/run-node-tests.ts

@@ -18,41 +18,38 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { OperationType, UserCredential } from '@firebase/auth-exp';
 import { expect } from 'chai';
-import { TestFunction, AuthDriver } from './util/authdriver';
+import { TestFunction } from './util/auth_driver';
+import { browserDescribe } from './util/test_runner';
 
 /**
  * Simple smoke test to demonstrate webdriver testing and serve as a template
  * for future tests; anonymous is largely covered by the headless tests in
  * test/integration/flows/anonymous.test.ts
  */
-describe('WebDriver anonymous auth test', () => {
-  const driver = new AuthDriver();
-
-  driver.runTestsInAvailableBrowsers(() => {
-    it('basic sign in is possible', async () => {
-      const cred: UserCredential = await driver.call(
-        TestFunction.SIGN_IN_ANONYMOUSLY
-      );
-      expect(cred).not.to.be.null;
-      expect(cred.user.isAnonymous).to.be.true;
-      expect(cred.operationType).to.eq(OperationType.SIGN_IN);
-      expect(await driver.getUserSnapshot()).to.eql(cred.user);
-    });
+browserDescribe('WebDriver anonymous auth test', driver => {
+  it('basic sign in is possible', async () => {
+    const cred: UserCredential = await driver.call(
+      TestFunction.SIGN_IN_ANONYMOUSLY
+    );
+    expect(cred).not.to.be.null;
+    expect(cred.user.isAnonymous).to.be.true;
+    expect(cred.operationType).to.eq(OperationType.SIGN_IN);
+    expect(await driver.getUserSnapshot()).to.eql(cred.user);
+  });
 
-    it('same user persists after refresh and sign in', async () => {
-      const { user: before }: UserCredential = await driver.call(
-        TestFunction.SIGN_IN_ANONYMOUSLY
-      );
-      await driver.refresh();
+  it('same user persists after refresh and sign in', async () => {
+    const { user: before }: UserCredential = await driver.call(
+      TestFunction.SIGN_IN_ANONYMOUSLY
+    );
+    await driver.refresh();
 
-      // First, is the user signed in from persistence?
-      expect(await driver.getUserSnapshot()).to.eql(before);
+    // First, is the user signed in from persistence?
+    expect(await driver.getUserSnapshot()).to.eql(before);
 
-      // Then, sign in again and check
-      const { user: after }: UserCredential = await driver.call(
-        TestFunction.SIGN_IN_ANONYMOUSLY
-      );
-      expect(after.uid).to.eq(before.uid);
-    });
+    // Then, sign in again and check
+    const { user: after }: UserCredential = await driver.call(
+      TestFunction.SIGN_IN_ANONYMOUSLY
+    );
+    expect(after.uid).to.eq(before.uid);
   });
 });

packages-exp/auth-exp/test/integration/webdriver/anonymous.test.ts

@@ -30,7 +30,17 @@ window.anonymous = async () => {
   return userCred;
 };
 
-window.reset = () => auth.signOut();
+window.reset = () => {
+  sessionStorage.clear();
+  localStorage.clear();
+  const del = indexedDB.deleteDatabase('firebaseLocalStorageDb');
+
+  return new Promise(resolve => {
+    del.addEventListener('success', () => resolve());
+    del.addEventListener('error', () => resolve());
+    del.addEventListener('blocked', () => resolve());
+  });
+}
 
 window.authInit = () => {
   return new Promise(resolve => {

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

@@ -26,9 +26,6 @@ import {
 } from '../../../helpers/integration/settings';
 import { authTestServer } from './test_server';
 
-/** Browsers to run the tests on */
-const BROWSERS = ['chrome', 'firefox'];
-
 /** Available functions within the browser. See static/index.js */
 export enum TestFunction {
   SIGN_IN_ANONYMOUSLY = 'anonymous',
@@ -55,27 +52,6 @@ export class AuthDriver {
     await this.webDriver.quit();
   }
 
-  /** Wraps a set of tests and runs them in multiple browsers */
-  runTestsInAvailableBrowsers(cb: () => void): void {
-    for (const browser of BROWSERS) {
-      context(`Under browser: ${browser}`, () => {
-        before(async () => {
-          await this.start(browser);
-        });
-
-        after(async () => {
-          await this.stop();
-        });
-
-        afterEach(async () => {
-          await this.reset();
-        });
-
-        cb();
-      });
-    }
-  }
-
   async call<T>(fn: TestFunction): Promise<T> {
     // When running on firefox we can't just return result immediately. For
     // some reason, the binding ends up causing a cycle dependency issue during
@@ -101,6 +77,7 @@ export class AuthDriver {
 
   async reset(): Promise<void> {
     await resetEmulator();
+    await this.webDriver.get(authTestServer.address!);
     return this.call(TestFunction.RESET);
   }
 
@@ -114,7 +91,7 @@ export class AuthDriver {
     await this.waitForAuthInit();
   }
 
-  private async injectConfigAndInitAuth(): Promise<void> {
+  async injectConfigAndInitAuth(): Promise<void> {
     if (!USE_EMULATOR) {
       throw new Error(
         'Local testing against emulator requested, but ' +

packages-exp/auth-exp/test/integration/webdriver/util/authdriver.ts renamed to packages-exp/auth-exp/test/integration/webdriver/util/auth_driver.ts

@@ -0,0 +1,67 @@
+import { AuthDriver } from './auth_driver';
+
+/*
+ * The most expensive operation in these tests is setting up / tearing down the
+ * driver. In order to avoid that cost, all of the tests are collected and
+ * bundled into single suites for each browser. To do this, we create a new
+ * describe function that is used to generate the new suites.
+ * 
+ * This test is started with the --delay flag, which allows us to control when
+ * test execution starts. Collection of the tests is synchronous, but we need
+ * a way to ensure that run() is called after they're all added. To accomplish
+ * this, we put the final construction of the suites (and the subsequent run()
+ * call) after a delay of 1ms.
+ */
+
+interface TempSuite {
+  generator: (driver: AuthDriver) => void;
+  title: string;
+}
+
+/** The browsers that these tests will run in */
+const BROWSERS = ['chrome', 'firefox'];
+
+/** One single AuthDriver instance to control everything */
+const DRIVER = new AuthDriver();
+const SUITES: TempSuite[] = [];
+
+/** Main entry point for all WebDriver tests */
+export function browserDescribe(title: string, generator:(driver: AuthDriver) => void): void {
+  SUITES.push({
+    title, generator
+  });
+}
+
+// Construct the final suites after a delay of 1ms, then kick off tests
+setTimeout(() => {
+  for (const browser of BROWSERS) {
+    describe(`Testing in browser "${browser}"`, () => {
+      before(async () => {
+        await DRIVER.start(browser);
+
+        // Prime for the first test.
+        await DRIVER.reset();
+      });
+
+      after(async () => {
+        await DRIVER.stop();
+      });
+
+      // It's assumed that the tests will start with a clean slate (i.e.
+      // no storage).
+      beforeEach(async () => {
+        await DRIVER.injectConfigAndInitAuth();
+      });
+
+      afterEach(async () => {
+        await DRIVER.reset();
+      });
+
+      for (const {title, generator} of SUITES) {
+        describe(title, () => generator(DRIVER));
+      }
+    });
+  }
+
+  run();
+}, 1);

packages-exp/auth-exp/test/integration/webdriver/util/test_runner.ts

@@ -38,8 +38,8 @@ class AuthTestServer {
     this.app.use([INTEGRATION_TEST_ASSETS]);
   }
 
-  get address(): string | null {
-    return this.server ? `http://localhost:${PORT_NUMBER}` : null;
+  get address(): string {
+    return `http://localhost:${PORT_NUMBER}`;
   }
 
   async start(): Promise<void> {