Add an extremely basic integration test to the SDK (#150)

Robert-Jan Huijsman · web-flow · commit f6712e08136d · 2017-07-10T14:22:52.000-07:00
Add an extremely basic integration test to the SDK, that SDK developers can run against their own Firebase projects to check that all moving parts still work in practice.

Previously, many developers had something like this stashed somewhere on their machine. The hope is that by adding this to the Git repo we'll maintain the integration test in a single place as we add new SDK features.
diff --git a/.gitignore b/.gitignore
@@ -1,11 +1,14 @@
 .idea
-.tmp
 .npm
-npm-debug.log
-lib
-yarn.lock
+.tmp
+.vscode/
 coverage
+firebase-functions-*.tgz
+integration_test/.firebaserc
+integration_test/*.log
+integration_test/functions/firebase-functions.tgz
+lib
 node_modules
+npm-debug.log
 typings
-.vscode/
-firebase-functions-*.tgz
+yarn.lock
diff --git a/.npmignore b/.npmignore
@@ -9,6 +9,7 @@ tslint.*
 # Don't include the raw typescript
 src
 spec
+integration_test
 # TODO(rjh) add back once testing isn't just a joke
 testing
 lib/testing.*
diff --git a/integration_test/README.md b/integration_test/README.md
@@ -0,0 +1,13 @@
+How to Use
+---------
+
+***ATTENTION***: Running this test will wipe the contents of the Firebase project you run it against. Make sure you use a disposable Firebase project!
+
+Run the integration test as follows:
+
+```bash
+firebase use $YOURPROJECTID # add your own project
+./run_tests.sh
+```
+
+Follow the instructions output by the script. You'll click on a number of HTTPS function links.  The integration test for HTTPS is that it properly kicks off other integration tests and redirects you to the database console. From there the other integration test suites will write their results back to the database, where you can check the results.
diff --git a/integration_test/database.rules.json b/integration_test/database.rules.json
@@ -0,0 +1,13 @@
+{
+  "rules": {
+    "dbTests": {
+      "$testId": {
+        "adminOnly": {
+          ".validate": false
+        }
+      }
+    },
+    ".read": "auth != null",
+    ".write": true
+  }
+}
diff --git a/integration_test/firebase.json b/integration_test/firebase.json
@@ -0,0 +1,5 @@
+{
+  "database": {
+    "rules": "database.rules.json"
+  }
+}
diff --git a/integration_test/functions/package.json b/integration_test/functions/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "functions",
+  "description": "Integration test for the Firebase SDK for Google Cloud Functions",
+  "scripts": {
+    "build": "./node_modules/.bin/tsc"
+  },
+  "dependencies": {
+    "@google-cloud/pubsub": "^0.6.0",
+    "@types/lodash": "^4.14.41",
+    "firebase": ">3.6.9",
+    "firebase-admin": ">4.1.1",
+    "firebase-functions": "./firebase-functions.tgz",
+    "loadash": "^0.0.1",
+    "lodash": "^4.17.2"
+  },
+  "main": "lib/index.js",
+  "devDependencies": {
+    "typescript": "^2.0.10"
+  },
+  "private": true
+}
diff --git a/integration_test/functions/src/auth-tests.ts b/integration_test/functions/src/auth-tests.ts
@@ -0,0 +1,52 @@
+import * as functions from 'firebase-functions';
+import { TestSuite, expectEq } from './testing';
+
+export const createUserTests: any = functions.auth.user().onCreate(receivedEvent => {
+  let user = receivedEvent.data;
+  let testId: string = user.displayName;
+  console.log(`testId is ${testId}`);
+
+  return new TestSuite('auth user onCreate')
+    .it('should have a project as resource', event => expectEq(
+      event.resource, `projects/${process.env.GCLOUD_PROJECT}`))
+
+    .it('should not have a path', event => expectEq(event.path, undefined))
+
+    .it('should have the correct eventType', event => expectEq(
+      event.eventType, 'providers/firebase.auth/eventTypes/user.create'))
+
+    .it('should have an eventId', event => event.eventId)
+
+    .it('should have a timestamp', event => event.timestamp)
+
+    .it('should not have auth', event => expectEq(event.auth, undefined))
+
+    .it('should not have action', event => expectEq(event.action, undefined))
+
+    .run(testId, receivedEvent);
+});
+
+export const deleteUserTests: any = functions.auth.user().onDelete(receivedEvent => {
+  let user = receivedEvent.data;
+  let testId: string = user.displayName;
+  console.log(`testId is ${testId}`);
+
+  return new TestSuite('auth user onDelete')
+    .it('should have a project as resource', event => expectEq(
+      event.resource, `projects/${process.env.GCLOUD_PROJECT}`))
+
+    .it('should not have a path', event => expectEq(event.path, undefined))
+
+    .it('should have the correct eventType', event => expectEq(
+      event.eventType, 'providers/firebase.auth/eventTypes/user.delete'))
+
+    .it('should have an eventId', event => event.eventId)
+
+    .it('should have a timestamp', event => event.timestamp)
+
+    .it('should not have auth', event => expectEq(event.auth, undefined))
+
+    .it('should not have action', event => expectEq(event.action, undefined))
+
+    .run(testId, receivedEvent);
+});
diff --git a/integration_test/functions/src/database-tests.ts b/integration_test/functions/src/database-tests.ts
@@ -0,0 +1,51 @@
+import * as functions from 'firebase-functions';
+import { TestSuite, expectReject, expectEq, expectMatches } from './testing';
+
+const testIdFieldName = 'testId';
+
+export const databaseTests: any = functions.database.ref('dbTests/{testId}/start').onWrite(receivedEvent => {
+  if (receivedEvent.data.val() === null) {
+    console.log(
+      'Event for ' + receivedEvent.params[testIdFieldName]
+      + ' is null; presuming data cleanup, so skipping.');
+    return;
+  }
+
+  return new TestSuite('database ref onWrite')
+
+    .it('should not have event.app', event => !event.app)
+
+    .it('should not give user refs access to admin data', expectReject(event =>
+      event.data.ref.parent.child('adminOnly').update({ disallowed: 0 })))
+
+    .it('should give admin refs access to admin data', event =>
+      event.data.adminRef.parent.child('adminOnly').update({ allowed: 1 }).then(() => true))
+
+    .it('should have a correct ref url', event => {
+      const url = event.data.ref.toString();
+      return Promise.resolve().then(() => {
+        return expectMatches(url, new RegExp(`^https://${process.env.GCLOUD_PROJECT}.firebaseio.com/dbTests`));
+      }).then(() => {
+        return expectMatches(url, /\/start$/);
+      });
+    })
+
+    .it('should have refs resources', event => expectEq(
+      event.resource,
+      `projects/_/instances/${process.env.GCLOUD_PROJECT}/refs/dbTests/${event.params.testId}/start`))
+
+    .it('should not include path', event => expectEq(event.path, undefined))
+
+    .it('should have the right eventType', event => expectEq(
+      event.eventType, 'providers/google.firebase.database/eventTypes/ref.write'))
+
+    .it('should have eventId', event => event.eventId)
+
+    .it('should have timestamp', event => event.timestamp)
+
+    .it('should not be admin-authenticated', event => expectEq(event.auth.admin, false))
+
+    .it('should not have action', event => expectEq(event.action, undefined))
+
+    .run(receivedEvent.params[testIdFieldName], receivedEvent);
+});
diff --git a/integration_test/functions/src/index.ts b/integration_test/functions/src/index.ts
@@ -0,0 +1,40 @@
+import * as functions from 'firebase-functions';
+import * as firebase from 'firebase';
+import * as admin from 'firebase-admin';
+import * as _ from 'lodash';
+import { Request, Response } from 'express';
+
+export * from './pubsub-tests';
+export * from './database-tests';
+export * from './auth-tests';
+
+firebase.initializeApp(_.omit(functions.config().firebase, 'credential'));  // Explicitly decline admin privileges.
+admin.initializeApp(functions.config().firebase);
+
+export const integrationTests: any = functions.https.onRequest((req: Request, resp: Response) => {
+  let pubsub: any = require('@google-cloud/pubsub')();
+
+  const testId = firebase.database().ref().push().key;
+
+  Promise.all([
+    // A database write to trigger the Firebase Realtime Database tests.
+    // The database write happens without admin privileges, so that the triggered function's "event.data.ref" also
+    // doesn't have admin privileges.
+    firebase.database().ref(`dbTests/${testId}/start`).set({ '.sv': 'timestamp' }),
+    // A Pub/Sub publish to trigger the Cloud Pub/Sub tests.
+    pubsub.topic('pubsubTests').publish({ testId }),
+    // A user creation to trigger the Firebase Auth user creation tests.
+    admin.auth().createUser({
+      email: `${testId}@fake.com`,
+      password: 'secret',
+      displayName: `${testId}`,
+    }).then(userRecord => {
+      // A user deletion to trigger the Firebase Auth user deletion tests.
+      admin.auth().deleteUser(userRecord.uid);
+    }),
+  ]).then(() => {
+    // On test completion, redirect the user to the Firebase RTDB dashboard, to
+    // see the results stored there.
+    resp.redirect(`https://${process.env.GCLOUD_PROJECT}.firebaseio.com/testRuns/${testId}`);
+  });
+});
diff --git a/integration_test/functions/src/pubsub-tests.ts b/integration_test/functions/src/pubsub-tests.ts
@@ -0,0 +1,41 @@
+import * as functions from 'firebase-functions';
+import { TestSuite, expectEq, evaluate } from './testing';
+
+// TODO(inlined) use multiple queues to run inline.
+// Expected message data: {"hello": "world"}
+export const pubsubTests: any = functions.pubsub.topic('pubsubTests').onPublish(receivedEvent => {
+  let testId: string;
+  try {
+    testId = receivedEvent.data.json.testId;
+  } catch (e) {
+    /* Ignored. Covered in another test case that `event.data.json` works. */
+  }
+
+  return new TestSuite('pubsub onPublish')
+    .it('should have a topic as resource', event => expectEq(
+      event.resource, `projects/${process.env.GCLOUD_PROJECT}/topics/pubsubTests`))
+
+    .it('should not have a path', event => expectEq(event.path, undefined))
+
+    .it('should have the correct eventType', event => expectEq(
+      event.eventType, 'providers/cloud.pubsub/eventTypes/topic.publish'))
+
+    .it('should have an eventId', event => event.eventId)
+
+    .it('should have a timestamp', event => event.timestamp)
+
+    .it('should not have auth', event => expectEq(event.auth, undefined))
+
+    .it('should not have action', event => expectEq(event.action, undefined))
+
+    .it('should have pubsub data', event => {
+      const decoded = (new Buffer(event.data.data, 'base64')).toString();
+      const parsed = JSON.parse(decoded);
+      return evaluate(parsed.hasOwnProperty('testId'), 'Raw data was: ' + event.data.data);
+    })
+
+    .it('should decode JSON payloads with the json helper', event =>
+      evaluate(event.data.json.hasOwnProperty('testId'), event.data.json))
+
+    .run(testId, receivedEvent);
+});
diff --git a/integration_test/functions/src/testing.ts b/integration_test/functions/src/testing.ts
@@ -0,0 +1,87 @@
+import * as firebase from 'firebase-admin';
+
+export type TestCase = (event) => any
+export type TestCaseMap = { [key: string]: TestCase };
+
+export class TestSuite {
+  private name: string;
+  private tests: TestCaseMap;
+
+  constructor(name: string, tests: TestCaseMap = {}) {
+    this.name = name;
+    this.tests = tests;
+  }
+
+  it(name: string, testCase: TestCase): TestSuite {
+    this.tests[name] = testCase;
+    return this;
+  }
+
+  run(testId: string, event): Promise<void> {
+    let running: Array<Promise<any>> = [];
+    for (let testName in this.tests) {
+      if (!this.tests.hasOwnProperty(testName)) { continue; }
+      const run = Promise.resolve()
+        .then(() => this.tests[testName](event))
+        .then(
+        (result) => {
+          console.log(`${result ? 'Passed' : 'Failed with successful op'}: ${testName}`);
+          return { name: testName, passed: !!result };
+        },
+        (error) => {
+          console.error(`Failed: ${testName}`, error);
+          return { name: testName, passed: 0, error: error };
+        }
+        );
+      running.push(run);
+    }
+    return Promise.all(running).then((results) => {
+      let sum = 0;
+      results.forEach((val) => sum = sum + val.passed);
+      const summary = `passed ${sum} of ${running.length}`;
+      console.log(summary);
+      const result = { summary, tests: results };
+      return firebase.database().ref(`testRuns/${testId}/${this.name}`).set(result);
+    }).then(() => null);
+  }
+}
+
+function success() {
+  return Promise.resolve().then(() => true);
+}
+
+function failure(reason: string) {
+  return Promise.reject(reason);
+}
+
+export function evaluate(value, errMsg) {
+  if (value) {
+    return success();
+  }
+  return failure(errMsg);
+}
+
+export function expectEq(left, right) {
+  return evaluate(
+    left === right,
+    JSON.stringify(left) + ' does not equal ' + JSON.stringify(right));
+}
+
+export function expectMatches(input: string, regexp) {
+  return evaluate(
+    input.match(regexp),
+    "Input '" + input + "' did not match regexp '" + regexp + "'");
+}
+
+export function expectReject(f) {
+  return function (event) {
+    return Promise.resolve()
+      .then(() => f(event))
+      .then(
+      () => {
+        throw new Error('Test should have returned a rejected promise');
+      },
+      () => true, // A rejection is what we expected, and so is a positive result.
+    );
+  };
+}
diff --git a/integration_test/functions/tsconfig.json b/integration_test/functions/tsconfig.json
@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "es6",
+      "es2015.promise"
+    ],
+    "module": "commonjs",
+    "target": "es6",
+    "noImplicitAny": false,
+    "outDir": "lib",
+    "declaration": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ]
+  },
+  "files": [
+    "src/index.ts"
+  ]
+}
diff --git a/integration_test/run_tests.sh b/integration_test/run_tests.sh
diff --git a/package.json b/package.json
diff --git a/src/providers/analytics.ts b/src/providers/analytics.ts

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +{
 +  "database": {
 +    "rules": "database.rules.json"
 +  }
 +}