Migrate testing to component framework

Author: Feiyang1

packages/testing/src/api/index.ts

@@ -16,12 +16,15 @@
  */
 
 import * as firebase from 'firebase';
+import { _FirebaseApp } from '@firebase/app-types/private';
+import { FirebaseAuthInternal } from '@firebase/auth-interop-types';
 import * as request from 'request';
 import { base64 } from '@firebase/util';
 import { setLogLevel, LogLevel } from '@firebase/logger';
 import * as grpc from 'grpc';
 import * as protoLoader from '@grpc/proto-loader';
 import { resolve } from 'path';
+import { Component, ComponentType } from '@firebase/component';
 
 export { database, firestore } from 'firebase';
 
@@ -126,8 +129,18 @@ function initializeApp(
   let app = firebase.initializeApp(appOptions, appName);
   // hijacking INTERNAL.getToken to bypass FirebaseAuth and allows specifying of auth headers
   if (accessToken) {
-    (app as any).INTERNAL.getToken = () =>
-      Promise.resolve({ accessToken: accessToken });
+    const mockAuthComponent = new Component(
+      'auth-internal',
+      () => ({
+        getToken: () => Promise.resolve({ accessToken: accessToken }),
+        getUid: () => null,
+        addAuthTokenListener: () => { },
+        removeAuthTokenListener: () => { }
+      }) as FirebaseAuthInternal,
+      ComponentType.PRIVATE
+    );
+
+    (app as unknown as _FirebaseApp)._addComponent(mockAuthComponent,/* overwrite */ true);
   }
   if (databaseName) {
     // Toggle network connectivity to force a reauthentication attempt.

packages/testing/test/database.test.ts

@@ -19,15 +19,16 @@ import * as chai from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
 import * as firebase from '../src/api';
 import { base64 } from '@firebase/util';
+import { _FirebaseApp } from '@firebase/app-types/private';
 
 const expect = chai.expect;
 
 before(() => {
   chai.use(chaiAsPromised);
 });
 
-describe('Testing Module Tests', function() {
-  it('assertSucceeds() iff success', async function() {
+describe('Testing Module Tests', function () {
+  it('assertSucceeds() iff success', async function () {
     const success = Promise.resolve('success');
     const failure = Promise.reject('failure');
     await firebase.assertSucceeds(success).catch(() => {
@@ -38,55 +39,64 @@ describe('Testing Module Tests', function() {
       .then(() => {
         throw new Error('Expected failure to fail.');
       })
-      .catch(() => {});
+      .catch(() => { });
   });
 
-  it('assertFails() iff failure', async function() {
+  it('assertFails() iff failure', async function () {
     const success = Promise.resolve('success');
     const failure = Promise.reject('failure');
     await firebase
       .assertFails(success)
       .then(() => {
         throw new Error('Expected success to fail.');
       })
-      .catch(() => {});
+      .catch(() => { });
     await firebase.assertFails(failure).catch(() => {
       throw new Error('Expected failure to succeed.');
     });
   });
 
-  it('initializeTestApp() with auth=null does not set access token', async function() {
+  it('initializeTestApp() with auth=null does not set access token', async function () {
     const app = firebase.initializeTestApp({
       projectId: 'foo',
       auth: undefined
     });
-    const token = await (app as any).INTERNAL.getToken();
-    expect(token).to.be.null;
+
+    const authInternal = (app as unknown as _FirebaseApp)
+      .container.getProvider('auth-internal').getImmediate({ optional: true });
+    // Auth instance will not be available because no API Key is provided 
+    expect(authInternal).to.be.null;
   });
 
-  it('initializeTestApp() with auth sets the correct access token', async function() {
+  it('initializeTestApp() with auth sets the correct access token', async function () {
     const auth = { uid: 'alice' };
     const app = firebase.initializeTestApp({
       projectId: 'foo',
       auth: auth
     });
-    const token = await (app as any).INTERNAL.getToken();
+    const authInternal = (app as unknown as _FirebaseApp)
+      .container.getProvider('auth-internal').getImmediate();
+
+    const token = await authInternal.getToken();
     expect(token).to.have.keys('accessToken');
     const claims = JSON.parse(
-      base64.decodeString(token.accessToken.split('.')[1], /*webSafe=*/ false)
+      base64.decodeString(token!.accessToken.split('.')[1], /*webSafe=*/ false)
     );
     // We add an 'iat' field.
     expect(claims).to.deep.equal({ uid: auth.uid, iat: 0, sub: auth.uid });
   });
 
-  it('initializeAdminApp() sets the access token to "owner"', async function() {
+  it('initializeAdminApp() sets the access token to "owner"', async function () {
     const app = firebase.initializeAdminApp({ projectId: 'foo' });
-    const token = await (app as any).INTERNAL.getToken();
+    const authInternal = (app as unknown as _FirebaseApp)
+      .container.getProvider('auth-internal').getImmediate();
+
+    const token = await authInternal.getToken();
     expect(token).to.have.keys('accessToken');
-    expect(token.accessToken).to.be.string('owner');
+    expect(token!.accessToken).to.be.string('owner');
   });
 
-  it('loadDatabaseRules() throws if no databaseName or rules', async function() {
+  it('loadDatabaseRules() throws if no databaseName or rules', async function () {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     await expect((firebase as any).loadDatabaseRules.bind(null, {})).to.throw(
       /databaseName not specified/
@@ -101,13 +111,13 @@ describe('Testing Module Tests', function() {
     ).to.throw(/databaseName not specified/);
   });
 
-  it('loadDatabaseRules() tries to make a network request', async function() {
+  it('loadDatabaseRules() tries to make a network request', async function () {
     await expect(
       firebase.loadDatabaseRules({ databaseName: 'foo', rules: '{}' })
     ).to.be.rejectedWith(/ECONNREFUSED/);
   });
 
-  it('loadFirestoreRules() succeeds on valid input', async function() {
+  it('loadFirestoreRules() succeeds on valid input', async function () {
     let promise = firebase.loadFirestoreRules({
       projectId: 'foo',
       rules: `service cloud.firestore {
@@ -119,28 +129,28 @@ describe('Testing Module Tests', function() {
     await expect(promise).to.be.rejectedWith(/UNAVAILABLE/);
   });
 
-  it('clearFirestoreData() succeeds on valid input', async function() {
+  it('clearFirestoreData() succeeds on valid input', async function () {
     let promise = firebase.clearFirestoreData({
       projectId: 'foo'
     });
     await expect(promise).to.be.rejectedWith(/UNAVAILABLE/);
   });
 
-  it('apps() returns apps created with initializeTestApp', async function() {
+  it('apps() returns apps created with initializeTestApp', async function () {
     const numApps = firebase.apps().length;
     await firebase.initializeTestApp({ databaseName: 'foo', auth: undefined });
     expect(firebase.apps().length).to.equal(numApps + 1);
     await firebase.initializeTestApp({ databaseName: 'bar', auth: undefined });
     expect(firebase.apps().length).to.equal(numApps + 2);
   });
 
-  it('there is a way to get database timestamps', function() {
+  it('there is a way to get database timestamps', function () {
     expect(firebase.database.ServerValue.TIMESTAMP).to.deep.equal({
       '.sv': 'timestamp'
     });
   });
 
-  it('there is a way to get firestore timestamps', function() {
+  it('there is a way to get firestore timestamps', function () {
     expect(firebase.firestore.FieldValue.serverTimestamp()).not.to.be.null;
   });
 });