mocha-distributed 0.8.1 → 0.9.3

package/master-server.js

@@ -1,194 +0,0 @@
-// -----------------------------------------------------------------------------
-// master-mocha-bindings.js
-//
-// Copyright(c) 2019 Pau Sanchez - MIT License
-// -----------------------------------------------------------------------------
-const url = require('url');
-const querystring = require('querystring');
-const constants = require('./constants.js');
-
-let g_testsPerRunner = new Map();
-let g_testEventEmitter = null;
-
-// -----------------------------------------------------------------------------
-// setEventEmitter
-//
-// To communicate with the mocha bindings
-// -----------------------------------------------------------------------------
-function setEventEmitter (testEventEmitter) {
-  g_testEventEmitter = testEventEmitter;
-}
-
-// -----------------------------------------------------------------------------
-// handleRunnerShouldRun
-//
-// REST: /runner/<runner-id>/should-run?test=xxxxx
-//
-// Asks whether the client should run given test
-// -----------------------------------------------------------------------------
-function handleRunnerShouldRun (req, res) {
-  const queryObj = querystring.parse(req.route.query);
-  const splitted = req.route.pathname.split('/');
-  const runnerId = splitted[2];
-  const action = splitted[3];
-
-  const testId = queryObj.test || null;
-
-  // is this test already assigned to somebody else?
-  if (!testId) {
-    res.write (
-      JSON.stringify ({
-        answer : 'skip',
-        reason : constants.ERRORS.INVALID_TEST_ID
-      })
-    )
-    return;
-  }
-
-  if (g_testsPerRunner.has(testId)) {
-    const runner = g_testsPerRunner.get (testId).runner;
-
-    // is it a retry? e.g. same runner...
-    if (runnerId === runner) {
-      g_testsPerRunner.get (testId).retries ++;
-      res.write (JSON.stringify ({ answer : 'run' }));
-      return;
-    }
-
-    // otherwise, it is already running :)
-    res.write (
-      JSON.stringify ({
-        answer : 'skip',
-        reason : constants.ERRORS.ALREADY_RUNNING,
-        runner : runner
-      })
-    );
-    return;
-  }
-
-  // make this runner the owner of running this test
-  g_testsPerRunner.set (testId, {
-    id     : testId,
-    runner : runnerId,
-    status : constants.TEST_STATUS_RUNNING,
-    retries: 0,
-    start  : Date.now(),
-    end    : false,
-    error  : null
-  });
-
-  res.write (
-    JSON.stringify ({
-      answer : 'run'
-    })
-  );
-}
-
-// -----------------------------------------------------------------------------
-// handleRunnerResult
-//
-// REST: /runner/<runner-id>/result?test=xxxxx&status=success|error
-//
-// Informs the result of running given test
-// -----------------------------------------------------------------------------
-function handleRunnerResult (req, res) {
-  const queryObj = querystring.parse(req.route.query);
-  const splitted = req.route.pathname.split('/');
-  const runnerId = splitted[2];
-  const action = splitted[3];
-
-  const testId = queryObj.test || null;
-  if (!testId || !g_testsPerRunner.has(testId)) {
-    res.write (
-      JSON.stringify ({
-        error : constants.ERRORS.INVALID_TEST_ID
-      })
-    )
-    return;
-  }
-
-  const test = g_testsPerRunner.get (testId);
-  if (test.runner !== runnerId) {
-    res.write (
-      JSON.stringify ({
-        error : constants.ERRORS.INVALID_RUNNER_OWNERSHIP
-      })
-    )
-    return;
-  }
-
-  let status = queryObj.status || constants.TEST_STATUS_FAILED;
-  if (status !== constants.TEST_STATUS_SUCCESS) {
-    status = constants.TEST_STATUS_FAILED;
-  }
-
-  test.status = status;
-  test.error  = JSON.parse(querystring.unescape (queryObj.error || 'null'));
-
-  res.write ( JSON.stringify ({ 'status' : status }) );
-
-  // Emit an event-finished for given test ID, we use the ID because that
-  // should be unique.
-  g_testEventEmitter.emit (constants.EVENT_FINISHED + ':' + testId, test);
-}
-
-// -----------------------------------------------------------------------------
-// handleRunners
-//
-// REST: /runner/<runner-id>/*
-//
-// Handles all requests from all runners (registration, queries, ...)
-// -----------------------------------------------------------------------------
-function handleRunners (req, res) {
-  const queryObj = querystring.parse(req.route.query);
-  const splitted = req.route.pathname.split('/');
-  const runnerId = splitted[2];
-  const action   = splitted[3];
-
-  // TODO: check that runner is registered
-  if (!runnerId || !action) {
-    res.end();
-    return;
-  }
-
-  switch (action) {
-    case 'should-run': handleRunnerShouldRun (req, res); break;
-    case 'result':     handleRunnerResult(req, res); break;
-    default:
-      console.error ("Invalid action: " + action + "(" + req.url + ")");
-      res.write (
-        JSON.stringify ({ error : constants.ERRORS.INVALID_REQUEST_ACTION })
-      )
-      break;
-  }
-  res.end();
-}
-
-// -----------------------------------------------------------------------------
-// mainServerHandler
-//
-// REST: /*
-//
-// Handles all requests to this master server
-// -----------------------------------------------------------------------------
-function mainServerHandler (req, res) {
-  res.writeHead(200, {'Content-Type': 'application/javascript'});
-  req.route = url.parse(req.url);
-
-  // REST: /runner/<runner-id>/*
-  //
-  // execute actions from given runner
-  if (req.route.pathname.startsWith (`/runner/`)) {
-    handleRunners (req, res);
-  }
-  else {
-    res.write(JSON.stringify ({ error : constants.ERRORS.INVALID_REQUEST }));
-    res.end();
-  }
-}
-
-
-module.exports = {
-  setEventEmitter,
-  mainServerHandler
-};

