Merge pull request #43 from raman-nbg/messaging

Author: dmurvihill

API.md

@@ -19,6 +19,10 @@ Only `MockFirebase` methods are included here. For details on normal Firebase AP
 - [Server Timestamps](#server-timestamps)
   - [`setClock(fn)`](#firebasesetclockfn---undefined)
   - [`restoreClock()`](#firebasesetclockfn---undefined)
+- [Messaging](#messaging)
+  - [`respondNext(methodName, result)`](#respondnextmethodname-result---undefined)
+  - [`failNext(methodName, err)`](#failnextmethodname-err---undefined)
+  - [`on(methodName, callback)`](#onmethodname-callback---undefined)
 
 ## Core
 
@@ -242,3 +246,31 @@ Instead of using `Date.now()`, MockFirebase will call the `fn` you provide to ge
 ##### `Firebase.restoreClock()` -> `undefined`
 
 After calling `Firebase.setClock`, calling `Firebase.restoreClock` will restore the default timestamp behavior.
+
+## Messaging
+
+API reference of `MockMessaging`.
+
+##### `respondNext(methodName, result)` -> `undefined`
+
+When `methodName` is next invoked, the `Promise` (that is returned from the `methodName`) will be resolved with the specified `result`. This is useful for testing specific results of firebase messaging (e. g. partial success of sending messaging). The result will be triggered with the next `flush`.
+
+If no result is specified, `methodName` will resolve a default response.
+
+`result` must not be undefined.
+
+<hr>
+
+##### `failNext(methodName, err)` -> `undefined`
+
+When `methodName` is next invoked, the `Promise` will be rejected with the specified `err`. This is useful for simulating validation or any other errors. The error will be triggered with the next `flush`.
+
+`err` must be a proper `Error` object and not a string or any other primitive.
+
+<hr>
+
+##### `on(methodName, callback)` -> `undefined`
+
+When `methodName` is next invoked, the `callback` will be triggered. The callback gets an array as argument. The array contains all arguments, that were passed on invoking `methodName`. This is useful to assert the input arguments of `methodName`.
+
+See [docs.js](/test/unit/docs.js) for an example.

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 ### Added
 - Changelog
+- Support for Firebase Messaging (Admin API)
 
 ### Changed
 - `MockStorageFile.download()` now allows omitting the destination arg;

README.md

@@ -35,6 +35,7 @@ Firebase Mock supports the client-side [JavaScript API](https://firebase.google.
 * Authentication
   * [Basic](tutorials/admin/authentication.md)
   * [JWT Tokens](tutorials/admin/tokens.md)
+* [Messaging](tutorials/admin/messaging.md)
 * [Realtime Database](tutorials/admin/rtdb.md)
 * [Firestore](tutorials/admin/firestore.md)
 * [Storage](tutorials/admin/storage.md)

src/messaging.js

@@ -1,6 +1,141 @@
+/*
+  Mock for admin.messaging.Messaging
+  https://firebase.google.com/docs/reference/admin/node/admin.messaging
+*/
 'use strict';
+var _ = require('./lodash');
+var assert = require('assert');
+var Promise = require('rsvp').Promise;
+var autoId = require('firebase-auto-ids');
+var Queue = require('./queue').Queue;
 
 function MockMessaging() {
+  this.results = {};
+  this.callbacks = {};
+  this.queue = new Queue();
+  this.flushDelay = false;
 }
 
+// https://firebase.google.com/docs/reference/admin/node/admin.messaging.Messaging.html#send
+MockMessaging.prototype.send = function(message, dryRun) {
+  assert(!_.isUndefined(message), 'message must not be undefined');
+  return this._send(_.toArray(arguments), 'send', function() {
+    var messageId = autoId(new Date().getTime());
+    return messageId;
+  });
+};
+
+// https://firebase.google.com/docs/reference/admin/node/admin.messaging.Messaging.html#send-all
+MockMessaging.prototype.sendAll = function(messages, dryRun) {
+  assert(Array.isArray(messages), 'messages must be an "Array"');
+  var self = this;
+  return this._send(_.toArray(arguments), 'sendAll', function() {
+    return self._mapMessagesToBatchResponse(messages);
+  });
+};
+
+// https://firebase.google.com/docs/reference/admin/node/admin.messaging.Messaging.html#send-multicast
+MockMessaging.prototype.sendMulticast = function(multicastMessage, dryRun) {
+  assert(!_.isUndefined(multicastMessage), 'multicastMessage must not be undefined');
+  assert(Array.isArray(multicastMessage.tokens));
+  var self = this;
+  return this._send(_.toArray(arguments), 'sendMulticast', function() {
+    return self._mapMessagesToBatchResponse(multicastMessage.tokens);
+  });
+};
+
+MockMessaging.prototype.flush = function(delay) {
+  this.queue.flush(delay);
+  return this;
+};
+
+MockMessaging.prototype.autoFlush = function (delay) {
+  if (_.isUndefined(delay)) {
+    delay = true;
+  }
+
+  this.flushDelay = delay;
+
+  return this;
+};
+
+MockMessaging.prototype.failNext = function(methodName, err) {
+  assert(_.isString(methodName), 'methodName must be a string');
+  assert(err instanceof Error, 'err must be an "Error" object');
+  this.results[methodName] = err;
+};
+
+MockMessaging.prototype.respondNext = function(methodName, result) {
+  assert(_.isString(methodName), 'methodName must be a string');
+  assert(!_.isUndefined(result), 'result must not be undefined');
+  assert(!(result instanceof Error), 'result must not be an "Error" object');
+  this.results[methodName] = result;
+};
+
+MockMessaging.prototype.on = function(methodName, callback) {
+  assert(_.isString(methodName), 'methodName must be a string');
+  assert(_.isFunction(callback), 'callback must be a function');
+  this.callbacks[methodName] = callback;
+};
+
+MockMessaging.prototype._send = function(args, methodName, defaultResultFn) {
+  var result = this._nextResult(methodName);
+  var self = this;
+  return new Promise(function (resolve, reject) {
+    self._defer(methodName, args, function () {
+      self._invokeOn(methodName, args);
+
+      if (result === null) {
+        resolve(defaultResultFn());
+      } else if (result instanceof Error) {
+        reject(result);
+      } else {
+        resolve(result);
+      }
+    });
+  });
+};
+
+MockMessaging.prototype._invokeOn = function(methodName, args) {
+  var callback = this.callbacks[methodName];
+  if (callback) {
+    callback(args);
+  }
+};
+  
+MockMessaging.prototype._nextResult = function(type) {
+  var result = this.results[type];
+  delete this.results[type];
+  return result || null;
+};
+
+MockMessaging.prototype._defer = function(sourceMethod, sourceArgs, callback) {
+  this.queue.push({
+    fn: callback,
+    context: this,
+    sourceData: {
+      ref: this,
+      method: sourceMethod,
+      args: sourceArgs
+    }
+  });
+  if (this.flushDelay !== false) {
+    this.flush(this.flushDelay);
+  }
+};
+
+MockMessaging.prototype._mapMessagesToBatchResponse = function(messages) {
+  return {
+    failureCount: 0,
+    successCount: messages.length,
+    responses: messages.map(function(message) {
+      return {
+        error: undefined,
+        messageId: autoId(new Date().getTime()),
+        success: true,
+      };
+    })
+  };
+};
+
 module.exports = MockMessaging;

test/unit/docs.js

@@ -1,15 +1,19 @@
-const MockUser = require('../../src/user');
+'use strict';
+
+/* jshint browser:true */
+/* globals expect:false */
 
 describe('API.md', () => {
   describe('Auth example for changeAuthState', () => {
 
     let ref;
     beforeEach(() => {
-      const Authentication = require('../../').MockAuthentication;
+      const Authentication = require('../../src').MockAuthentication;
       ref = new Authentication();
     });
 
     it('works as described', () => {
+      const MockUser = require('../../src/user');
       ref.changeAuthState(new MockUser(ref, {
         uid: 'theUid',
         email: '[email protected]',
@@ -37,4 +41,78 @@ describe('API.md', () => {
       console.assert(ref.getAuth().displayName === 'Mr. Meeseeks', 'Auth name is correct');
     });
   });
+
+  describe('Messaging examples', () => {
+    let mockMessaging;
+
+    beforeEach(() => {
+      const Messaging = require('../../').MockMessaging;
+      mockMessaging = new Messaging();
+    });
+
+    it('send messages', () => {
+      var message = {
+        notification: {
+          title: 'message title',
+          body: 'foobar'
+        }
+      };
+      var result = mockMessaging.send(message);
+      mockMessaging.flush();
+      result.then(function (messageId) {
+        console.assert(messageId !== '', 'message id is ' + messageId);
+      });
+    });
+
+    it('returns custom message responses', () => {
+      var messages = [
+        {
+          notification: {
+            title: 'message title',
+            body: 'foobar'
+          }
+        },
+        {
+          notification: {
+            title: 'message title',
+            body: 'second message'
+          }
+        }
+      ];
+      var batchResponse = {
+        failureCount: 1,
+        responses: [
+            {
+                error: "something went wrong",
+                success: false,
+            },
+            {
+                messageId: "12345",
+                success: true,
+            },
+        ],
+        successCount: 1,
+      };
+      mockMessaging.respondNext('sendAll', batchResponse);
+      var result = mockMessaging.sendAll(messages);
+      mockMessaging.flush();
+      result.then(function (response) {
+        console.assert(response === batchResponse, 'custom batch response is returned');
+      });
+    });
+
+    it('callback on sending messages', () => {
+      var message = {
+        notification: {
+          title: 'message title',
+          body: 'foobar'
+        }
+      };
+      mockMessaging.on('send', function(args) {
+        console.assert(args[0] === message, 'message argument is correct');
+      });
+      mockMessaging.send(message);
+      mockMessaging.flush();
+    });
+  });
 });