function-tree-firebase-admin/lib/TestTasks.js

Firebase admin execution and provider

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.TestTasks = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _functionTree = require('function-tree');

var _functionTree2 = _interopRequireDefault(_functionTree);

var _fayeWebsocket = require('faye-websocket');

var _fayeWebsocket2 = _interopRequireDefault(_fayeWebsocket);

var _proxyquire = require('proxyquire');

var _proxyquire2 = _interopRequireDefault(_proxyquire);

var _firebaseServer = require('firebase-server');

var _firebaseServer2 = _interopRequireDefault(_firebaseServer);

var _Provider = require('./Provider');

var _Provider2 = _interopRequireDefault(_Provider);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var firebase = (0, _proxyquire2.default)('firebase', {
  'faye-websocket': {
    Client: function Client(url) {
      url = url.replace(/dummy\.firebaseio\.test/i, 'localhost');

      return new _fayeWebsocket2.default.Client(url);
    }
  },
  '@global': true
});
var firebaseProvider = (0, _Provider2.default)(undefined, firebase);

function runTest(initialData, tasks, assertion, runTree, done) {
  var server = new _firebaseServer2.default(45000, 'localhost:45000', initialData || {});
  var client = firebase.initializeApp({
    apiKey: 'someApiKey',
    databaseURL: 'ws://dummy.firebaseio.test:45000'
  });

  function abortTest(err) {
    return client.delete().then(function () {
      server.close(function () {
        done(err);
      });
    });
  }

  function resolveTest(error) {
    server.getValue().then(function (snapshot) {
      client.delete().then(function () {
        server.close(function () {
          try {
            if (assertion) {
              assertion(snapshot);
            }
            done(error);
          } catch (e) {
            done(e);
          }
        });
      });
    });
  }

  function rejectTest(error) {
    resolveTest(error);
  }

  tasks.reduce(function (currentPromise, task, index) {
    return currentPromise.then(function () {
      return new Promise(function (_resolve, _reject) {
        function runTask(taskToRun) {
          runTree('task_' + index, taskToRun.task, {
            task: {
              resolve: function resolve() {
                if (taskToRun.assert) {
                  server.getValue().then(function (snapshot) {
                    taskToRun.assert(snapshot);
                    _resolve();
                  }).catch(_reject);
                } else {
                  _resolve();
                }
              },
              reject: function reject(error) {
                _reject(new Error(error));
              }
            },
            uid: taskToRun.uid,
            data: taskToRun.data
          }, function (err) {
            if (err) {
              abortTest(err);
            }
          });
        }

        if (typeof task === 'function') {
          server.getValue().then(function (snapshot) {
            runTask(task(snapshot));
          });
        } else {
          runTask(task);
        }
      });
    });
  }, Promise.resolve()).then(function () {
    return resolveTest(null);
  }).catch(function (error) {
    return rejectTest(error);
  });
}

var TestTasks = exports.TestTasks = function () {
  function TestTasks(providers) {
    _classCallCheck(this, TestTasks);

    this.providers = [firebaseProvider].concat(providers);
    this.runTree = new _functionTree2.default(this.providers);
  }

  _createClass(TestTasks, [{
    key: 'create',
    value: function create(initialData, tasks, assertion) {
      var _this = this;

      return function (done) {
        return runTest(initialData, Array.isArray(tasks) ? tasks : [tasks], assertion, _this.runTree, done);
      };
    }
  }]);

  return TestTasks;
}();
//# sourceMappingURL=TestTasks.js.map