package/master.js

@@ -1,47 +0,0 @@
-// -----------------------------------------------------------------------------
-// master.js
-//
-// Copyright(c) 2019 Pau Sanchez - MIT License
-// -----------------------------------------------------------------------------
-const http = require('http');
-const EventEmitter = require('events');
-const masterServer = require ('./master-server.js');
-const masterMochaBindings = require ('./master-mocha-bindings.js');
-
-// used to notify master that a test has been executed
-class TestEmitter extends EventEmitter {};
-
-let g_server = null;
-let g_eventEmitter = null;
-
-// -----------------------------------------------------------------------------
-// master
-//
-// Initializes the master server, redefines variables, etc...
-// -----------------------------------------------------------------------------
-function master (port) {
-
-  // Checking server because this master function might be called once
-  // per every mocha file, and we only want to initialize once.
-  if (g_server === null) {
-    g_eventEmitter = new TestEmitter();
-
-    masterServer.setEventEmitter(g_eventEmitter);
-    masterMochaBindings.setEventEmitter (g_eventEmitter);
-
-    g_server = http.createServer(masterServer.mainServerHandler);
-    g_server.listen(port, function() {
-      console.log("# Mocha distributed master listening at port:", port, "\n");
-    });
-  }
-
-  // hook all mocha methods
-  global.describe   = masterMochaBindings.describe;
-  global.it         = masterMochaBindings.it;
-  global.before     = masterMochaBindings.before;
-  global.beforeEach = masterMochaBindings.beforeEach;
-  global.after      = masterMochaBindings.after;
-  global.afterEach  = masterMochaBindings.afterEach;
-}
-
-module.exports = master;

package/runner-mocha-bindings.js

