[Auth] Add integration test framework to compatibility layer.

packages-exp/auth-compat-exp/.eslintrc.js

@@ -17,6 +17,7 @@
 
 module.exports = {
   extends: '../../config/.eslintrc.js',
+  ignorePatterns: ['scripts/'],
   parserOptions: {
     project: 'tsconfig.json',
     // to make vscode-eslint work with monorepo

packages-exp/auth-compat-exp/index.node.ts

@@ -22,3 +22,11 @@
  * just use index.ts
  */
 export * from './index';
+import { FetchProvider } from '@firebase/auth-exp/internal';
+import * as fetchImpl from 'node-fetch';
+
+FetchProvider.initialize(
+  (fetchImpl.default as unknown) as typeof fetch,
+  (fetchImpl.Headers as unknown) as typeof Headers,
+  (fetchImpl.Response as unknown) as typeof Response
+);

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

@@ -15,6 +15,8 @@
  * limitations under the License.
  */
 
+/* eslint-disable camelcase */
+
 import firebase, { _FirebaseNamespace } from '@firebase/app-compat';
 import * as impl from '@firebase/auth-exp/internal';
 import * as externs from '@firebase/auth-exp';
@@ -24,13 +26,32 @@ import {
   InstantiationMode
 } from '@firebase/component';
 
-import { FirebaseAuth } from '@firebase/auth-types';
+import {
+  EmailAuthProvider,
+  EmailAuthProvider_Instance,
+  FacebookAuthProvider,
+  FacebookAuthProvider_Instance,
+  FirebaseAuth,
+  GithubAuthProvider,
+  GithubAuthProvider_Instance,
+  GoogleAuthProvider,
+  GoogleAuthProvider_Instance,
+  OAuthProvider,
+  PhoneAuthProvider,
+  PhoneAuthProvider_Instance,
+  PhoneMultiFactorGenerator,
+  RecaptchaVerifier,
+  RecaptchaVerifier_Instance,
+  SAMLAuthProvider,
+  TwitterAuthProvider,
+  TwitterAuthProvider_Instance
+} from '@firebase/auth-types';
 import { version } from './package.json';
 import { Auth } from './src/auth';
 import { Persistence } from './src/persistence';
-import { PhoneAuthProvider } from './src/phone_auth_provider';
+import { PhoneAuthProvider as CompatAuthProvider } from './src/phone_auth_provider';
 import { _getClientPlatform } from './src/platform';
-import { RecaptchaVerifier } from './src/recaptcha_verifier';
+import { RecaptchaVerifier as CompatRecaptchaVerifier } from './src/recaptcha_verifier';
 
 const AUTH_TYPE = 'auth';
 
@@ -44,6 +65,24 @@ declare module '@firebase/app-compat' {
   interface FirebaseNamespace {
     auth: {
       (app?: FirebaseApp): FirebaseAuth;
+      Auth: typeof FirebaseAuth;
+      EmailAuthProvider: typeof EmailAuthProvider;
+      EmailAuthProvider_Instance: typeof EmailAuthProvider_Instance;
+      FacebookAuthProvider: typeof FacebookAuthProvider;
+      FacebookAuthProvider_Instance: typeof FacebookAuthProvider_Instance;
+      GithubAuthProvider: typeof GithubAuthProvider;
+      GithubAuthProvider_Instance: typeof GithubAuthProvider_Instance;
+      GoogleAuthProvider: typeof GoogleAuthProvider;
+      GoogleAuthProvider_Instance: typeof GoogleAuthProvider_Instance;
+      OAuthProvider: typeof OAuthProvider;
+      SAMLAuthProvider: typeof SAMLAuthProvider;
+      PhoneAuthProvider: typeof PhoneAuthProvider;
+      PhoneAuthProvider_Instance: typeof PhoneAuthProvider_Instance;
+      PhoneMultiFactorGenerator: typeof PhoneMultiFactorGenerator;
+      RecaptchaVerifier: typeof RecaptchaVerifier;
+      RecaptchaVerifier_Instance: typeof RecaptchaVerifier_Instance;
+      TwitterAuthProvider: typeof TwitterAuthProvider;
+      TwitterAuthProvider_Instance: typeof TwitterAuthProvider_Instance;
     };
   }
   interface FirebaseApp {
@@ -84,9 +123,9 @@ function registerAuthCompat(instance: _FirebaseNamespace): void {
         GoogleAuthProvider: impl.GoogleAuthProvider,
         OAuthProvider: impl.OAuthProvider,
         //   SAMLAuthProvider,
-        PhoneAuthProvider,
+        PhoneAuthProvider: CompatAuthProvider,
         PhoneMultiFactorGenerator: impl.PhoneMultiFactorGenerator,
-        RecaptchaVerifier,
+        RecaptchaVerifier: CompatRecaptchaVerifier,
         TwitterAuthProvider: impl.TwitterAuthProvider,
         Auth: {
           Persistence

packages-exp/auth-compat-exp/karma.conf.js

@@ -16,20 +16,55 @@
  */
 
 const karmaBase = require('../../config/karma.base');
+const { argv } = require('yargs');
 
 const files = ['src/**/*.test.ts'];
 
 module.exports = function (config) {
   const karmaConfig = Object.assign({}, karmaBase, {
     // files to load into karma
-    files: files,
+    files: getTestFiles(),
     preprocessors: { '**/*.ts': ['webpack', 'sourcemap'] },
     // frameworks to use
     // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
-    frameworks: ['mocha']
+    frameworks: ['mocha'],
+
+    client: Object.assign({}, karmaBase.client, getClientConfig())
   });
 
   config.set(karmaConfig);
 };
 
-module.exports.files = files;
+function getTestFiles() {
+  if (argv.integration) {
+    return ['test/**/*.test.ts'];
+  } else {
+    return ['src/**/*.test.ts'];
+  }
+}
+
+function getClientConfig() {
+  if (!argv.integration) {
+    return {};
+  }
+
+  if (!process.env.GCLOUD_PROJECT || !process.env.FIREBASE_AUTH_EMULATOR_HOST) {
+    console.error(
+      'Local testing against emulator requested, but ' +
+        'GCLOUD_PROJECT and FIREBASE_AUTH_EMULATOR_HOST env variables ' +
+        'are missing'
+    );
+    process.exit(1);
+  }
+
+  return {
+    authAppConfig: {
+      apiKey: 'local-api-key',
+      projectId: process.env.GCLOUD_PROJECT,
+      authDomain: 'local-auth-domain'
+    },
+    authEmulatorHost: process.env.FIREBASE_AUTH_EMULATOR_HOST
+  };
+}
+
+module.exports.files = getTestFiles();

packages-exp/auth-compat-exp/package.json

@@ -22,7 +22,10 @@
     "test:all": "run-p test:browser test:node",
     "test:ci": "node ../../scripts/run_tests_in_ci.js -s test:all",
     "test:browser": "karma start --single-run",
-    "test:node": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' nyc --reporter lcovonly -- mocha src/**/*.test.* --file ../auth-exp/src/platform_browser/iframe/gapi.iframes.ts --config ../../config/mocharc.node.js"
+    "test:browser:integration": "karma start --single-run --integration",
+    "test:node": "ts-node -O '{\"module\": \"commonjs\", \"target\": \"es6\"}' scripts/run_node_tests.ts",
+    "test:node:integration": "ts-node -O '{\"module\": \"commonjs\", \"target\": \"es6\"}' scripts/run_node_tests.ts --integration",
+    "test:integration": "run-s test:browser:integration test:node:integration"
   },
   "peerDependencies": {
     "@firebase/app-compat": "0.x"
@@ -32,6 +35,7 @@
     "@firebase/auth-exp": "0.0.900",
     "@firebase/component": "0.2.1",
     "@firebase/util": "0.4.0",
+    "node-fetch": "2.6.1",
     "tslib": "^2.0.0"
   },
   "license": "Apache-2.0",

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

@@ -0,0 +1,83 @@
+/**
+ * @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.
+ */
+
+import { resolve } from 'path';
+
+import { spawn } from 'child-process-promise';
+import * as yargs from 'yargs';
+
+const argv = yargs.options({
+  integration: {
+    type: 'boolean'
+  },
+  webdriver: {
+    type: 'boolean'
+  }
+}).argv;
+
+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"}';
+
+let testConfig = ['src/**/*.test.ts'];
+
+if (argv.integration) {
+  testConfig = ['test/integration/flows/**.test.ts'];
+} else if (argv.webdriver) {
+  testConfig = ['test/integration/webdriver/**.test.ts', '--delay'];
+}
+
+let args = [
+  '--reporter',
+  'lcovonly',
+  mocha,
+  ...testConfig,
+  '--file',
+  '../auth-exp/src/platform_browser/iframe/gapi.iframes.ts',
+  '--config',
+  '../../config/mocharc.node.js'
+];
+
+// Make sure that the environment variables are present for local test
+if (argv.integration || argv.webdriver) {
+  if (!process.env.GCLOUD_PROJECT || !process.env.FIREBASE_AUTH_EMULATOR_HOST) {
+    console.error(
+      'Local testing against emulator requested, but ' +
+        'GCLOUD_PROJECT and FIREBASE_AUTH_EMULATOR_HOST env variables ' +
+        'are missing'
+    );
+    process.exit(1);
+  }
+}
+
+args = args.concat(argv._ as string[]);
+
+const spawned = spawn(nyc, args, {
+  stdio: 'inherit',
+  cwd: process.cwd()
+});
+
+const childProcess = spawned.childProcess;
+spawned.catch(() => {
+  childProcess.kill();
+  process.exit(1);
+});
+
+process.once('exit', () => childProcess.kill());
+process.once('SIGINT', () => childProcess.kill('SIGINT'));
+process.once('SIGTERM', () => childProcess.kill('SIGTERM'));

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

@@ -71,13 +71,14 @@ export class Auth
 
     this.auth._updateErrorMap(exp.debugErrorMap);
 
+    // Only use a popup/redirect resolver in browser environments
+    const resolver =
+      typeof window !== 'undefined' ? CompatPopupRedirectResolver : undefined;
+
     // This promise is intended to float; auth initialization happens in the
     // background, meanwhile the auth object may be used by the app.
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    this.auth._initializeWithPersistence(
-      hierarchy,
-      CompatPopupRedirectResolver
-    );
+    this.auth._initializeWithPersistence(hierarchy, resolver);
   }
 
   get emulatorConfig(): compat.EmulatorConfig | null {

packages-exp/auth-compat-exp/test/helpers/helpers.ts

@@ -0,0 +1,58 @@
+/**
+ * @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.
+ */
+
+import * as sinon from 'sinon';
+import firebase from '@firebase/app-compat';
+import '../..';
+
+import * as exp from '@firebase/auth-exp/internal';
+import {
+  getAppConfig,
+  getEmulatorUrl
+} from '../../../auth-exp/test/helpers/integration/settings';
+import { resetEmulator } from '../../../auth-exp/test/helpers/integration/emulator_rest_helpers';
+
+export function initializeTestInstance(): void {
+  firebase.initializeApp(getAppConfig());
+  const stub = stubConsoleToSilenceEmulatorWarnings();
+  firebase.auth().useEmulator(getEmulatorUrl()!);
+  stub.restore();
+}
+
+export async function cleanUpTestInstance(): Promise<void> {
+  for (const app of firebase.apps) {
+    await app.delete();
+  }
+  await resetEmulator();
+}
+
+export function randomEmail(): string {
+  return `${exp._generateEventId('test.email.')}@integration.test`;
+}
+
+function stubConsoleToSilenceEmulatorWarnings(): sinon.SinonStub {
+  const originalConsoleInfo = console.info.bind(console);
+  return sinon.stub(console, 'info').callsFake((...args: unknown[]) => {
+    if (
+      !JSON.stringify(args[0]).includes(
+        'WARNING: You are using the Auth Emulator'
+      )
+    ) {
+      originalConsoleInfo(...args);
+    }
+  });
+}