firebase-functions/handler SDK (#219)

* crashlytics

* remove unnecessary import

* throwing error if context.params accessed

* reworded and removed unnecessary tests

* initial commit

* firestore unit tests

* remove unnecessary imports

* reworded tests

* https and database providers for firebase-functions/handler sdk (#222)

https and database providers and tests for firebase-functions/handler sdk

* auth, pubsub, storage, and analytics providers for firebase-functions/handler sdk (#224)

auth, pubsub, storage, and analytics providers

* remote config provider for firebase-functions/handler SDK (#223)

* remote config provider and unit tests

Author: tinaliang

spec/cloud-functions.spec.ts

@@ -158,6 +158,39 @@ describe('makeCloudFunction', () => {
       },
     });
   });
+
+  it('should throw error when context.params accessed in handler environment', () => {
+    let args: any = _.assign({}, cloudFunctionArgs, {
+      handler: (data: any, context: EventContext) => context,
+      triggerResource: () => null,
+    });
+    let cf = makeCloudFunction(args);
+    let test: Event = {
+      context: {
+        eventId: '00000',
+        timestamp: '2016-11-04T21:29:03.496Z',
+        eventType: 'provider.event',
+        resource: {
+          service: 'provider',
+          name: 'resource',
+        },
+      },
+      data: 'test data',
+    };
+
+    return cf(test).then(result => {
+      expect(result).to.deep.equal({
+        eventId: '00000',
+        timestamp: '2016-11-04T21:29:03.496Z',
+        eventType: 'provider.event',
+        resource: {
+          service: 'provider',
+          name: 'resource',
+        },
+      });
+      expect(() => result.params).to.throw(Error);
+    });
+  });
 });
 
 describe('makeParams', () => {

spec/providers/analytics.spec.ts

@@ -249,6 +249,44 @@ describe('Analytics Functions', () => {
     });
   });
 
