meteor/packages/test-in-console/driver.js

// Global flag for phantomjs (or other browser) to eval to see if we're done.
DONE = false;
// Failure count for phantomjs exit code
FAILURES = null;

TEST_STATUS = {
  DONE: false,
  FAILURES: null
};

// xUnit format uses XML output
var XML_CHAR_MAP = {
  '<': '&lt;',
  '>': '&gt;',
  '&': '&amp;',
  '"': '&quot;',
  "'": '&apos;'
};

// Escapes a string for insertion into XML
var escapeXml = function (s) {
  return s.replace(/[<>&"']/g, function (c) {
    return XML_CHAR_MAP[c];
  });
}

// Returns a human name for a test
var getName = function (result) {
  return (result.server ? "S: " : "C: ") +
    result.groupPath.join(" - ") + " - " + result.test;
};

// Calls console.log, but returns silently if console.log is not available
var log = function (/*arguments*/) {
  if (typeof console !== 'undefined') {
    console.log.apply(console, arguments);
  }
};

var MAGIC_PREFIX = '##_meteor_magic##';
// Write output so that other tools can read it
// Output is sent to console.log, prefixed with the magic prefix and then the facility
// By grepping for the prefix, other tools can get the 'special' output
var logMagic = function (facility, s) {
  log(MAGIC_PREFIX + facility + ': ' + s);
};

// Logs xUnit output, if xunit output is enabled
// This uses logMagic with a facility of xunit
var xunit = function (s) {
  if (xunitEnabled) {
    logMagic('xunit', s);
  }
};

var passed = 0;
var failed = 0;
var expected = 0;
var resultSet = {};
var toReport = [];

var hrefPath = document.location.href.split("/");
var platform = decodeURIComponent(hrefPath.length && hrefPath[hrefPath.length - 1]);
if (!platform)
  platform = "local";

// We enable xUnit output when platform is xunit
var xunitEnabled = (platform == 'xunit');

var doReport = Meteor &&
      Meteor.settings &&
      Meteor.settings.public &&
      Meteor.settings.public.runId;
var report = function (name, last) {
  if (doReport) {
    var data = {
      run_id: Meteor.settings.public.runId,
      testPath: resultSet[name].testPath,
      status: resultSet[name].status,
      platform: platform,
      server: resultSet[name].server,
      fullName: name.substr(3)
    };
    if ((data.status === "FAIL" || data.status === "EXPECTED") &&
        !_.isEmpty(resultSet[name].events)) {
      // only send events when bad things happen
      data.events = resultSet[name].events;
    }
    if (last)
      data.end = new Date();
    else
      data.start = new Date();
    toReport.push(EJSON.toJSONValue(data));
  }
};
var sendReports = function (callback) {
  var reports = toReport;
  if (!callback)
    callback = function () {};
  toReport = [];
  if (doReport)
    Meteor.call("report", reports, callback);
  else
    callback();
};
Meteor.startup(function () {
  setTimeout(sendReports, 500);
  setInterval(sendReports, 2000);

  Tinytest._runTestsEverywhere(
    function (results) {
      var name = getName(results);
      if (!_.has(resultSet, name)) {
        var testPath = EJSON.clone(results.groupPath);
        testPath.push(results.test);
        resultSet[name] = {
          name: name,
          status: "PENDING",
          events: [],
          server: !!results.server,
          testPath: testPath,
          test: results.test
        };
        report(name, false);
      }
      // Loop through events, and record status for each test
      // Also log result if test has finished
      _.each(results.events, function (event) {
        resultSet[name].events.push(event);
        switch (event.type) {
        case "ok":
          break;
        case "expected_fail":
          if (resultSet[name].status !== "FAIL")
            resultSet[name].status = "EXPECTED";
          break;
        case "exception":
          log(name, ":", "!!!!!!!!! FAIL !!!!!!!!!!!");
          if (event.details && event.details.stack)
            log(event.details.stack);
          else
            log("Test failed with exception");
          failed++;
          break;
        case "finish":
          switch (resultSet[name].status) {
          case "OK":
            break;
          case "PENDING":
            resultSet[name].status = "OK";
            report(name, true);
            log(name, ":", "OK");
            passed++;
            break;
          case "EXPECTED":
            report(name, true);
            log(name, ":", "EXPECTED FAILURE");
            expected++;
            break;
          case "FAIL":
            failed++;
            report(name, true);
            log(name, ":", "!!!!!!!!! FAIL !!!!!!!!!!!");
            log(JSON.stringify(resultSet[name].info));
            break;
          default:
            log(name, ": unknown state for the test to be in");
          }
          break;
        default:
          resultSet[name].status = "FAIL";
          resultSet[name].info = results;
          break;
        }
      });
    },

    // After test completion, log a quick summary
    function () {
      if (failed > 0) {
        log("~~~~~~~ THERE ARE FAILURES ~~~~~~~");
      }
      log("passed/expected/failed/total", passed, "/", expected, "/", failed, "/", _.size(resultSet));
      sendReports(function () {
        if (doReport) {
          log("Waiting 3s for any last reports to get sent out");
          setTimeout(function () {
            TEST_STATUS.FAILURES = FAILURES = failed;
            TEST_STATUS.DONE = DONE = true;
          }, 3000);
        } else {
          TEST_STATUS.FAILURES = FAILURES = failed;
          TEST_STATUS.DONE = DONE = true;
        }
      });

      // Also log xUnit output
      xunit('<testsuite errors="" failures="" name="meteor" skips="" tests="" time="">');
      _.each(resultSet, function (result, name) {
        var classname = result.testPath.join('.').replace(/ /g, '-') + (result.server ? "-server" : "-client");
        var name = result.test.replace(/ /g, '-') + (result.server ? "-server" : "-client");
        var time = "";
        var error = "";
        _.each(result.events, function (event) {
          switch (event.type) {
            case "finish":
              var timeMs = event.timeMs;
              if (timeMs !== undefined) {
                time = (timeMs / 1000) + "";
              }
              break;
            case "exception":
              var details = event.details || {};
              error = (details.message || '?') + " filename=" + (details.filename || '?') + " line=" + (details.line || '?');
              break;
          }
        });
        switch (result.status) {
          case "FAIL":
            error = error || '?';
            break;
          case "EXPECTED":
            error = null;
            break;
        }

        xunit('<testcase classname="' + escapeXml(classname) + '" name="' + escapeXml(name) + '" time="' + time + '">');
        if (error) {
          xunit('  <failure message="test failure">' + escapeXml(error) + '</failure>');
        }
        xunit('</testcase>');
      });
      xunit('</testsuite>');
      logMagic('state', 'done');
    },
    ["tinytest"]);
});