gt 0.10.0 → 2.7.0

package/src/TestRunner.js

@@ -1,223 +0,0 @@
-var ConsoleHider = require('./utils/ConsoleHider').ConsoleHider;
-var TestRunInfo = require('./TestRunInfo').TestRunInfo;
-var BasicAssertions = require('./assertions/PrimaryAssertions');
-var SecondaryAssertions = require('./assertions/SecondaryAssertions');
-var TertiaryAssertions = require('./assertions/TertiaryAssertions');
-
-var check = require('check-types');
-var _ = require('lodash');
-var async = require('async');
-var Q = require('q');
-var quote = require('quote');
-
-var TestRunner = {
-	init: function (config) {
-		config = config || {};
-		config.output = config.output || false;
-
-		TestRunInfo._currentTest = null;
-		this.modules = null;
-		this.config = config;
-	},
-
-	// todo: add started / finished info
-	executeTest: function (test, callback) {
-		check.verify.object(test, 'expected a test object');
-		check.verify.fn(callback, 'expected callback object');
-
-		test.check();
-		if (test.skip) {
-			log.info('skipping test', quote(test.name));
-			callback();
-			return;
-		}
-
-		TestRunInfo._currentTest = test;
-		var hider = null;
-
-		function onTestFinished() {
-			if (hider) {
-				test.stdout = hider.restoreConsole();
-			}
-			log.debug('finished test', quote(test.name),
-				TestRunInfo._currentTest.assertions + ' assertions,',
-				TestRunInfo._currentTest.broken, 'broken');
-
-			try {
-				TestRunInfo._afterTest();
-			} catch (err) {
-				console.error('caught error after test', quote(test.name));
-				console.error(err);
-				callback(err);
-				return;
-			}
-
-			callback();
-		}
-
-		function printFirstStackLines(stack) {
-			if (!stack) {
-				return;
-			}
-
-			var lines = stack.split('\n');
-			var maxLines = 5;
-			if (lines.length < maxLines) {
-				console.log('stack:\n', lines.join('\n'));
-			} else {
-				var firstLines = lines.slice(0, maxLines).join('\n');
-				console.log('stack:\n', firstLines);
-				console.log(lines.length - maxLines + ' stack lines clipped');
-			}
-		}
-
-		try {
-			test.start(onTestFinished);
-
-			if (!this.config.output) {
-				hider = new ConsoleHider();
-				hider.hideConsole();
-			} else {
-				log.info('starting test', quote(test.name));
-			}
-			test.code(global.gt);
-		} catch (errors) {
-			console.error('crash in test', quote(test.name));
-			console.error(errors);
-			// console.error(errors.stack);
-			printFirstStackLines(errors.stack);
-
-			test.hasCrashed = true;
-			test.finished = new Date();
-			test.async = false;
-		} finally {
-			if (TestRunInfo._currentTest && !TestRunInfo._currentTest.async) {
-				TestRunInfo._currentTest.finished = new Date();
-				// console.log('sync test', TestRunInfo._currentTest.name, 'has finished');
-				onTestFinished();
-			}
-		}
-	},
-
-	runTests: function (verifyIntegrity, onAllTestsFinished) {
-		check.verify.array(this.modules, 'runner has no test collection');
-		check.verify.fn(onAllTestsFinished, 'missing all tests completed function');
-
-		async.eachSeries(this.modules,
-			this.runModule.bind(this, verifyIntegrity),
-			function (err) {
-				if (err) {
-					console.error('caught error running modules', err);
-				}
-				// console.log('finished all tests from all modules');
-				onAllTestsFinished(err);
-			});
-	},
-
-	runSingleTest: function (preTest, verifyIntegrity, postTest, test, callback) {
-		check.verify.fn(preTest, 'missing preTest');
-		check.verify.fn(verifyIntegrity, 'missing verifyIntegrity');
-		check.verify.fn(postTest, 'missing postTest');
-
-		check.verify.object(test, 'missing test');
-		check.verify.fn(callback, 'missing callback function');
-
-		function executePreTest(fn, errorCallback) {
-			try {
-				return fn();
-			} catch (err) {
-				console.log('pretest error\n', err);
-				errorCallback(err);
-			}
-		}
-
-		var self = this;
-
-		Q.when(executePreTest(preTest, callback)).then(function () {
-			self.executeTest(test, function () {
-				verifyIntegrity();
-
-				Q.when(postTest()).then(function () {
-					callback();
-				});
-			});
-		}).catch(function (err) {
-			console.error('error stack\n' + err.stack);
-			callback(err);
-		});
-	},
-
-	runModule: function (verifyIntegrity, testModule, allModuleTestsCompleted) {
-		check.verify.fn(verifyIntegrity, 'verify integrity should be a function');
-		check.verify.object(testModule, 'missing test module');
-		check.verify.fn(allModuleTestsCompleted, 'missing module completed function');
-
-		if (testModule.lifecycle.setupOnce) {
-			check.verify.fn(testModule.lifecycle.setupOnce, 'setupOnce should be a function');
-		}
-
-		if (testModule.lifecycle.teardownOnce) {
-			check.verify.fn(testModule.lifecycle.teardownOnce, 'teardownOnce should be a function');
-		}
-
-		var preEachTest = testModule.lifecycle.setup;
-		check.verify.fn(preEachTest, 'module setup should be a function');
-
-		var postEachTest = testModule.lifecycle.teardown;
-		check.verify.fn(postEachTest, 'module teardown should be a function');
-
-		log.debug('starting module', quote(testModule.name));
-		var testSteps = this.runSingleTest.bind(this, preEachTest, verifyIntegrity, postEachTest);
-
-		function runOnce(fn, errorCallback) {
-			if (!check.fn(fn)) {
-				return;
-			}
-			try {
-				return fn();
-			} catch (err) {
-				console.log('module', quote(testModule.name), 'run once error\n', err);
-				testModule.crashed = true;
-				errorCallback(err);
-			}
-		}
-
-		Q.when(runOnce(testModule.lifecycle.setupOnce, allModuleTestsCompleted))
-		.then(function () {
-			async.eachSeries(testModule._tests,
-				testSteps,
-				function (err) {
-					if (err) {
-						console.error('caught error in module', quote(testModule.name));
-						testModule.crashed = true;
-						testModule._tests.forEach(function (test) {
-							test.hasCrashed = true;
-						});
-					}
-					Q.when(runOnce(testModule.lifecycle.teardownOnce, allModuleTestsCompleted))
-					.then(function () {
-						allModuleTestsCompleted(err);
-					});
-				});
-		}).catch(function (err) {
-			console.error('module', quote(module.name), 'error stack\n' + err.stack);
-			allModuleTestsCompleted(err);
-		});
-	}
-};
-
-_.extend(TestRunner, BasicAssertions, SecondaryAssertions, TertiaryAssertions);
-
-TestRunner.getBindMethods = function () {
-	return this.basic().concat(this.secondary()).concat(TertiaryAssertions.assertions());
-};
-
-process.on('error', function (err) {
-	if (TestRunInfo._currentTest) {
-		console.error('Crash in test', TestRunner._currentTest);
-		console.error(err);
-		process.exit(1);
-	}
-});
-
-exports.TestRunner = TestRunner;