+  describe('handler namespace', () => {
+    describe('#onLog', () => {
+      it('should return an empty trigger', () => {
+        const cloudFunction = functions.handler.analytics.event.onLog(
+          () => null
+        );
+        expect(cloudFunction.__trigger).to.deep.equal({});
+      });
+
+      it('should handle an event with the appropriate fields', () => {
+        const cloudFunction = functions.handler.analytics.event.onLog(
+          (data: analytics.AnalyticsEvent) => data
+        );
+
+        // The event data delivered over the wire will be the JSON for an AnalyticsEvent:
+        // https://firebase.google.com/docs/auth/admin/manage-users#retrieve_user_data
+        let event: LegacyEvent = {
+          eventId: 'f2e2f0bf-2e47-4d92-b009-e7a375ecbd3e',
+          eventType: 'providers/google.firebase.analytics/eventTypes/event.log',
+          resource: 'projects/myUnitTestProject/events/first_open',
+          data: {
+            userDim: {
+              userId: 'hi!',
+            },
+          },
+        };
+
+        return expect(cloudFunction(event)).to.eventually.deep.equal({
+          params: {},
+          user: {
+            userId: 'hi!',
+            userProperties: {},
+          },
+        });
+      });
+    });
+  });
+
   describe('process.env.GCLOUD_PROJECT not set', () => {
     it('should not throw if __trigger is not accessed', () => {
       expect(() => analytics.event('event').onLog(() => null)).to.not.throw(

spec/providers/auth.spec.ts

@@ -201,6 +201,115 @@ describe('Auth Functions', () => {
     });
   });
 
+  describe('handler namespace', () => {
+    describe('#onCreate', () => {
+      let cloudFunctionCreate: CloudFunction<
+        firebase.auth.UserRecord
+      > = functions.handler.auth.user.onCreate(
+        (data: firebase.auth.UserRecord) => data
+      );
+
+      it('should return an empty trigger', () => {
+        const cloudFunction = functions.handler.auth.user.onCreate(() => null);
+        expect(cloudFunction.__trigger).to.deep.equal({});
+      });
+
+      it('should transform wire format for UserRecord into v5.0.0 format', () => {
+        const event = {
+          data: {
+            metadata: {
+              createdAt: '2016-12-15T19:37:37.059Z',
+              lastSignedInAt: '2017-01-01T00:00:00.000Z',
+            },
+          },
+        };
+
+        return cloudFunctionCreate(event).then((data: any) => {
+          expect(data.metadata.creationTime).to.equal(
+            '2016-12-15T19:37:37.059Z'
+          );
+          expect(data.metadata.lastSignInTime).to.equal(
+            '2017-01-01T00:00:00.000Z'
+          );
+        });
+      });
+
+      it('should handle new wire format if/when there is a change', () => {
+        const newEvent = {
+          data: {
+            metadata: {
+              creationTime: '2016-12-15T19:37:37.059Z',
+              lastSignInTime: '2017-01-01T00:00:00.000Z',
+            },
+          },
+        };
+
+        return cloudFunctionCreate(newEvent).then((data: any) => {
+          expect(data.metadata.creationTime).to.equal(
+            '2016-12-15T19:37:37.059Z'
+          );
+          expect(data.metadata.lastSignInTime).to.equal(
+            '2017-01-01T00:00:00.000Z'
+          );
+        });
+      });
+    });
+
+    describe('#onDelete', () => {
+      let cloudFunctionDelete: CloudFunction<
+        firebase.auth.UserRecord
+      > = functions.handler.auth.user.onDelete(
+        (data: firebase.auth.UserRecord) => data
+      );
+
+      it('should return an empty trigger', () => {
+        let handler: (user: firebase.auth.UserRecord) => PromiseLike<any> | any;
+        const cloudFunction = functions.handler.auth.user.onDelete(handler);
+        expect(cloudFunction.__trigger).to.deep.equal({});
+      });
+
+      it('should transform wire format for UserRecord into v5.0.0 format', () => {
+        const event = {
+          data: {
+            metadata: {
+              createdAt: '2016-12-15T19:37:37.059Z',
+              lastSignedInAt: '2017-01-01T00:00:00.000Z',
+            },
+          },
+        };
+
+        return cloudFunctionDelete(event).then((data: any) => {
+          expect(data.metadata.creationTime).to.equal(
+            '2016-12-15T19:37:37.059Z'
+          );
+          expect(data.metadata.lastSignInTime).to.equal(
+            '2017-01-01T00:00:00.000Z'
+          );
+        });
+      });
+
+      it('should handle new wire format if/when there is a change', () => {
+        const newEvent = {
+          data: {
+            metadata: {
+              creationTime: '2016-12-15T19:37:37.059Z',
+              lastSignInTime: '2017-01-01T00:00:00.000Z',
+            },
+          },
+        };
+
+        return cloudFunctionDelete(newEvent).then((data: any) => {
+          expect(data.metadata.creationTime).to.equal(
+            '2016-12-15T19:37:37.059Z'
+          );
+          expect(data.metadata.lastSignInTime).to.equal(
+            '2017-01-01T00:00:00.000Z'
+          );
+        });
+      });
+    });
+  });
+
   describe('process.env.GCLOUD_PROJECT not set', () => {
     it('should not throw if __trigger is not accessed', () => {
       expect(() => auth.user().onCreate(() => null)).to.not.throw(Error);

spec/providers/crashlytics.spec.ts

@@ -93,6 +93,59 @@ describe('Crashlytics Functions', () => {
         });
       });
     });
+
+    describe('HandlerBuilder', () => {
+      const testIssue = {
+        issueId: '1234',
+        issueTitle: 'testIssue',
+        appInfo: {
+          appName: 'My Awesome Test App',
+          appPlatform: 'ios',
+          appId: '9876',
+          latestAppVersion: '1.2.3.4',
+        },
+        createTime: '2018-12-18T23:05:55+00:00',
+      };
+
+      describe('#onNew', () => {
+        it('should return a CloudFunction with appropriate values', () => {
+          const cloudFunction = functions.handler.crashlytics.issue.onNew(
+            testIssue => {
+              return (
+                testIssue.issueId + testIssue.issueTitle + testIssue.createTime
+              );
+            }
+          );
+          expect(cloudFunction.__trigger).to.deep.equal({});
+        });
+      });
+
+      describe('#onRegressed', () => {
+        it('should return a CloudFunction with appropriate values', () => {
+          const cloudFunction = functions.handler.crashlytics.issue.onRegressed(
+            testIssue => {
+              return (
+                testIssue.issueId + testIssue.issueTitle + testIssue.createTime
+              );
+            }
+          );
+          expect(cloudFunction.__trigger).to.deep.equal({});
+        });
+      });
+
+      describe('#onVelocityAlert', () => {
+        it('should return a CloudFunction with appropriate values', () => {
+          const cloudFunction = functions.handler.crashlytics.issue.onVelocityAlert(
+            testIssue => {
+              return (
+                testIssue.issueId + testIssue.issueTitle + testIssue.createTime
+              );
+            }
+          );
+          expect(cloudFunction.__trigger).to.deep.equal({});
+        });
+      });
+    });
   });
 
   describe('process.env.GCLOUD_PROJECT not set', () => {

spec/providers/database.spec.ts

@@ -218,6 +218,116 @@ describe('Database Functions', () => {
     });
   });
 
+  describe('handler namespace', () => {
+    describe('#onWrite()', () => {
+      it('correctly sets trigger to {}', () => {
+        let cf = functions.handler.database.ref.onWrite(() => null);
+        expect(cf.__trigger).to.deep.equal({});
+      });
+
+      it('should be able to use the instance entry point', () => {
+        let func = functions.handler.database.instance.ref.onWrite(() => null);
+        expect(func.__trigger).to.deep.equal({});
+      });
+
+      it('should return a handler that emits events with a proper DataSnapshot', () => {
+        let handler = functions.handler.database.ref.onWrite(change => {
+          return expect(change.after.val()).to.deep.equal({ foo: 'bar' });
+        });
+
+        return handler({
+          data: {
+            data: null,
+            delta: { foo: 'bar' },
+          },
+          resource: 'projects/_/instances/subdomains/refs/users',
+          eventType: 'providers/google.firebase.database/eventTypes/ref.write',
+        });
+      });
+    });
+
+    describe('#onCreate()', () => {
+      it('correctly sets trigger to {}', () => {
+        let cf = functions.handler.database.ref.onCreate(() => null);
+        return expect(cf.__trigger).to.deep.equal({});
+      });
+
+      it('should be able to use the instance entry point', () => {
+        let func = functions.handler.database.instance.ref.onCreate(() => null);
+        expect(func.__trigger).to.deep.equal({});
+      });
+
+      it('should return a handler that emits events with a proper DataSnapshot', () => {
+        let handler = functions.handler.database.ref.onCreate(data => {
+          return expect(data.val()).to.deep.equal({ foo: 'bar' });
+        });
+
+        return handler({
+          data: {
+            data: null,
+            delta: { foo: 'bar' },
+          },
+          resource: 'projects/_/instances/subdomains/refs/users',
+          eventType: 'providers/google.firebase.database/eventTypes/ref.create',
+        });
+      });
+    });
+
+    describe('#onUpdate()', () => {
+      it('correctly sets trigger to {}', () => {
+        let cf = functions.handler.database.ref.onUpdate(() => null);
+        return expect(cf.__trigger).to.deep.equal({});
+      });
+
+      it('should be able to use the instance entry point', () => {
+        let func = functions.handler.database.instance.ref.onUpdate(() => null);
+        expect(func.__trigger).to.deep.equal({});
+      });
+
+      it('should return a handler that emits events with a proper DataSnapshot', () => {
+        let handler = functions.handler.database.ref.onUpdate(change => {
+          return expect(change.after.val()).to.deep.equal({ foo: 'bar' });
+        });
+
+        return handler({
+          data: {
+            data: null,
+            delta: { foo: 'bar' },
+          },
+          resource: 'projects/_/instances/subdomains/refs/users',
+          eventType: 'providers/google.firebase.database/eventTypes/ref.update',
+        });
+      });
+    });
+
+    describe('#onDelete()', () => {
+      it('correctly sets trigger to {}', () => {
+        let cf = functions.handler.database.ref.onDelete(() => null);
+        return expect(cf.__trigger).to.deep.equal({});
+      });
+
+      it('should be able to use the instance entry point', () => {
+        let func = functions.handler.database.instance.ref.onDelete(() => null);
+        expect(func.__trigger).to.deep.equal({});
+      });
+
+      it('should return a handler that emits events with a proper DataSnapshot', () => {
+        let handler = functions.handler.database.ref.onDelete(data => {
+          return expect(data.val()).to.deep.equal({ foo: 'bar' });
+        });
+
+        return handler({
+          data: {
+            data: { foo: 'bar' },
+            delta: null,
+          },
+          resource: 'projects/_/instances/subdomains/refs/users',
+          eventType: 'providers/google.firebase.database/eventTypes/ref.delete',
+        });
+      });
+    });
+  });
+
   describe('process.env.FIREBASE_CONFIG not set', () => {
     it('should not throw if __trigger is not accessed', () => {
       expect(() => database.ref('/path').onWrite(() => null)).to.not.throw(