Add integration testing framework to auth compat, plus the auth test ported over

Author: sam-gc

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

@@ -24,13 +24,13 @@ 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 +44,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 +102,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",
+    "test:integration": "run-s test:browser:integration test:node:integration"
   },
   "peerDependencies": {
     "@firebase/app-compat": "0.x"

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

@@ -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.
+ */
+
+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/test/helpers/helpers.ts

@@ -0,0 +1,36 @@
+import * as sinon from 'sinon';
+import firebase from '@firebase/app-compat';
+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);
+    }
+  });
+}

packages-exp/auth-compat-exp/test/integration/flows/anonymous.test.ts

@@ -0,0 +1,117 @@
+/**
+ * @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 { expect, use } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+
+
+import firebase from '@firebase/app-compat';
+import '@firebase/auth-compat';
+import { FirebaseError } from '@firebase/util';
+import { cleanUpTestInstance, initializeTestInstance, randomEmail } from '../../helpers/helpers';
+
+use(chaiAsPromised);
+
+describe('Integration test: anonymous auth', () => {
+  beforeEach(() => {
+    initializeTestInstance();
+  });
+
+  afterEach(async () => {
+    await cleanUpTestInstance();
+  });
+
+  it('signs in anonymously', async () => {
+    const userCred = await firebase.auth().signInAnonymously();
+    expect(firebase.auth().currentUser).to.eq(userCred.user);
+    expect(userCred.operationType).to.eq('signIn');
+
+    const user = userCred.user!;
+    expect(user.isAnonymous).to.be.true;
+    expect(user.uid).to.be.a('string');
+  });
+
+  it('second sign in on the same device yields same user', async () => {
+    const { user: userA } = await firebase.auth().signInAnonymously();
+    const { user: userB } = await firebase.auth().signInAnonymously();
+
+    expect(userA!.uid).to.eq(userB!.uid);
+  });
+
+  context('email/password interaction', () => {
+    let email: string;
+
+    beforeEach(() => {
+      email = randomEmail();
+    });
+
+    it('anonymous / email-password accounts remain independent', async () => {
+      let anonCred = await firebase.auth().signInAnonymously();
+      const emailCred = await firebase.auth().createUserWithEmailAndPassword(
+        email,
+        'password'
+      );
+      expect(emailCred.user!.uid).not.to.eql(anonCred.user!.uid);
+
+      await firebase.auth().signOut();
+      anonCred = await firebase.auth().signInAnonymously();
+      const emailSignIn =  await firebase.auth().signInWithEmailAndPassword(
+        email,
+        'password'
+      );
+      expect(emailCred.user!.uid).to.eql(emailSignIn.user!.uid);
+      expect(emailSignIn.user!.uid).not.to.eql(anonCred.user!.uid);
+    });
+
+    it('account can be upgraded by setting email and password', async () => {
+      const { user: anonUser } = await firebase.auth().signInAnonymously();
+      await anonUser!.updateEmail(email);
+      await anonUser!.updatePassword('password');
+
+      await firebase.auth().signOut();
+
+      const { user: emailPassUser } = await firebase.auth().signInWithEmailAndPassword(
+        email,
+        'password'
+      );
+      expect(emailPassUser!.uid).to.eq(anonUser!.uid);
+    });
+
+    it('account can be linked using email and password', async () => {
+      const { user: anonUser } = await firebase.auth().signInAnonymously();
+      const cred = firebase.auth.EmailAuthProvider.credential(email, 'password');
+      await anonUser!.linkWithCredential(cred);
+      await firebase.auth().signOut();
+
+      const { user: emailPassUser } = await firebase.auth().signInWithEmailAndPassword(
+        email,
+        'password'
+      );
+      expect(emailPassUser!.uid).to.eq(anonUser!.uid);
+    });
+
+    it('account cannot be linked with existing email/password', async () => {
+      await firebase.auth().createUserWithEmailAndPassword(email, 'password');
+      const { user: anonUser } = await firebase.auth().signInAnonymously();
+      const cred = firebase.auth.EmailAuthProvider.credential(email, 'password');
+      await expect(anonUser!.linkWithCredential(cred)).to.be.rejectedWith(
+        FirebaseError,
+        'auth/email-already-in-use'
+      );
+    });
+  });
+});