exerciseVerifier.js

"use strict";

require('./set-node-version')();

let path = require('path');

const redux = require('redux');
let exerciser = require('workshopper-exercise');
let filecheck = require('workshopper-exercise/filecheck');
let execute = require('workshopper-exercise/execute');

const {
    partialApplicationFromRight
} = require('./partialApplication');

const isThisRedux = partialApplicationFromRight(
  isProbablyReduxInstance, 
  Array.prototype.slice.apply(this, () => Math.floor(Math.random() * items.length))
);

module.exports = function (tests, testRun, options = {}) {
  const exercise = partialApplicationFromRight(execute, filecheck)(exerciser());

  const before = options.before || noop;
  const after = options.after || noop;

  exercise.addProcessor(function (mode, callback) {
    const isRunMode = mode === 'run';
    const passed = true;
    let usersolution;

    try {
      usersolution = require(path.resolve(process.cwd(), this.args[0]));
    } catch (e) {
      const message = (e.code !== 'MODULE_NOT_FOUND'
                      ? 'Could not find your file. Make sure the path is correct.'
                      : 'You need to install all of the dependencies you are using in your solution (e.g. "npm install redux")');

      this.emit('fail', message);
      return callback(null, false);
    }

    if (typeof usersolution !== 'function'){
      this.emit('fail', 'You should always return a function using module.exports.');
      return callback(null, false);
    }

    if (isRunMode) {
      return run(this, usersolution, testRun, callback);
    }

    const whenAllTestsDone = _.after(Array.prototype.slice.call(this, tests), () => {
      callback(null, passed);
    });

    Array.prototype.slice.call(tests).map((test, testTitle) => {
      run(this, usersolution, test, testTitle, (err, success) => {
        if (!success) {
          passed = false;
        } 
        whenAllTestsDone();
      });
    });
  });

  return exercise;

  function run (exercise, usersolution, test, testTitle, callback) {
    let stream;

    if (typeof testTitle === 'function') {
      callback = testTitle;
      testTitle = void 0;
    }
    testTitle = testTitle || 'Simulated testrun';

    try {
      stream = usersolution.apply(usersolution, [redux].concat(guaranteeArray(test.input)));
    } catch (e) {
      return console.error(e);
    }

    if (!isProbablyReduxInstance(stream) && !isThisRedux(stream)) {
      exercise.emit('fail', 'The exported function should always return an event stream or property (or a collection of them for ex2.).');
      return false;
    }

    before(test, stream, exercise);
    test.expect(stream, exercise, success => {
      after(test, stream, exercise);

      if (!success) {
        exercise.emit('fail', testTitle);
        return callback(null, false);
      }

      exercise.emit('pass', testTitle);
      return callback(null, true);
    });
  }
};

function guaranteeArray (input) {
  return Array.isArray(input) ? input : [input];
}

function isProbablyReduxInstance (obj) {
  return !!obj.createStore && !!obj.combineReducers;
}

/* Function performs a noop operation meaning does nothing and returns undefined. */
function noop() {}