package/src/UnitTest/CollectionMethods.js

@@ -1,97 +0,0 @@
-var ModuleTests = require("./ModuleTests").ModuleTests;
-var getCallerFilename = require('../utils/utils').getCallerFilename;
-var check = require('check-types');
-var quote = require('quote');
-
-var CollectionMethods = {
-	module: function (name, lifecycle) {
-		check.verify.string(name, "module name should be a string");
-		check.verify.array(this.modules, "modules is not an array");
-		check.verify.object(this.testOnlyModules, 'test modules should be an object');
-
-		if (this.shouldTestModule(name) && !this.shouldSkipModule(name)) {
-			log.debug("module " + quote(name));
-			this.currentModule = new ModuleTests(name, lifecycle);
-			this.modules.push(this.currentModule);
-		}
-	},
-
-	_addTest: function (options) {
-		check.verify.object(options, 'missing test options');
-		options.skip = !!options.skip;
-		options.async = !!options.async;
-
-		this._startModuleIfNecessary();
-		check.verify.object(this.currentModule, "current module is not defined, cannot add test", options.name);
-
-		if (check.number(options.code) && !options.timeout) {
-			options.timeout = options.code;
-		}
-
-		if (check.fn(options.expected) && !check.fn(options.code)) {
-			options.code = options.expected;
-			options.expected = undefined;
-		}
-
-		if (check.fn(options.name) && !check.fn(options.code)) {
-			options.code = options.name;
-			options.name = options.code.name;
-		}
-		check.verify.string(options.name, 'missing unit test name');
-		var testFilename = getCallerFilename() || this.currentFileName;
-		check.verify.string(testFilename, 'could not get filename for test', options.name);
-		if (options.timeout) {
-			options.timeout = +options.timeout;
-		}
-
-		this.currentModule.add({
-			name: options.name,
-			code: options.code,
-			filename: testFilename,
-			skip: options.skip,
-			async: options.async,
-			timeout: options.timeout,
-			expected: options.expected
-		});
-	},
-
-	asyncTest: function (name, expected, code, timeoutMs) {
-		this._addTest({
-			name: name,
-			expected: expected,
-			code: code,
-			skip: false,
-			async: true,
-			timeout: timeoutMs
-		});
-	},
-
-	async: function () {
-		this.asyncTest.apply(this, Array.prototype.slice.call(arguments));
-	},
-
-	test: function (name, expected, code) {
-		this._addTest({
-			name: name,
-			code: code,
-			expected: expected,
-			skip: false,
-			async: false
-		});
-	},
-
-	notest: function () {
-		this.skip.apply(this, Array.prototype.slice.call(arguments));
-	},
-
-	skip: function (name, expected, code) {
-		this._addTest({
-			name: name,
-			code: code,
-			expected: expected,
-			skip: true,
-			async: false
-		});
-	}
-};
-exports.CollectionMethods  = CollectionMethods;

