Support for scheduled functions

Author: rhodgkins

spec/index.spec.ts

@@ -63,6 +63,7 @@ import './lifecycle.spec';
 import './main.spec';
 import './app.spec';
 import './providers/https.spec';
+import './providers/scheduled.spec';
 // import './providers/analytics.spec';
 // import './providers/auth.spec';
 // import './providers/database.spec';

spec/providers/scheduled.spec.ts

@@ -0,0 +1,42 @@
+import * as sinon from 'sinon';
+import * as functions from 'firebase-functions';
+import fft = require('../../src/index');
+import { WrappedScheduledFunction } from '../../src/main';
+
+describe('providers/scheduled', () => {
+
+   const fakeFn = sinon.fake.resolves();
+   const scheduledFunc = functions.pubsub.schedule('every 2 hours').onRun(fakeFn);
+
+   const emptyObjectMatcher = sinon.match((v) => sinon.match.object.test(v) && Object.keys(v).length === 0);
+
+   afterEach(() => {
+      fakeFn.resetHistory();
+   });
+
+   it('should run the wrapped function with generated context', async () => {
+      const test = fft();
+      const fn: WrappedScheduledFunction = test.wrap(scheduledFunc);
+      await fn();
+      // Function should only be called with 1 argument
+      sinon.assert.calledOnce(fakeFn);
+      sinon.assert.calledWithExactly(fakeFn, sinon.match({
+         eventType: sinon.match.string,
+         timestamp: sinon.match.string,
+         params: emptyObjectMatcher,
+      }));
+   });
+
+   it('should run the wrapped function with provided context', async () => {
+      const timestamp = new Date().toISOString();
+      const test = fft();
+      const fn: WrappedScheduledFunction = test.wrap(scheduledFunc);
+      await fn({ timestamp });
+      sinon.assert.calledOnce(fakeFn);
+      sinon.assert.calledWithExactly(fakeFn, sinon.match({
+         eventType: sinon.match.string,
+         timestamp,
+         params: emptyObjectMatcher,
+      }));
+   });
+});

src/main.ts

@@ -65,12 +65,45 @@ export type ContextOptions = EventContextOptions | CallableContextOptions;
  */
 export type WrappedFunction = (data: any, options?: ContextOptions) => any | Promise<any>;
 
+/** A scheduled function that can be called with optional override values for the event context.
+ * It will subsequently invoke the cloud function it wraps with a generated event context.
+ */
+export type WrappedScheduledFunction = (options?: ContextOptions) => any | Promise<any>;
+
 /** Takes a cloud function to be tested, and returns a WrappedFunction which can be called in test code. */
-export function wrap<T>(cloudFunction: CloudFunction<T>): WrappedFunction {
+export function wrap<T>(cloudFunction: CloudFunction<T>): WrappedScheduledFunction | WrappedFunction {
   if (!has(cloudFunction, '__trigger')) {
     throw new Error('Wrap can only be called on functions written with the firebase-functions SDK.');
   }
 
+  if (get(cloudFunction, '__trigger.labels.deployment-scheduled') === 'true') {
+    const scheduledWrapped: WrappedScheduledFunction = (options: ContextOptions) => {
+      // Although in Typescript we require `options` some of our JS samples do not pass it.
+      options = options || {};
+
+      _checkOptionValidity(['eventId', 'timestamp'], options);
+      let eventContextOptions = options as EventContextOptions;
+      const defaultContext: EventContext = {
+        eventId: _makeEventId(),
+        resource: cloudFunction.__trigger.eventTrigger && {
+          service: cloudFunction.__trigger.eventTrigger.service,
+          name: _makeResourceName(
+            cloudFunction.__trigger.eventTrigger.resource,
+            has(eventContextOptions, 'params') && eventContextOptions.params,
+          ),
+        },
+        eventType: get(cloudFunction, '__trigger.eventTrigger.eventType'),
+        timestamp: (new Date()).toISOString(),
+        params: {},
+      };
+      const context = merge({}, defaultContext, eventContextOptions);
+
+      // @ts-ignore
+      return cloudFunction.run(context);
+    };
+    return scheduledWrapped;
+  }
+
   if (has(cloudFunction, '__trigger.httpsTrigger') &&
       (get(cloudFunction, '__trigger.labels.deployment-callable') !== 'true')) {
     throw new Error('Wrap function is only available for `onCall` HTTP functions, not `onRequest`.');