src/__tests__/chimp-spec.js
jest.dontMock('../lib/chimp.js');
jest.dontMock('../lib/boolean-helper');
jest.dontMock('underscore');
jest.dontMock('async');
jest.dontMock('wrappy');
jest.dontMock('../lib/cucumberjs/cucumber.js');
beforeEach(() => {
jest.resetModules();
});
describe('Chimp', () => {
jest.genMockFromModule('chromedriver');
jest.genMockFromModule('fs-extra');
const Chimp = require('../lib/chimp');
describe('bin path', () => {
it('sets the bin path to the location of chimp', () => {
expect(Chimp.bin.match(/bin\/chimp$/)).not.toBe(null);
});
});
describe('init', () => {
it('calls selectMode right away if it does not find package.json', () => {
const chimp = new Chimp();
const restore = chimp.fs.existsSync;
chimp.fs.existsSync = jest.fn().mockReturnValue(false);
chimp.informUser = jest.fn();
chimp.exec = jest.fn();
chimp.selectMode = jest.fn();
const callback = function () {};
chimp.init(callback);
expect(chimp.selectMode).toBeCalledWith(callback);
expect(chimp.exec).not.toBeCalled();
chimp.fs.existsSync = restore;
});
it('does not executes npm install if the offline option is set', () => {
const chimp = new Chimp({offline: true});
const restore = chimp.fs.existsSync;
chimp.fs.existsSync = jest.fn().mockReturnValue(true);
chimp.informUser = jest.fn();
chimp.exec = jest.fn();
chimp.selectMode = jest.fn();
const callback = jest.fn();
chimp.init(callback);
expect(chimp.exec.mock.calls.length).toBe(0);
expect(chimp.selectMode.mock.calls.length).toBe(1);
expect(callback.mock.calls.length).toBe(0);
chimp.fs.existsSync = restore;
});
it('executes npm install then calls selectMode when there are no errors', () => {
const chimp = new Chimp();
const restore = chimp.fs.existsSync;
chimp.fs.existsSync = jest.fn().mockReturnValue(true);
chimp.informUser = jest.fn();
chimp.exec = jest.fn().mockImplementation((cmd, callback) => callback(null));
chimp.selectMode = jest.fn();
const callback = function () {};
chimp.init(callback);
expect(chimp.selectMode).toBeCalledWith(callback);
chimp.fs.existsSync = restore;
});
});
describe('selectMode', () => {
it('runs in single mode when no mode option is passed', () => {
const chimp = new Chimp();
const mockedWatch = jest.spyOn(chimp, "watch");
const mockedRun = jest.spyOn(chimp, "run");
const mockedServer = jest.spyOn(chimp, "server");
const callback = function () {};
chimp.selectMode(callback);
expect(mockedRun.mock.calls.length).toBe(1);
expect(mockedRun.mock.calls[0][0]).toBe(callback);
expect(mockedWatch.mock.calls.length).toBe(0);
expect(mockedServer.mock.calls.length).toBe(0);
mockedWatch.mockRestore();
mockedRun.mockRestore();
mockedServer.mockRestore();
});
it('runs in watch mode)', () => {
const chimp = new Chimp({watch: true});
const mockedWatch = jest.spyOn(chimp, "watch");
const mockedRun = jest.spyOn(chimp, "run");
const mockedServer = jest.spyOn(chimp, "server");
chimp.selectMode();
expect(mockedWatch.mock.calls.length).toBe(1);
expect(mockedWatch.mock.calls[0].length).toBe(0);
expect(mockedRun.mock.calls.length).toBe(0);
expect(mockedServer.mock.calls.length).toBe(0);
mockedWatch.mockRestore();
mockedRun.mockRestore();
mockedServer.mockRestore();
});
it('runs in server mode)', () => {
const chimp = new Chimp({server: true});
const mockedWatch = jest.spyOn(chimp, "watch");
const mockedRun = jest.spyOn(chimp, "run");
const mockedServer = jest.spyOn(chimp, "server");
chimp.selectMode();
expect(mockedServer.mock.calls.length).toBe(1);
expect(typeof mockedServer.mock.calls[0][0]).toBe('undefined');
expect(mockedRun.mock.calls.length).toBe(0);
expect(mockedWatch.mock.calls.length).toBe(0);
mockedWatch.mockRestore();
mockedRun.mockRestore();
mockedServer.mockRestore();
});
});
describe('watch', () => {
it('initializes chokidar', () => {
jest.doMock('chokidar', () => {
return {
watch: jest.fn(),
watcher: {
on: jest.fn(),
once: jest.fn(),
},
};
});
const chokidar = require('chokidar');
chokidar.watch.mockReturnValue(chokidar.watcher);
const Chimp = require('../lib/chimp.js');
const options = {path: 'abc'};
const chimp = new Chimp(options);
chimp.run = jest.fn();
chimp.watch();
expect(chokidar.watch.mock.calls.length).toEqual(1);
expect(chokidar.watch.mock.calls[0][0]).toEqual([options.path]);
});
it('all listener is registered after watcher is ready', () => {
jest.doMock('chokidar', () => {
return {
watch: jest.fn(),
watcher: {
on: jest.fn(),
once: jest.fn(),
},
};
});
const chokidar = require('chokidar');
chokidar.watch.mockReturnValue(chokidar.watcher);
const Chimp = require('../lib/chimp.js');
const options = {path: 'abc'};
const chimp = new Chimp(options);
chimp.run = jest.fn();
chokidar.watcher.on = jest.fn();
chokidar.watcher.once = jest.fn();
chimp.watch();
expect(chokidar.watcher.once.mock.calls[0][0]).toBe('ready');
const readyCallback = chokidar.watcher.once.mock.calls[0][1];
readyCallback();
expect(chokidar.watcher.on.mock.calls[0][0]).toBe('all');
});
it('an non-unlink event triggers the interrupt and run sequence', function () {
jest.doMock('chokidar', () => {
return {
watch: jest.fn(),
watcher: {
on: jest.fn(),
once: jest.fn(),
},
};
});
const chokidar = require('chokidar');
chokidar.watch.mockReturnValue(chokidar.watcher);
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp();
chimp.run = jest.fn();
const self = this;
self.func = null;
self.timeout = null;
chimp._getDebouncedFunction = function (func, timeout) {
self.allCallback = func;
self.timeout = timeout;
};
chimp.watch();
const readyCallback = chokidar.watcher.once.mock.calls[0][1];
readyCallback();
chimp.rerun = jest.fn();
self.allCallback('not-unlink');
expect(chimp.rerun.mock.calls.length).toBe(1);
});
it('a deleted feature does not trigger the interrupt and run sequence', () => {
jest.doMock('chokidar', () => {
return {
watch: jest.fn(),
watcher: {
on: jest.fn(),
once: jest.fn(),
},
};
});
const chokidar = require('chokidar');
chokidar.watch.mockReturnValue(chokidar.watcher);
const Chimp = require('../lib/chimp.js');
// var _on = process.on;
// process.on = jest.fn();
const chimp = new Chimp();
chimp.run = jest.fn();
chimp.watch();
const readyCallback = chokidar.watcher.once.mock.calls[0][1];
readyCallback();
const allCallback = chokidar.watcher.on.mock.calls[0][1];
chimp.rerun = jest.fn();
allCallback('unlink', '/path/some.feature');
expect(chimp.rerun.mock.calls.length).toBe(0);
// process.on = _on;
});
it('a deleted non-feature triggers the interrupt and run sequence', function () {
jest.doMock('chokidar', () => {
return {
watch: jest.fn(),
watcher: {
on: jest.fn(),
once: jest.fn(),
},
};
});
const chokidar = require('chokidar');
chokidar.watch.mockReturnValue(chokidar.watcher);
const async = require('async');
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp();
chimp.run = jest.fn();
const self = this;
self.func = null;
self.timeout = null;
chimp._getDebouncedFunction = function (func, timeout) {
self.allCallback = func;
self.timeout = timeout;
};
chimp.watch();
const readyCallback = chokidar.watcher.once.mock.calls[0][1];
readyCallback();
chimp.rerun = jest.fn();
this.allCallback('unlink', '/path/some.feature.js');
expect(chimp.rerun.mock.calls.length).toBe(1);
});
it('runs on startup', () => {
jest.doMock('chokidar', () => {
return {
watch: jest.fn(),
watcher: {
on: jest.fn(),
once: jest.fn(),
},
};
});
const chokidar = require('chokidar');
chokidar.watch.mockReturnValue(chokidar.watcher);
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp();
chimp.run = jest.fn();
chimp.watch();
const readyCallback = chokidar.watcher.once.mock.calls[0][1];
readyCallback();
expect(chimp.run.mock.calls.length).toBe(1);
});
it('uses the watchTag with cucumber', () => {
jest.doMock('chokidar', () => {
return {
watch: jest.fn(),
watcher: {
on: jest.fn(),
once: jest.fn(),
},
};
});
const chokidar = require('chokidar');
chokidar.watch.mockReturnValue(chokidar.watcher);
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp({
watchTags: '@someTag,@andAnotherTag',
});
chimp.watch();
expect(chimp.options.tags).toBe('@someTag,@andAnotherTag');
});
});
describe('server', () => {
it('listens on a freeport when server-port is not provided', () => {
const freeport = require('freeport');
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp();
chimp.server();
expect(freeport.mock.calls.length).toBe(1);
});
it('listens on the server-port when it is provided', () => {
const freeport = require('freeport');
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp({serverPort: 1234});
chimp._startServer = jest.fn();
chimp.server();
expect(chimp._startServer.mock.calls.length).toBe(1);
expect(chimp._startServer.mock.calls[0][0]).toBe(1234);
expect(freeport.mock.calls.length).toBe(0);
});
it('handshakes with a DDP endpoint with the server address on startup if ddp is passed', () => {
// TODO having some issues testing this. DDPClient is tricky to jest up
});
it('exposes the run and interrupt endpoints', () => {
const Hapi = require('hapi');
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp({serverHost: 'localhost', serverPort: 1234});
chimp.server();
expect(Hapi.instance.route.mock.calls[0][0].method).toBe('GET');
expect(Hapi.instance.route.mock.calls[0][0].path).toBe('/run');
expect(Hapi.instance.route.mock.calls[1][0].method).toBe('GET');
expect(Hapi.instance.route.mock.calls[1][0].path).toBe('/run/{absolutePath*}');
expect(Hapi.instance.route.mock.calls[2][0].method).toBe('GET');
expect(Hapi.instance.route.mock.calls[2][0].path).toBe('/interrupt');
expect(Hapi.instance.route.mock.calls[3][0].method).toBe('GET');
expect(Hapi.instance.route.mock.calls[3][0].path).toBe('/runAll');
});
it('returns cucumber results when run handler is called successfully', () => {
const Hapi = require('hapi');
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp({serverHost: 'localhost', serverPort: 1234});
chimp.rerun = jest.fn().mockImplementation(callback => callback(null,
[null, [null, 'cucumber results']],
));
chimp.server();
const getHandler = Hapi.instance.route.mock.calls[0][0].handler;
const headerMock = jest.fn();
const reply = jest.fn().mockReturnValue({header: headerMock});
getHandler(null, reply);
expect(reply.mock.calls[0][0]).toBe('cucumber results');
});
it('returns cucumber results when run handler is called successfully with a feature', () => {
const Hapi = require('hapi');
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp({serverHost: 'localhost', serverPort: 1234});
chimp.options._ = {};
chimp.rerun = jest.fn().mockImplementation(callback => callback(null,
[null, [null, 'cucumber results']],
));
chimp.server();
const getHandler = Hapi.instance.route.mock.calls[1][0].handler;
const request = {params: {absolutePath: 'blah'}};
const headerMock = jest.fn();
const reply = jest.fn().mockReturnValue({header: headerMock});
getHandler(request, reply);
expect(chimp.options._[2]).toBe(request.params.absolutePath);
expect(reply.mock.calls[0][0]).toBe('cucumber results');
});
it('returns "done" when interrupt handler is called successfully', () => {
const Hapi = require('hapi');
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp({serverHost: 'localhost', serverPort: 1234});
chimp.interrupt = jest.fn().mockImplementation(callback => callback(null,
[null, [null, 'cucumber results']],
));
chimp.server();
const interruptHandler = Hapi.instance.route.mock.calls[2][0].handler;
const headerMock = jest.fn();
const reply = jest.fn().mockReturnValue({header: headerMock});
interruptHandler(null, reply);
expect(reply.mock.calls[0][0]).toBe('done');
});
it('returns cucumber results when runAll handler is called successfully', () => {
const Hapi = require('hapi');
const Chimp = require('../lib/chimp.js');
const chimp = new Chimp({serverHost: 'localhost', serverPort: 1234});
chimp.rerun = jest.fn().mockImplementation(callback => callback(null,
[null, [null, 'cucumber results']],
));
chimp.server();
const getHandler = Hapi.instance.route.mock.calls[3][0].handler;
const headerMock = jest.fn();
const reply = jest.fn().mockReturnValue({header: headerMock});
getHandler(null, reply);
expect(reply.mock.calls[0][0]).toBe('cucumber results');
});
});
describe('run', () => {
it('interrupts any existing processes, starts processes and calls callback', () => {
const chimp = new Chimp();
chimp.interrupt = jest.fn().mockImplementation(callback => callback());
chimp._startProcesses = jest.fn().mockImplementation(callback => callback());
const callback = jest.fn();
chimp.run(callback);
expect(chimp.interrupt.mock.calls.length).toBe(2);
expect(chimp._startProcesses.mock.calls.length).toBe(1);
expect(callback.mock.calls.length).toBe(1);
});
it('detects errors in interrupt and calls callback with an error', () => {
const chimp = new Chimp();
chimp.interrupt = jest.fn().mockImplementation(callback => callback('error'));
const callback = jest.fn();
chimp.run(callback);
expect(callback.mock.calls.length).toBe(1);
expect(callback.mock.calls[0][0]).toEqual('error');
});
it('stops all processes on successful runs', () => {
const chimp = new Chimp();
chimp.interrupt = jest.fn().mockImplementation(callback => callback());
chimp._startProcesses = jest.fn().mockImplementation(callback => callback());
chimp.stop = jest.fn();
const callback = jest.fn();
chimp.run(callback);
expect(chimp.interrupt.mock.calls.length).toBe(2);
});
it('passes the options to the simian reporter constructor', () => {
const SimianReporter = require('../lib/simian-reporter');
const Chimp = require('../lib/chimp.js');
const options = {simianAccessToken: 'present'};
const chimp = new Chimp(options);
chimp.interrupt = jest.fn().mockImplementation(callback => callback());
chimp._startProcesses = jest.fn().mockImplementation(callback => callback());
const callback = jest.fn();
chimp.run(callback);
expect(SimianReporter.mock.calls[0][0]).toBe(options);
expect(SimianReporter.mock.calls.length).toBe(1);
});
it('calls the simian reporter when the run is finished', () => {
jest.dontMock('../lib/simian-reporter');
const SimianReporter = require('../lib/simian-reporter');
SimianReporter.prototype.report = jest.fn();
const Chimp = require('../lib/chimp.js');
const options = {simianAccessToken: 'present'};
const chimp = new Chimp(options);
chimp.interrupt = jest.fn().mockImplementation(callback => callback(null, 'hello'));
chimp._startProcesses = jest.fn().mockImplementation(callback => callback(null, [undefined, '[]']));
const callback = jest.fn();
chimp.run(callback);
expect(SimianReporter.instance.report.mock.calls.length).toBe(1);
});
});
describe('interrupt', () => {
it('calls interrupt on all processes in the reverse order that they were started', () => {
jest.dontMock('async');
const Chimp = require('../lib/chimp');
const chimp = new Chimp();
let orderCounter = 0;
function Process() {
this.orderRun = -1;
}
Process.prototype.interrupt = function (callback) {
this.orderRun = orderCounter++;
callback();
};
const process1 = new Process('1');
const process2 = new Process('2');
chimp.processes = [process1, process2];
const callback = jest.fn();
chimp.interrupt(callback);
expect(process2.orderRun).toBe(0);
expect(process1.orderRun).toBe(1);
});
it('bubbles callback without modifying the arguments', () => {
const async = require('async');
const Chimp = require('../lib/chimp');
const chimp = new Chimp();
chimp.processes = [{interrupt: jest.fn()}];
const someArgs = ['some', 'args'];
async.series = jest.fn().mockImplementation(function (processes, callback) {
callback.apply(this, someArgs);
});
const callback = jest.fn();
chimp.interrupt(callback);
expect(callback.mock.calls.length).toBe(1);
expect(callback.mock.calls[0]).toEqual(['some', 'args']);
});
it('calls the callback when no processes have been started', () => {
const async = require('async');
const Chimp = require('../lib/chimp');
const chimp = new Chimp();
chimp.isInterrupting = true;
async.series = jest.fn();
const callback = jest.fn();
chimp.interrupt(callback);
expect(chimp.isInterrupting).toBe(false);
expect(callback.mock.calls.length).toBe(1);
expect(async.series.mock.calls.length).toBe(0);
});
it('cancels the isInterrupting flag after all processes have run with no errors', () => {
const _ = require('underscore');
const async = require('async');
const Chimp = require('../lib/chimp');
const chimp = new Chimp();
chimp.isInterrupting = true;
chimp.processes = ['yo'];
_.collect = jest.fn();
async.series = jest.fn().mockImplementation((procs, func) => {
func();
});
chimp.interrupt(jest.fn());
expect(chimp.isInterrupting).toBe(false);
});
it('cancels the isInterrupting flag after all processes have run with errors', () => {
const _ = require('underscore');
const async = require('async');
const Chimp = require('../lib/chimp');
const chimp = new Chimp();
chimp.isInterrupting = true;
chimp.processes = ['yo'];
_.collect = jest.fn();
async.series = jest.fn().mockImplementation((procs, func) => {
func('error');
});
chimp.interrupt(jest.fn());
expect(chimp.isInterrupting).toBe(false);
});
});
describe('rerun', () => {
it('calls run if interrupt is successful', () => {
const chimp = new Chimp();
chimp.interrupt = jest.fn().mockImplementation((callback) => {
callback(null);
});
chimp.run = jest.fn();
chimp.rerun();
expect(chimp.run.mock.calls.length).toBe(1);
});
it('does not rerun if an rerun is in progress', () => {
const chimp = new Chimp();
chimp.run = jest.fn();
chimp.isInterrupting = true;
chimp.rerun();
expect(chimp.run.mock.calls.length).toBe(0);
});
it('reruns once it has finished rerunning', () => {
const chimp = new Chimp();
chimp.run = jest.fn().mockImplementation((callback) => {
callback(null);
// after the first run, replace this mockImplementation with a standard mock so we
// can assert on that the rerun interrupts after a successful run
chimp.run = jest.fn();
});
chimp.rerun();
chimp.rerun();
expect(chimp.run.mock.calls.length).toBe(1);
});
});
describe('_startProcesses', () => {
it('creates an array of series of processes and starts them', () => {
const async = require('async');
const Chimp = require('../lib/chimp.js');
async.series = jest.fn();
const chimp = new Chimp();
const processes = [];
const mockedCreateProcesses = jest.spyOn(chimp, "_createProcesses");
mockedCreateProcesses.mockReturnValue(processes);
chimp._startProcesses();
expect(mockedCreateProcesses.mock.calls.length).toBe(1);
expect(chimp.processes).toBe(processes);
mockedCreateProcesses.mockRestore();
});
it('start each process in its own context and calls callback once', () => {
jest.dontMock('async');
const Chimp = require('../lib/chimp');
const chimp = new Chimp();
function Process() {
this.state = 'constructed';
}
Process.prototype.start = function (callback) {
this.state = 'started';
callback();
};
const processes = [new Process(), new Process()];
const mockedCreateProcesses = jest.spyOn(chimp, "_createProcesses");
mockedCreateProcesses.mockReturnValue(processes);
const callback = jest.fn();
chimp._startProcesses(callback);
expect(typeof callback.mock.calls[0][0]).toBe('undefined');
expect(callback.mock.calls.length).toBe(1);
expect(processes[0].state).toBe('started');
expect(processes[1].state).toBe('started');
mockedCreateProcesses.mockRestore();
});
it('bubbles up errors in callback if an processes callback with an error', () => {
jest.dontMock('async');
const Chimp = require('../lib/chimp');
const chimp = new Chimp();
function Process() {
this.state = 'constructed';
}
Process.prototype.start = function (callback) {
this.state = 'started';
callback('error!');
};
const processes = [new Process('1'), new Process('2')];
const mockedCreateProcesses = jest.spyOn(chimp, "_createProcesses");
mockedCreateProcesses.mockReturnValue(processes);
const callback = jest.fn();
chimp._startProcesses(callback);
expect(callback.mock.calls[0][0]).toBe('error!');
expect(callback.mock.calls.length).toBe(1);
expect(processes[0].state).toBe('started');
expect(processes[1].state).toBe('constructed');
mockedCreateProcesses.mockRestore();
});
it('cancels the isInterrupting flag on error', () => {
const _ = require('underscore');
const async = require('async');
const Chimp = require('../lib/chimp');
const chimp = new Chimp();
chimp.isInterrupting = true;
const mockedCreateProcesses = jest.spyOn(chimp, "_createProcesses");
mockedCreateProcesses.mockImplementation(() => [{ start: { bind: () => 'yo' } }]);
async.series = jest.fn().mockImplementation((procs, func) => {
func('error');
});
chimp._startProcesses(jest.fn());
expect(chimp.isInterrupting).toBe(false);
mockedCreateProcesses.mockRestore();
});
});
describe('_createProcesses', () => {
it('adds a phantom', () => {
const Phantom = require('../lib/phantom.js');
const Chimp = require('../lib/chimp.js');
const options = {browser: 'phantomjs'};
const chimp = new Chimp(options);
const processes = chimp._createProcesses();
expect(Phantom.mock.calls[0][0]).toBe(options);
expect(processes.length).toBe(2);
});
it('adds a selenium when no browser is passed', () => {
let Selenium = require('../lib/selenium.js');
const Chimp = require('../lib/chimp.js');
Selenium = jest.fn();
const options = {browser: 'some-browser', host: ''};
const chimp = new Chimp(options);
const processes = chimp._createProcesses();
expect(Selenium.mock.calls[0][0]).toBe(options);
expect(processes.length).toBe(2);
});
it('does not add selenium when SauceLabs is the host', () => {
let Selenium = require('../lib/selenium.js');
const Chimp = require('../lib/chimp.js');
Selenium = jest.fn();
const options = {host: 'saucelabs'};
const chimp = new Chimp(options);
const processes = chimp._createProcesses();
expect(Selenium.mock.calls.length).toBe(0);
expect(processes.length).toBe(1);
});
it('adds cucumber last', () => {
const Chimp = require('../lib/chimp.js');
const options = {browser: 'phantomjs'};
const chimp = new Chimp(options);
const processes = chimp._createProcesses();
expect(typeof processes[0].cucumberChild).toBe('undefined');
expect(typeof processes[1].cucumberChild).not.toBe('undefined');
});
it('should add at least one process', () => {
const chimp = new Chimp({browser: 'phantomjs'});
const processes = chimp._createProcesses();
expect(processes.length).not.toBe(0);
});
});
});