package/src/UnitTest/ModuleTests.js

@@ -1,104 +0,0 @@
-/* jshint indent:2 */
-var Test = require('./Test').Test;
-var _ = require('lodash');
-var check = require('check-types');
-var verify = check.verify;
-var pluck = require('../utils/pluckFunction');
-verify.fn(pluck, 'could not load pluck function');
-
-var noop = function () {};
-
-var ModuleTests = function (name, lifecycle) {
-  this._tests = [];
-  if (name) {
-    verify.unemptyString(name, 'module name should be a string, not', name);
-  }
-  this.name = name || 'default';
-  if (lifecycle) {
-    check.verify.object(lifecycle, 'lifecycle should be an object');
-  }
-  this.lifecycle = lifecycle || {};
-  this.lifecycle.setup = this.lifecycle.setup || noop;
-  this.lifecycle.teardown = this.lifecycle.teardown || noop;
-
-  // crashed somewhere in the lifecycle functions
-  this.crashed = false;
-};
-
-ModuleTests.prototype.add = function (options) {
-  verify.object(options, 'missing test options');
-  verify.string(options.name, 'missing test name');
-  verify.fn(options.code, 'expected a test function');
-  verify.string(options.filename, 'expected a filename string');
-
-  verify.array(this._tests, 'this._tests is defined');
-  options.moduleName = this.name;
-  var test = new Test(options);
-  this._tests.push(test);
-};
-
-ModuleTests.prototype.getNumberOfTests = function () {
-  return this._tests.length;
-};
-
-ModuleTests.prototype.getTests = function () {
-  return this._tests;
-};
-
-ModuleTests.prototype.getFilename = function () {
-  var filenames = this.getTestFilenames();
-  verify.array(filenames, 'filenames should be an array');
-  return filenames[0];
-};
-
-ModuleTests.prototype.getTestFilenames = function () {
-  var filenames = _.pluck(this._tests, 'filename');
-  filenames = _.uniq(filenames);
-  return filenames;
-};
-
-ModuleTests.prototype.hasFailed = function () {
-  return !this.crashed && this._tests.some(pluck('hasFailed'));
-};
-
-ModuleTests.prototype.notRun = function () {
-  return !this.getFailedTests() && !this.getPassedTests();
-};
-
-ModuleTests.prototype.getFailedTests = function () {
-  verify.array(this._tests, 'tests are not defined');
-  var failedTests = this._tests.filter(pluck('hasFailed'));
-  var crashedTests = this._tests.filter(pluck('hasCrashed'));
-  return failedTests.concat(crashedTests);
-};
-
-ModuleTests.prototype.getPassedTests = function () {
-  return this._tests.reduce(function (good, test) {
-    return good + !test.hasFailed();
-  }, 0);
-};
-
-ModuleTests.prototype.passedPercentage = function () {
-  var failed = this.getFailedTests();
-  var goodTests = this._tests.length - failed.length;
-  var percent = (this._tests.length > 0 ? goodTests / this._tests.length : 1) * 100;
-  return percent;
-};
-
-ModuleTests.prototype.duration = function () {
-  if (this.crashed) {
-    return 0;
-  }
-  return this._tests.reduce(function (total, test) {
-    return total += test.duration();
-  }, 0);
-};
-
-ModuleTests.prototype.filterTests = function (expression) {
-  console.assert(_.isRegExp(expression), 'filter expression should be RegExp');
-  this._tests = this._tests.filter(function (test) {
-    return expression.test(test.name);
-  });
-};
-
-exports.ModuleTests = ModuleTests;

