mocha-chrome/client/shim.js

(function (){
  'use strict';

  Object.defineProperty(window, 'mocha', {
    get () {
      return undefined;
    },
    set (m) {
      shimMocha(m);
      delete window.mocha;
      window.mocha = m;

      // mochaOptions is injected in lib/client.js

      mochaOptions = mochaOptions || {
        ui: 'bdd',
        reporter: 'spec',
        useColors: true
      };

      mocha.setup(mochaOptions);
    },
    configurable: true
  });

  Object.defineProperty(window, 'Mocha', {
    get () {
      return undefined;
    },
    set (m) {
      delete window.Mocha;
      window.Mocha = m;

      m.process.stdout._write = function (chunks, encoding, cb) {
        var output = chunks.toString ? chunks.toString() : chunks;

        window._eventbus.emit('mocha', output);

        m.process.nextTick(cb);
      };

      window._eventbus.emit('width');
    },
    configurable: true
  });

  function shimMocha (m) {
    var origRun = m.run, origUi = m.ui;

    m.ui = function () {
      var retval = origUi.apply(mocha, arguments);
      m.reporter = () => {};
      return retval;
    };
    m.run = function () {
      window._eventbus.emit('started', m.suite.suites.length);

      m.runner = origRun.apply(mocha, arguments);
      if (m.runner.stats && m.runner.stats.end) {
        window._eventbus.emit('ended', m.runner.stats);
      }
      else {
        m.runner.on('end', () => {
          window._eventbus.emit('ended', m.runner.stats);
        });
      }
      return m.runner;
    };
  }

  // Mocha needs the formating feature of console.log so copy node's format function and
  // monkey-patch it into place. This code is copied from node's, links copyright applies.
  // https://github.com/joyent/node/blob/master/lib/util.js
  if (!console.format) {
    let origError = console.error,
      origLog = console.log;

    // stringify() and serizlier() from https://github.com/moll/json-stringify-safe
    function stringify (obj, replacer, spaces, cycleReplacer) {
      if (typeof replacer !== 'function') {
        replacer = null;
      }
      return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
    }

    function serializer (replacer, cycleReplacer) {
      var stack = [], keys = [];

      if (cycleReplacer == null) cycleReplacer = function (key, value) {
        if (stack[0] === value) return "[Circular ~]";
        return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
      };

      return function (key, value) {
        if (stack.length > 0) {
          var thisPos = stack.indexOf(this);
          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
          ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
          if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value);
        }
        else stack.push(value);

        return replacer == null ? value : replacer.call(this, key, value);
      };
    }

    console.format = function (f) {
      if (typeof f !== 'string') {
        return Array.prototype.map.call(arguments, stringify).join(' ');
      }
      var i = 1,
        args = arguments,
        len = args.length,
        str = String(f).replace(/%[sdj%]/g, (x) => {
          if (x === '%%') return '%';
          if (i >= len) return x;
          switch (x) {
            case '%s': return String(args[i++]);
            case '%d': return Number(args[i++]);
            case '%j': return stringify(args[i++]);
            default:
              return x;
          }
        }),
        x;
      for (x = args[i]; i < len; x = args[++i]) {
        if (x === null || typeof x !== 'object') {
          str += ' ' + x;
        }
        else {
          str += ' ' + stringify(x);
        }
      }
      return str;
    };

    console.error = function (){
      origError.call(console, console.format.apply(console, arguments));
    };

    console.log = function (){
      origLog.call(console, console.format.apply(console, arguments));
    };
  }

})();