@@ -1,212 +0,0 @@
-// -----------------------------------------------------------------------------
-// runner-mocha-bindings.js
-//
-// NOTE: mocha first does a first pass executing all describe/it/... and then
-//       when it has gathered all information, it runs the functions associated
-//       to each. What we do is we hook our method in the middle and call
-//       or not, the original test method.
-//
-// Copyright(c) 2019 Pau Sanchez - MIT License
-// -----------------------------------------------------------------------------
-const axios = require('axios');
-const querystring = require('querystring');
-const crypto = require('crypto');
-
-const constants = require('./constants.js');
-
-let g_masterAddress = null;
-
-// Generate a unique random id for this runner (with almost 100% certainty
-// to be different on any machine/environment).
-const g_runnerIdBuffer = Buffer.alloc(16);
-const g_runnerId = crypto.randomFillSync(g_runnerIdBuffer).toString('hex');
-
-let g_mochaMethods = {
-  describe   : global.describe || null,
-  it         : global.it || null,
-  before     : global.before || null,
-  beforeEach : global.beforeEach || null,
-  after      : global.after || null,
-  afterEach  : global.afterEach || null
-};
-
-
-// contains the actual test path such as suite.title > suite.title > it.title
-let g_testPath = [];
-
-// -----------------------------------------------------------------------------
-// askMasterIfShouldRun
-//
-// Asks master server if the current runner should run given suite.
-//
-// Right now we only ask for suites because it seems the safest approach.
-//
-// Returns:
-//  - true: the caller should run the test
-//  - false: the caller should not run the test
-//  - null: connectivity issue with the master, it depends on the caller to
-//    decide what to do
-// -----------------------------------------------------------------------------
-async function askMasterIfShouldRun (testPath) {
-  const testSuite = querystring.escape(testPath[0]);
-  try {
-    const r = await axios.get (`http://${g_masterAddress}/runner/${g_runnerId}/should-run?test=${testSuite}`);
-    const ok = (r.data.answer === 'run');
-
-    // we ask for given test, so we can save the result properly
-    // TODO: this can be removed if the server accepts runners
-    if (ok) {
-      const path = querystring.escape(testPath.join(constants.TEST_PATH_SEPARATOR));
-      const r = await axios.get (`http://${g_masterAddress}/runner/${g_runnerId}/should-run?test=${path}`);
-    }
-    return ok;
-  }
-  catch (e) {
-    // ignore connection errors
-    // the master could have died because it already finished
-  }
-
-  // skip (should not run) if there is any kind of error with master
-  return null;
-}
-
-// -----------------------------------------------------------------------------
-// sendTestResultToMaster
-// -----------------------------------------------------------------------------
-async function sendTestResultToMaster (testPath, status, error = null) {
-  // TODO: use POST
-  const path = querystring.escape(testPath.join(constants.TEST_PATH_SEPARATOR));
-  let serror = querystring.escape(JSON.stringify(error || null));
-
-  try {
-    const r = await axios.get (
-      `http://${g_masterAddress}/runner/${g_runnerId}/result?test=${path}&status=${status}&error=${serror}`
-    );
-  }
-  catch (e) {
-    // ignore connection errors
-    // the master could have died because it already finished
-  }
-}
-
-// -----------------------------------------------------------------------------
-// init
-//
-// Initialize this module
-// -----------------------------------------------------------------------------
-function init (masterAddress){
-  g_masterAddress = masterAddress;
-}
-
-// -----------------------------------------------------------------------------
-// describe
-//
-// Custom version to describe a test, with same signature
-// -----------------------------------------------------------------------------
-async function describe (title, fn) {
-  g_testPath.push (title);
-  const result = g_mochaMethods.describe (title, fn);
-  g_testPath.pop();
-
-  return result;
-}
-
-// TODO:
-// describe.skip = async function (title, fn) { }
-// describe.once = async function (title, fn) { }
-
-
-// -----------------------------------------------------------------------------
-// it
-// -----------------------------------------------------------------------------
-async function it (title, fn) {
-  // store current path for when the 'it' function executes
-  g_testPath.push (title);
-  const testPath = g_testPath.slice(0);
-  g_testPath.pop();
-
-  // define our own function hook
-  return g_mochaMethods.it (title, async function () {
-    if (!await askMasterIfShouldRun (testPath)) {
-      this.skip();
-      return;
-    }
-
-    try {
-      const testResult = await fn();
-      await sendTestResultToMaster (testPath, constants.TEST_STATUS_SUCCESS);
-      return testResult;
-    }
-    catch (e) {
-      await sendTestResultToMaster (testPath, constants.TEST_STATUS_FAILED, e);
-      throw e;
-    }
-  });
-}
-
-// -----------------------------------------------------------------------------
-// execHookMochaMethod
-//
-// Method used accross all mocha hooks (before, beforeEach, after, afterEach)
-// in order to query the master server if it needs to be executed or not.
-// -----------------------------------------------------------------------------
-function execHookMochaMethod (title, orgMochaMethod, fn) {
-  g_testPath.push (title);
-  const testPath = g_testPath.slice(0);
-  g_testPath.pop();
-
-  return orgMochaMethod (async function () {
-    if (!await askMasterIfShouldRun (testPath)) {
-      this.skip();
-      return;
-    }
-
-    try {
-      const testResult = await fn();
-      await sendTestResultToMaster (testPath, constants.TEST_STATUS_SUCCESS);
-      return testResult;
-    }
-    catch (e) {
-      await sendTestResultToMaster (testPath, constants.TEST_STATUS_FAILED, e);
-      throw e;
-    }
-  });
-}
-
-// -----------------------------------------------------------------------------
-// before
-// -----------------------------------------------------------------------------
-async function before (fn) {
-  return execHookMochaMethod (':before', g_mochaMethods.before, fn);
-}
-
-// -----------------------------------------------------------------------------
-// beforeEach
-// -----------------------------------------------------------------------------
-async function beforeEach (fn) {
-  return execHookMochaMethod (':beforeEach', g_mochaMethods.beforeEach, fn);
-}
-
-// -----------------------------------------------------------------------------
-// after
-// -----------------------------------------------------------------------------
-async function after (fn) {
-  return execHookMochaMethod (':after', g_mochaMethods.after, fn);
-}
-
-// -----------------------------------------------------------------------------
-// afterEach
-// -----------------------------------------------------------------------------
-async function afterEach (fn) {
-  return execHookMochaMethod (':afterEach', g_mochaMethods.after, fn);
-}
-
-module.exports = {
-  init,
-  describe,
-  it,
-  before,
-  beforeEach,
-  after,
-  afterEach
-};

package/runner.js

@@ -1,20 +0,0 @@
-// -----------------------------------------------------------------------------
-// runner.js
-//
-// Copyright(c) 2019 Pau Sanchez - MIT License
-// -----------------------------------------------------------------------------
-const runnerMochaBindings = require ('./runner-mocha-bindings.js');
-
-function runner (masterAddress, port) {
-  runnerMochaBindings.init (masterAddress + ':' + port);
-
-  // hook all mocha methods
-  global.describe   = runnerMochaBindings.describe;
-  global.it         = runnerMochaBindings.it;
-  global.before     = runnerMochaBindings.before;
-  global.beforeEach = runnerMochaBindings.beforeEach;
-  global.after      = runnerMochaBindings.after;
-  global.afterEach  = runnerMochaBindings.afterEach;
-}
-
-module.exports = runner;