package/src/UnitTest/Test.js

@@ -1,85 +0,0 @@
-var TestBaseInfo = require('./TestBaseInfo').TestBaseInfo;
-var TestInfo = require('./TestInfo').TestInfo;
-var TestAsync = require('./TestAsync').TestAsync;
-var TestReport = require('./TestReport').TestReport;
-var _ = require('lodash');
-var check = require('check-types');
-
-// individual unit test
-var Test = function (options) {
-	TestBaseInfo.call(this, options);
-	TestInfo.call(this);
-	TestAsync.call(this, options);
-};
-
-Test.prototype = Object.create(TestAsync.prototype);
-_.extend(Test.prototype, TestInfo.prototype);
-_.extend(Test.prototype, TestReport);
-
-Test.prototype.hasFailed = function () {
-	if (!this.hasReallyFailed()) {
-		return false;
-	}
-	if (this.expectsCertainStatus()) {
-		return !this.achievedExpectedResult();
-	}
-	return true;
-};
-
-Test.prototype.hasReallyFailed = function () {
-	var stat = this.status();
-	check.verify.string(stat, 'could not get status for', this.name);
-	return stat !== Test.PASS && stat !== Test.SKIP;
-};
-
-Test.prototype.expectsCertainStatus = function () {
-	if (this.name.indexOf(Test.PASS) === 0) {
-		return true;
-	}
-	if (this.name.indexOf(Test.FAIL) === 0) {
-		return true;
-	}
-	if (this.name.indexOf(Test.CRASH) === 0) {
-		return true;
-	}
-	if (this.name.indexOf(Test.INCOMPLETE) === 0) {
-		return true;
-	}
-	return false;
-};
-
-Test.prototype.achievedExpectedResult = function() {
-	var stat = this.status();
-	check.verify.string(stat, 'could not get test status for', this.name);
-	return this.name.indexOf(stat) === 0;
-};
-
-Test.prototype.status = function () {
-	check.verify.string(Test.PASS, "Test.PASS is undefined");
-	if (check.number(this.expected) && (this.expected !== this.assertions)) {
-		return Test.INCOMPLETE;
-	}
-
-	if (this.timedOut) {
-		return Test.INCOMPLETE;
-	}
-	if (this.hasCrashed) {
-		return Test.CRASH;
-	}
-	if (this.skip) {
-		return Test.SKIP;
-	}
-	if (this.broken > 0) {
-		log.debug(this.name, "has", this.broken, "broken assertions, failed");
-		return Test.FAIL;
-	}
-	return Test.PASS;
-};
-
-Test.PASS = "PASS";
-Test.FAIL = "FAIL";
-Test.CRASH = "CRASH";
-Test.INCOMPLETE = "INCOMPLETE";
-Test.SKIP = "SKIP";
-
-exports.Test = Test;

