Enable firestore sdk to talk to emulator

packages/testing/index.ts

@@ -26,5 +26,6 @@ export {
   assertSucceeds,
   initializeAdminApp,
   initializeTestApp,
+  initializeFirestoreTestApp,
   loadDatabaseRules
 } from './src/api';

packages/testing/src/api/index.ts

@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 
+import { firebase } from '@firebase/app';
 import * as admin from 'firebase-admin';
 import request from 'request-promise';
 import * as fs from 'fs';
+import { FirebaseApp } from '@firebase/app-types';
+import { base64 } from '@firebase/util';
 
 const DBURL = 'http://localhost:9000';
 
@@ -36,6 +39,10 @@ export function apps(): (admin.app.App | null)[] {
   return admin.apps;
 }
 
+export function firestoreApps(): (FirebaseApp | null)[] {
+  return firebase.apps;
+}
+
 export function initializeAdminApp(options: any): admin.app.App {
   if (!('databaseName' in options)) {
     throw new Error('databaseName not specified');
@@ -49,10 +56,11 @@ export function initializeAdminApp(options: any): admin.app.App {
   );
 }
 
-export function initializeTestApp(options: any): admin.app.App {
-  if (!('databaseName' in options)) {
-    throw new Error('databaseName not specified');
-  }
+export type TestAppOptions = {
+  databaseName: string;
+  auth: Object;
+};
+export function initializeTestApp(options: TestAppOptions): admin.app.App {
   // if options.auth is not present, we will construct an app with auth == null
   return admin.initializeApp(
     {
@@ -64,6 +72,32 @@ export function initializeTestApp(options: any): admin.app.App {
   );
 }
 
+export type FirestoreTestAppOptions = {
+  projectId: string;
+  auth: Object;
+};
+export function initializeFirestoreTestApp(
+  options: FirestoreTestAppOptions
+): FirebaseApp {
+  const header = {
+    alg: 'RS256',
+    kid: 'fakekid'
+  };
+  const fakeToken = [
+    base64.encodeString(JSON.stringify(header), /*webSafe=*/ false),
+    base64.encodeString(JSON.stringify(options.auth), /*webSafe=*/ false),
+    'fakesignature'
+  ].join('.');
+  const app = firebase.initializeApp(
+    { projectId: options.projectId },
+    'app-' + new Date().getTime() + '-' + Math.random()
+  );
+  // hijacking INTERNAL.getToken to bypass FirebaseAuth and allows specifying of auth headers
+  (app as any).INTERNAL.getToken = () =>
+    Promise.resolve({ accessToken: fakeToken });
+  return app;
+}
+
 export type LoadDatabaseRulesOptions = {
   databaseName: String;
   rules: String;

packages/testing/test/database.test.ts

@@ -16,6 +16,7 @@
 
 import { expect } from 'chai';
 import * as firebase from '../src/api';
+import { base64 } from '@firebase/util';
 
 describe('Testing Module Tests', function() {
   it('assertSucceeds() iff success', async function() {
@@ -60,17 +61,8 @@ describe('Testing Module Tests', function() {
     expect(app.options).to.not.have.any.keys('databaseAuthVariableOverride');
   });
 
-  it('initializeTestApp() throws if no databaseName', function() {
-    expect(firebase.initializeTestApp.bind(null, {})).to.throw(
-      /databaseName not specified/
-    );
-    expect(
-      firebase.initializeTestApp.bind(null, { databaseName: 'foo' })
-    ).to.not.throw();
-  });
-
   it('initializeTestApp() uses specified auth.', function() {
-    let app = firebase.initializeTestApp({ databaseName: 'foo' });
+    let app = firebase.initializeTestApp({ databaseName: 'foo', auth: {} });
     expect(app.options).to.have.any.keys('databaseAuthVariableOverride');
 
     app = firebase.initializeTestApp({
@@ -84,6 +76,32 @@ describe('Testing Module Tests', function() {
     );
   });
 
+  it('initializeFirestoreTestApp() uses specified auth.', async function() {
+    let app = firebase.initializeFirestoreTestApp({
+      projectId: 'foo',
+      auth: {}
+    });
+    let token = await (app as any).INTERNAL.getToken();
+    expect(token).to.have.any.keys('accessToken');
+    let claims = base64.decodeString(
+      token.accessToken.split('.')[1],
+      /*webSafe=*/ false
+    );
+    expect(claims).to.equal('{}');
+
+    app = firebase.initializeFirestoreTestApp({
+      projectId: 'foo',
+      auth: { uid: 'alice' }
+    });
+    token = await (app as any).INTERNAL.getToken();
+    expect(token).to.have.any.keys('accessToken');
+    claims = base64.decodeString(
+      token.accessToken.split('.')[1],
+      /*webSafe=*/ false
+    );
+    expect(claims).to.equal('{"uid":"alice"}');
+  });
+
   it('loadDatabaseRules() throws if no databaseName or rulesPath', async function() {
     expect(firebase.loadDatabaseRules.bind(null, {})).to.throw(
       /databaseName not specified/
@@ -108,13 +126,27 @@ describe('Testing Module Tests', function() {
     ).to.throw(/Could not find file/);
   });
 
-  it('apps() returns all created apps', async function() {
+  it('apps() returns all apps created except by initializeFirestoreTestApp', async function() {
     const numApps = firebase.apps().length;
     await firebase.initializeAdminApp({ databaseName: 'foo' });
     expect(firebase.apps().length).to.equal(numApps + 1);
     await firebase.initializeAdminApp({ databaseName: 'foo' });
     expect(firebase.apps().length).to.equal(numApps + 2);
-    await firebase.initializeTestApp({ databaseName: 'foo' });
+    await firebase.initializeTestApp({ databaseName: 'foo', auth: {} });
+    expect(firebase.apps().length).to.equal(numApps + 3);
+    await firebase.initializeFirestoreTestApp({ projectId: 'foo', auth: {} });
     expect(firebase.apps().length).to.equal(numApps + 3);
   });
+
+  it('firestoreApps() returns only apps created with initializeFirestoreTestApp', async function() {
+    const numApps = firebase.firestoreApps().length;
+    await firebase.initializeAdminApp({ databaseName: 'foo' });
+    expect(firebase.firestoreApps().length).to.equal(numApps + 0);
+    await firebase.initializeAdminApp({ databaseName: 'foo' });
+    expect(firebase.firestoreApps().length).to.equal(numApps + 0);
+    await firebase.initializeTestApp({ databaseName: 'foo', auth: {} });
+    expect(firebase.firestoreApps().length).to.equal(numApps + 0);
+    await firebase.initializeFirestoreTestApp({ projectId: 'foo', auth: {} });
+    expect(firebase.firestoreApps().length).to.equal(numApps + 1);
+  });
 });