package/src/UnitTest/TestAsync.js

@@ -1,78 +0,0 @@
-var check = require('check-types');
-var quote = require('quote');
-
-// async unit test support
-var TestAsync = function(options) {
-	this.async = options.async;
-	this.timeout = +options.timeout || 5000;
-	check.verify.positiveNumber(this.timeout, 'should be positive number (timeout ms)', this.timeout);
-};
-
-TestAsync.prototype.start = function (callback, timeout) {
-	this.hasRun = true;
-	this.started = new Date();
-	// console.log('test "' + this.name + '" started on', this.started);
-	if (this.async) {
-		// console.log('starting async test', this.name);
-		check.verify.fn(callback, 'missing callback function in', this.name);
-		timeout = timeout || this.timeout;
-		check.verify.positiveNumber(timeout, 'expect timeout number, not', timeout);
-		this.startTimeout(callback, timeout);
-	} else {
-		// allow sync tests to execute callback, for example after calling
-		// gt.test(
-		// 		gt.stop();
-		//		gt.start();
-		this.onFinished = callback;
-	}
-};
-
-TestAsync.prototype.startTimeout = function(callback, timeout) {
-	timeout = timeout || 5000;
-	check.verify.fn(callback, 'callback should be a function');
-	check.verify.positiveNumber(timeout, 'invalid timeout', timeout);
-	this.onFinished = callback;
-	this.timeoutId = setTimeout(this.checkTestIsStillRunning.bind(this), timeout);
-};
-
-TestAsync.prototype.checkTestIsStillRunning = function() {
-	// console.log('checking if still running test "' + this.name + '"');
-	console.assert(this.started, 'missing started timestampt for', this.name);
-	if (typeof this.finished === 'undefined') {
-		this.finished = new Date();
-		this.timedOut = true;
-		log.error('test ' + quote(this.name) + ' is still executing, timed out after',
-			(this.finished - this.started) + 'ms');
-		check.verify.fn(this.onFinished, 'missing on finished function');
-		setTimeout(this.onFinished, 1);
-	}
-};
-
-TestAsync.prototype.continueWithTest = function() {
-	// console.log('start called on test', this.name);
-	console.assert(this.async, 'only async unit tests should call start()');
-	console.assert(this.timeoutId, 'missing timeout id when continuing test', this);
-	clearTimeout(this.timeoutId);
-	delete this.timeoutId;
-
-	this.finished = new Date();
-	// current test will continue, then we get control back
-	// and can run next async test (if any)
-	setTimeout(this.onFinished, 1);
-};
-
-TestAsync.prototype.pause = function () {
-	this.async = true;
-	this.timeoutId = setTimeout(this.checkTestIsStillRunning.bind(this), 5000);
-};
-
-TestAsync.prototype.duration = function() {
-	if (this.skip) {
-		return 0;
-	}
-	console.assert(this.started, 'missing started timestamp for test ' + quote(this.name));
-	console.assert(this.finished, 'missing finished timestamp for test ' + quote(this.name));
-	return this.finished - this.started;
-}
-
-module.exports.TestAsync = TestAsync;

package/src/UnitTest/TestBaseInfo.js

@@ -1,21 +0,0 @@
-var check = require('check-types');
-
-// basic test information: name, parent module name, source filename, etc
-var TestBaseInfo = function (options) {
-	check.verify.object(options, 'missing Test options');
-	check.verify.string(options.name, "test name should be a string, not", options.name);
-	check.verify.string(options.moduleName, options.name, "should have module name");
-	check.verify.fn(options.code, options.name, "should have code function");
-	check.verify.string(options.filename, options.name, 'should have original source filename');
-
-	this.name = options.name;
-	this.code = options.code;
-	this.module = options.moduleName;
-	this.filename = options.filename;
-	this.skip = options.skip;
-
-	this.expected = check.number(options.expected) ? options.expected : undefined;
-};
-
-module.exports.TestBaseInfo = TestBaseInfo;
-