jasmine-node - npm Package Compare versions

Gruntfile.coffee

index.js

lib/jasmine-node/auto-test.js

lib/jasmine-node/file-finder.js

lib/jasmine-node/jasmine-loader.js

lib/jasmine-node/jasmine/boot.js

lib/jasmine-node/jasmine/jasmine-2.0.0.js

lib/jasmine-node/runner.js

scripts/specs.sh

spec/SampleSpec.js

spec/Test.Test.js

src/auto-test.coffee

src/file-finder.coffee

src/jasmine-loader.coffee

src/jasmine/boot.coffee

src/reporter.coffee

src/runner.coffee

2

bower.json

		{
		"name": "jasmine-node",
		"version": "1.12.0",
		"version": "2.0.0",
		"homepage": "https://github.com/mhevery/jasmine-node",
		@@ -5,0 +5,0 @@ "authors": [

522

lib/jasmine-node/reporter.js

		(function() {
		//
		// Imports
		//
		var util;
		try {
		util = require('util')
		} catch(e) {
		util = require('sys')
		}
		var TerminalReporter, noOp, util, _,
		__bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

		var jasmineNode = {};
		//
		// Helpers
		//
		function noop() {}
		_ = require('underscore');

		util = null;

		jasmineNode.TerminalReporter = function(config) {
		this.print_ = config.print \|\| function (str) { process.stdout.write(util.format(str)); };
		this.color_ = config.color ? this.ANSIColors : this.NoColors;

		this.started_ = false;
		this.finished_ = false;

		this.callback_ = config.onComplete \|\| false

		this.suites_ = [];
		this.specResults_ = {};
		this.failures_ = [];
		this.includeStackTrace_ = config.includeStackTrace === false ? false : true;
		this.stackFilter_ = config.stackFilter \|\| function(t) { return t; };
		try {
		util = require('util');
		} catch (_error) {
		util = require('sys');
		}

		noOp = function() {};

		jasmineNode.TerminalReporter.prototype = {
		reportRunnerStarting: function(runner) {
		this.started_ = true;
		this.startedAt = new Date();
		var suites = runner.topLevelSuites();
		for (var i = 0; i < suites.length; i++) {
		var suite = suites[i];
		this.suites_.push(this.summarize_(suite));
		TerminalReporter = (function() {
		TerminalReporter.prototype.ANSIColors = {
		pass: function() {
		return '\x1B[32m';
		},
		fail: function() {
		return '\x1B[31m';
		},
		specTiming: function() {
		return '\x1B[34m';
		},
		suiteTiming: function() {
		return '\x1B[33m';
		},
		ignore: function() {
		return '\x1B[37m';
		},
		neutral: function() {
		return '\x1B[0m';
		}
		},
		};

		ANSIColors: {
		pass: function() { return '\033[32m'; }, // Green
		fail: function() { return '\033[31m'; }, // Red
		specTiming: function() { return '\033[34m'; }, // Blue
		suiteTiming: function() { return '\033[33m'; }, // Yelow
		ignore: function() { return '\033[37m'; }, // Light Gray
		neutral: function() { return '\033[0m'; } // Normal
		},
		TerminalReporter.prototype.NoColors = {
		pass: function() {
		return '';
		},
		fail: function() {
		return '';
		},
		specTiming: function() {
		return '';
		},
		suiteTiming: function() {
		return '';
		},
		ignore: function() {
		return '';
		},
		neutral: function() {
		return '';
		}
		};

		NoColors: {
		pass: function() { return ''; },
		fail: function() { return ''; },
		specTiming: function() { return ''; },
		suiteTiming: function() { return ''; },
		ignore: function() { return ''; },
		neutral: function() { return ''; }
		},
		function TerminalReporter(config) {
		var defaults;
		this.config = config != null ? config : {};
		this.specDone = __bind(this.specDone, this);
		this.specStarted = __bind(this.specStarted, this);
		this.suiteDone = __bind(this.suiteDone, this);
		this.suiteStarted = __bind(this.suiteStarted, this);
		this.jasmineDone = __bind(this.jasmineDone, this);
		this.jasmineStarted = __bind(this.jasmineStarted, this);
		defaults = {
		onComplete: noOp,
		noStackTrace: true,
		verbose: false,
		print: function(str) {
		process.stdout.write(util.format(str));
		},
		stackFilter: function(t) {
		return t;
		}
		};
		this.config = _.defaults(this.config, defaults);
		this.config.color = this.config.noColor ? this.NoColors : this.ANSIColors;
		this.counts = {
		tests: 0,
		failures: 0,
		skipped: 0
		};
		this.allSpecs = {};
		this.suiteNestLevel = 0;
		this.done = false;
		this.suiteTimes = {};
		return;
		}

		summarize_: function(suiteOrSpec) {
		var isSuite = suiteOrSpec instanceof jasmine.Suite;
		TerminalReporter.prototype.jasmineStarted = function(runner) {
		this.startedAt = +(new Date);
		};

		// We could use a separate object for suite and spec
		var summary = {
		id: suiteOrSpec.id,
		name: suiteOrSpec.description,
		type: isSuite? 'suite' : 'spec',
		suiteNestingLevel: 0,
		children: []
		TerminalReporter.prototype.jasmineDone = function() {
		var color, elapsed, now, results, _base;
		if (this.done) {
		return;
		}
		this.done = true;
		now = +(new Date);
		elapsed = now - this.startedAt;
		this.printFailures();
		this.config.print("\n\nFinished in " + (elapsed / 1000) + " seconds\n");
		results = ["" + this.counts.tests + " Tests", "" + this.counts.failures + " Failures", "" + this.counts.skipped + " Skipped\n\n"];
		if (this.counts.failures > 0) {
		color = this.config.color.fail();
		} else {
		color = this.config.color.pass();
		}
		global.jasmineResult = {
		fail: this.counts.failures > 0
		};
		this.config.print(this.stringWithColor(results.join(', '), color));
		if (typeof (_base = this.config).onComplete === "function") {
		_base.onComplete();
		}
		};

		if (isSuite) {
		var calculateNestingLevel = function(examinedSuite) {
		var nestingLevel = 0;
		while (examinedSuite.parentSuite !== null) {
		nestingLevel += 1;
		examinedSuite = examinedSuite.parentSuite;
		}
		return nestingLevel;
		};
		TerminalReporter.prototype.suiteStarted = function(suite) {
		this.suiteTimes[suite.id] = +(new Date);
		if (this.config.verbose) {
		this.printVerboseSuiteStart(suite);
		}
		this.suiteNestLevel++;
		suite.parent = this.currentSuite;
		this.currentSuite = suite;
		};

		summary.suiteNestingLevel = calculateNestingLevel(suiteOrSpec);

		var children = suiteOrSpec.children();
		for (var i = 0; i < children.length; i++) {
		summary.children.push(this.summarize_(children[i]));
		}
		TerminalReporter.prototype.printVerboseSuiteStart = function(suite) {
		var i, msg, _i, _ref;
		msg = '';
		for (i = _i = 0, _ref = this.suiteNestLevel; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
		msg += " ";
		}
		msg += this.stringWithColor("" + suite.description + " Start\n", this.config.color.ignore());
		return this.config.print(msg);
		};

		return summary;
		},

		// This is heavily influenced by Jasmine's Html/Trivial Reporter
		reportRunnerResults: function(runner) {
		this.reportFailures_();

		var results = runner.results();
		var resultColor = (results.failedCount > 0) ? this.color_.fail() : this.color_.pass();

		var specs = runner.specs();
		var specCount = specs.length;

		var message = "\n\nFinished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + " seconds";
		this.printLine_(message);

		// This is what jasmine-html.js has
		//message = "" + specCount + " spec" + ( specCount === 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount === 1) ? "" : "s");

		this.printLine_(this.stringWithColor_(this.printRunnerResults_(runner), resultColor));

		this.finished_ = true;
		if(this.callback_) { this.callback_(runner); }
		},

		reportFailures_: function() {
		if (this.failures_.length === 0) {
		TerminalReporter.prototype.suiteDone = function(suite) {
		var _ref;
		if (!this.suiteTimes[suite.id]) {
		return;
		}
		this.suiteNestLevel--;
		this.suiteTimes[suite.id] = (+(new Date)) - this.suiteTimes[suite.id];
		if (this.config.verbose) {
		this.printVerboseSuiteDone(suite);
		}
		delete this.suiteTimes[suite.id];
		this.currentSuite = (_ref = this.currentSuite.parent) != null ? _ref : null;
		};

		var indent = ' ', failure;
		this.printLine_('\n');

		this.print_('Failures:');

		for (var i = 0; i < this.failures_.length; i++) {
		failure = this.failures_[i];
		this.printLine_('\n');
		this.printLine_(' ' + (i + 1) + ') ' + failure.spec);
		this.printLine_(' Message:');
		this.printLine_(' ' + this.stringWithColor_(failure.message, this.color_.fail()));
		if (this.includeStackTrace_) {
		this.printLine_(' Stacktrace:');
		this.print_(' ' + this.stackFilter_(failure.stackTrace));
		}
		TerminalReporter.prototype.printVerboseSuiteDone = function(suite) {
		var i, msg, _i, _ref;
		msg = '';
		for (i = _i = 0, _ref = this.suiteNestLevel; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
		msg += " ";
		}
		},
		msg += this.stringWithColor("" + suite.description + " Finish", this.config.color.ignore());
		msg += this.stringWithColor(" - " + this.suiteTimes[suite.id] + " ms\n\n", this.config.color.suiteTiming());
		return this.config.print(msg);
		};

		reportSuiteResults: function(suite) {
		// Not used in this context
		},
		TerminalReporter.prototype.specStarted = function(spec) {
		this.specStart = +(new Date);
		this.counts.tests++;
		};

		reportSpecResults: function(spec) {
		var result = spec.results();
		var msg = '';
		if (result.skipped) {
		msg = this.stringWithColor_('-', this.color_.ignore());
		} else if (result.passed()) {
		msg = this.stringWithColor_('.', this.color_.pass());
		TerminalReporter.prototype.specDone = function(spec) {
		var msg, _base, _name;
		((_base = this.allSpecs)[_name = this.currentSuite.id] != null ? _base[_name] : _base[_name] = []).push(spec);
		if (this.config.verbose) {
		msg = this.makeVerbose(spec);
		} else {
		msg = this.stringWithColor_('F', this.color_.fail());
		this.addFailureToFailures_(spec);
		msg = this.makeSimple(spec);
		}
		this.spec_results += msg;
		this.print_(msg);
		},
		this.config.print(msg);
		};

		addFailureToFailures_: function(spec) {
		var result = spec.results();
		var failureItem = null;
		TerminalReporter.prototype.makeSimple = function(spec) {
		var msg;
		msg = '';
		switch (spec.status) {
		case 'pending':
		this.counts.skipped++;
		msg = this.stringWithColor('-', this.config.color.ignore());
		break;
		case 'passed':
		msg = this.stringWithColor('.', this.config.color.pass());
		break;
		case 'failed':
		this.counts.failures++;
		msg = this.stringWithColor('F', this.config.color.fail());
		break;
		default:
		msg = this.stringWithColor('U', this.config.color.fail());
		}
		return msg;
		};

		var items_length = result.items_.length;
		for (var i = 0; i < items_length; i++) {
		if (result.items_[i].passed_ === false) {
		failureItem = result.items_[i];

		var failure = {
		spec: spec.suite.getFullName() + " " + spec.description,
		message: failureItem.message,
		stackTrace: failureItem.trace.stack
		}

		this.failures_.push(failure);
		}
		TerminalReporter.prototype.makeVerbose = function(spec) {
		var elapsed, i, msg, _i, _ref;
		elapsed = (+(new Date)) - this.specStart;
		msg = '';
		for (i = _i = 0, _ref = this.suiteNestLevel; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
		msg += " ";
		}
		},

		printRunnerResults_: function(runner){
		var results = runner.results();
		var specs = runner.specs();
		var msg = '';
		var skippedCount = 0;
		specs.forEach(function(spec) {
		if (spec.results().skipped) {
		skippedCount++;
		}
		});
		var passedCount = specs.length - skippedCount;
		msg += passedCount + ' test' + ((passedCount === 1) ? '' : 's') + ', ';
		msg += results.totalCount + ' assertion' + ((results.totalCount === 1) ? '' : 's') + ', ';
		msg += results.failedCount + ' failure' + ((results.failedCount === 1) ? '' : 's') + ', ';
		msg += skippedCount + ' skipped' + '\n';
		switch (spec.status) {
		case 'pending':
		this.counts.skipped++;
		msg += this.stringWithColor("" + spec.description, this.config.color.ignore());
		break;
		case 'passed':
		msg += this.stringWithColor("" + spec.description, this.config.color.pass());
		break;
		case 'failed':
		this.counts.failures++;
		msg += this.stringWithColor("" + spec.description, this.config.color.fail());
		break;
		default:
		msg += this.stringWithColor("" + spec.description, this.config.color.fail());
		}
		msg += this.stringWithColor(" - " + elapsed + " ms\n", this.config.color.specTiming());
		return msg;
		},
		};

		// Helper Methods //
		stringWithColor_: function(stringValue, color) {
		return (color \|\| this.color_.neutral()) + stringValue + this.color_.neutral();
		},

		printLine_: function(stringValue) {
		this.print_(stringValue);
		this.print_('\n');
		}
		};

		// ***************************************************************
		// TerminalVerboseReporter uses the TerminalReporter's constructor
		// ***************************************************************
		jasmineNode.TerminalVerboseReporter = function(config) {
		jasmineNode.TerminalReporter.call(this, config);
		// The extra field in this object
		this.indent_ = 0;
		this.specTimes_ = {};
		this.suiteTimes_ = {};
		this.suiteResults_ = {};
		}


		jasmineNode.TerminalVerboseReporter.prototype = {

		reportSpecStarting: function(spec) {
		now = new Date().getTime();
		this.specTimes_[spec.id] = now;
		var suite = spec.suite;
		while (suite) {
		if (!this.suiteTimes_[suite.id]) {
		this.suiteTimes_[suite.id] = now;
		TerminalReporter.prototype.printFailures = function() {
		var count, failure, indent, spec, specs, stack, suite, _i, _j, _len, _len1, _ref, _ref1;
		if (!(this.counts.failures > 0)) {
		return;
		}
		this.config.print("\n\nFailures:");
		indent = " ";
		count = 0;
		_ref = this.allSpecs;
		for (suite in _ref) {
		specs = _ref[suite];
		for (_i = 0, _len = specs.length; _i < _len; _i++) {
		spec = specs[_i];
		_ref1 = spec.failedExpectations;
		for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
		failure = _ref1[_j];
		count++;
		this.config.print("\n\n" + indent + count + ") " + spec.fullName + "\n" + indent + indent + "Message:\n" + indent + indent + indent + (this.stringWithColor(failure.message, this.config.color.fail())));
		if (!this.config.noStackTrace) {
		stack = this.config.stackFilter(failure.stack);
		this.config.print("\n\n" + indent + indent + "Stacktrace:\n" + indent + indent + indent + stack);
		}
		suite = suite.parentSuite;
		}
		}
		},

		reportSpecResults: function(spec) {
		var elapsed = new Date().getTime() - this.specTimes_[spec.id];

		if (spec.results().failedCount > 0) {
		this.addFailureToFailures_(spec);
		}
		};

		this.specResults_[spec.id] = {
		messages: spec.results().getItems(),
		result: spec.results().failedCount > 0 ? 'failed' : 'passed',
		runtime: elapsed
		};
		},

		reportSuiteResults: function(suite) {
		var startTime = this.suiteTimes_[suite.id];
		if (startTime) {
		var elapsed = new Date().getTime() - startTime;
		this.suiteResults_[suite.id] = {
		runtime: elapsed
		};
		}
		},

		reportRunnerResults: function(runner) {
		var messages = new Array();
		this.buildMessagesFromResults_(messages, this.suites_);

		var messages_length = messages.length;
		for (var i = 0; i < messages_length-1; i++) {
		this.printLine_(messages[i]);
		TerminalReporter.prototype.stringWithColor = function(string, color) {
		if (color == null) {
		color = this.config.color.neutral();
		}
		return "" + color + string + (this.config.color.neutral());
		};

		this.print_(messages[messages_length-1]);
		return TerminalReporter;

		// Call the parent object's method
		jasmineNode.TerminalReporter.prototype.reportRunnerResults.call(this, runner);
		},
		})();

		buildMessagesFromResults_: function(messages, results, depth) {
		var element, specResult, specIndentSpaces, msg = '';
		depth = (depth === undefined) ? 0 : depth;

		var results_length = results.length;
		for (var i = 0; i < results_length; i++) {
		element = results[i];

		if (element.type === 'spec') {
		specResult = this.specResults_[element.id.toString()];

		if (specResult.result === 'passed') {
		msg = this.stringWithColor_(this.indentMessage_(element.name, depth), this.color_.pass());
		} else {
		msg = this.stringWithColor_(this.indentMessage_(element.name, depth), this.color_.fail());
		}
		msg += this.stringWithColor_(" - " + specResult.runtime + " ms",
		this.color_.specTiming());

		messages.push(msg);
		} else {
		messages.push('');
		msg = this.indentMessage_(element.name, depth)
		if (element.id != null) {
		suiteResult = this.suiteResults_[element.id.toString()];
		if (suiteResult) {
		msg += this.stringWithColor_(" - " + suiteResult.runtime + " ms", this.color_.suiteTiming());
		}
		}
		messages.push(msg);
		}

		this.buildMessagesFromResults_(messages, element.children, depth + 2);
		}
		},

		indentMessage_: function(message, indentCount) {
		var _indent = '';
		for (var i = 0; i < indentCount; i++) {
		_indent += ' ';
		}
		return (_indent + message);
		}
		module.exports = {
		TerminalReporter: TerminalReporter
		};

		// Inherit from TerminalReporter
		jasmineNode.TerminalVerboseReporter.prototype.__proto__ = jasmineNode.TerminalReporter.prototype;

		//
		// Exports
		//
		exports.jasmineNode = jasmineNode;
		})();
		}).call(this);

36

package.json

		{
		"name": "jasmine-node",
		"version": "1.14.1",
		"version": "2.0.0",
		"description": "DOM-less simple JavaScript BDD testing framework for Node",
		@@ -26,18 +26,30 @@ "contributors": [
		"dependencies": {
		"coffee-script": ">=1.0.1",
		"jasmine-reporters": ">=0.2.0",
		"jasmine-growl-reporter": "~0.0.2",
		"requirejs": ">=0.27.1",
		"walkdir": ">= 0.0.1",
		"underscore": ">= 1.3.1",
		"gaze": "~0.3.2",
		"mkdirp": "~0.3.5"
		"coffee-script": "~1.7.1",
		"walkdir": "~0.0.7",
		"underscore": "~1.6.0",
		"gaze": "~0.5.1",
		"mkdirp": "~0.3.5",
		"minimist": "0.0.8",
		"jasmine-growl-reporter": "~0.2.0"
		},
		"bin": "bin/jasmine-node",
		"devDependencies": {
		"grunt-contrib-coffee": "^0.10.1",
		"grunt-contrib-watch": "^0.5.3",
		"grunt": "^0.4.2"
		},
		"bin": {
		"jasmine-node": "./bin/jasmine-node"
		},
		"preferGlobal": true,
		"main": "lib/jasmine-node",
		"main": "./lib/jasmine-node",
		"scripts": {
		"test": "node lib/jasmine-node/cli.js spec"
		},
		"devDependencies": {}
		"bugs": {
		"url": "https://github.com/mhevery/jasmine-node/issues"
		},
		"license": "ISC",
		"engines": {
		"node": ">=0.10.0"
		}
		}

94

README.md

		@@ -0,1 +1,6 @@
		NOTE
		====

		This branch is in-development. Not recommended for use

		jasmine-node
		@@ -12,26 +17,13 @@ ======

		Version `1.3.1` of Jasmine is currently included with node-jasmine. This is a forked version from the
		[Karma project](https://github.com/karma-runner/karma-jasmine), which allows you to use the
		`ddescribe` and `iit` functions to run individual suites or specs.
		Version `2.0.0` of Jasmine is currently included with node-jasmine.

		BETA `2.0.0` Support is available in the `Jasmine2.0` branch.

		what's new
		----------
		* Growl notifications with the `--growl` flag (requires Growl to be installed)
		* Ability to test specs written in Literate Coffee-Script
		* Teamcity Reporter reinstated.
		* Ability to specify multiple files to test via list in command line
		* Ability to suppress stack trace with `--noStack`
		* Async tests now run in the expected context instead of the global one
		* `--config` flag that allows you to assign variables to process.env
		* Terminal Reporters are now available in the Jasmine Object #184
		* Done is now available in all timeout specs #199
		* `afterEach` is available in requirejs #179
		* Editors that replace instead of changing files should work with autotest #198
		* Jasmine Mock Clock now works!
		* Autotest now works!
		* Using the latest Jasmine!
		* Verbose mode tabs `describe` blocks much more accurately!
		* `--coffee` now allows specs written in Literate CoffeeScript (`.litcoffee`)
		* Now using Jasmine 2.0.0
		* Removed Support for RequireJS
		* Removed Support for Custom Helpers (have to be inside a beforeEach)
		* Removed Custom Timeout
		* Rewrote Terminal Reporter
		* Removed TeamCity Reporter (no support for Jasmine 2.0)
		* Removed JUnit Reporter (no support for Jasmine 2.0)

		@@ -77,26 +69,15 @@ install
		You can supply the following arguments:
		* `--autoTest` - rerun automatically the specs when a file changes
		* `--watchFolders PATH`- when used with --autoTest, watches the given path(s) and runs all tests if a change is detected
		* `--noColor` - do not use color coding for output
		* `-m, --match REGEXP` - load only specs containing "REGEXPspec"
		* `--matchAll` - relax requirement of "spec" in spec file names
		* `--verbose` - print extra information per each test run
		* `--coffee` - load coffee-script which allows execution .coffee files
		* `--forceExit` - force exit once tests complete.
		* `--captureExceptions`- listen to global exceptions, report them and exit (interferes with Domains)
		* `--noStackTrace` - suppress the stack trace generated from a test failure
		* `--version` - show the current version
		* `-h, --help` - display this help and exit

		* `--autotest`, provides automatic execution of specs after each change
		* `--watch`, when used with `--autotest`, paths after `--watch` will be
		watched for changes, allowing to watch for changes outside of specs directory
		* `--coffee`, allow execution of `.coffee` and `.litcoffee` specs
		* `--color`, indicates spec output should uses color to
		indicates passing (green) or failing (red) specs
		* `--noColor`, do not use color in the output
		* `-m, --match REGEXP`, match only specs comtaining "REGEXPspec"
		* `--matchall`, relax requirement of "spec" in spec file names
		* `--verbose`, verbose output as the specs are run
		* `--junitreport`, export tests results as junitreport xml format
		* `--output FOLDER`, defines the output folder for junitreport files
		* `--teamcity`, converts all console output to teamcity custom test runner commands. (Normally auto detected.)
		* `--growl`, display test run summary in a growl notification (in addition to other outputs)
		* `--runWithRequireJs`, loads all specs using requirejs instead of node's native require method
		* `--requireJsSetup`, file run before specs to include and configure RequireJS
		* `--test-dir`, the absolute root directory path where tests are located
		* `--nohelpers`, does not load helpers
		* `--forceexit`, force exit once tests complete
		* `--captureExceptions`, listen to global exceptions, report them and exit (interferes with Domains in NodeJs, so do not use if using Domains as well
		* `--config NAME VALUE`, set a global variable in `process.env`
		* `--noStack`, suppress the stack trace generated from a test failure

		Individual files to test can be added as bare arguments to the end of the args.
		@@ -159,18 +140,2 @@

		requirejs
		---------

		There is a sample project in `/spec-requirejs`. It is comprised of:

		1. `requirejs-setup.js`, this pulls in our wrapper template (next)
		1. `requirejs-wrapper-template`, this builds up requirejs settings
		1. `requirejs.sut.js`, this is a __SU__bject To __T__est, something required by requirejs
		1. `requirejs.spec.js`, the actual jasmine spec for testing

		To run it:

		```sh
		node lib/jasmine-node/cli.js --runWithRequireJs --requireJsSetup ./spec-requirejs/requirejs-setup.js ./spec-requirejs/
		```

		exceptions
		@@ -229,3 +194,3 @@ ----------

		Run the specs before you send your pull request:
		Run the specs before you send your pull request and ensure all pass:

		@@ -236,11 +201,6 @@ ```sh

		__Note:__ Some tests are designed to fail in the specs.sh. After each of the
		individual runs completes, there is a line that lists what the expected
		Pass/Assert/Fail count should be. If you add/remove/edit tests, please be sure
		to update this with your PR.


		changelog
		---------

		* _2.0.0_ Upgrade to Jasmine 2.0.0, remove support for legacy/unused items
		* _1.14.1_ Default to noColors if not in a TTY
		@@ -247,0 +207,0 @@ * _1.14.0_ Add support for `iit`, `ddescribe` (thanks to [mgcrea](https://github.com/mgcrea))

37

spec/helper_spec.js

		describe("helper", function() {
		it("should load the helpers", function() {
		var expectation= expect(true);

		expect(typeof(expectation.toHaveProperty)).toBe('function');
		});
		});
		beforeEach(function() {
		jasmine.addMatchers(
		{
		toHaveProperty: function(util, customEqualityTesters) {
		return {
		compare: function(actual, expected) {
		var result = {};

		try {
		result.pass = expected in actual;
		}
		catch (e) {
		result.pass = false;
		}

		if (result.pass) {
		result.message = "Expected " + actual + " not to be a property.";
		} else {
		result.message = "Expected " + actual + " to be a property.";
		}

		return result
		}
		}
		}
		});
		});
		it("should load the helpers", function() {
		expect(expect(true).toHaveProperty).toEqual(jasmine.any(Function));
		});
		});

4

spec/nested/uber-nested/UberNestedSpec.js

		@@ -7,6 +7,6 @@ describe('jasmine-node-uber-nested', function(){
		describe('failure', function(){
		it('should report failure (THIS IS EXPECTED)', function(){
		expect(true).toBeFalsy();
		it('should report passing', function(){
		expect(false).toBeFalsy();
		});
		});
		});

472

spec/reporter_spec.js

		@@ -1,2 +0,2 @@
		var jasmineNode = require(__dirname + "/../lib/jasmine-node/reporter").jasmineNode;
		var jasmineNode = require(__dirname + "/../lib/jasmine-node/reporter")

		@@ -10,61 +10,37 @@ describe('TerminalReporter', function() {
		describe("initialize", function() {
		it('initializes print_ from config', function() {
		it('initializes print from config', function() {
		var config = { print: true };
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.print_).toBeTruthy();
		expect(this.reporter.config.print).toBeTruthy();
		});

		it('initializes color_ from config', function() {
		var config = { color: true }
		it('initializes color from config', function() {
		var config = { noColor: false}
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.color_).toEqual(jasmineNode.TerminalReporter.prototype.ANSIColors);
		expect(this.reporter.config.color).toEqual(jasmineNode.TerminalReporter.prototype.ANSIColors);
		});

		it('initializes includeStackTrace_ from config', function () {
		it('initializes noStackTrace from config', function () {
		var config = {}
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.includeStackTrace_).toBeTruthy();
		expect(this.reporter.config.noStackTrace).toBeTruthy();
		});

		it('sets the started_ flag to false', function() {
		it('initializes the specCounts to an Object', function() {
		var config = {}
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.started_).toBeFalsy();
		expect(this.reporter.counts).toBeDefined();
		});

		it('sets the finished_ flag to false', function() {
		it('sets the callback property to false by default', function() {
		var config = {}
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.finished_).toBeFalsy();
		expect(this.reporter.config.onComplete).toEqual(jasmine.any(Function))
		});

		it('initializes the suites_ array', function() {
		var config = {}
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.suites_.length).toEqual(0);
		});

		it('initializes the specResults_ to an Object', function() {
		var config = {}
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.specResults_).toBeDefined();
		});

		it('initializes the failures_ array', function() {
		var config = {}
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.failures_.length).toEqual(0);
		});

		it('sets the callback_ property to false by default', function() {
		var config = {}
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.callback_).toEqual(false)
		});

		it('sets the callback_ property to onComplete if supplied', function() {
		it('sets the callback property to callback if supplied', function() {
		var foo = function() { }
		var config = { onComplete: foo }
		this.reporter = new jasmineNode.TerminalReporter(config);
		expect(this.reporter.callback_).toBe(foo)
		expect(this.reporter.config.onComplete).toBe(foo)
		});
		@@ -75,423 +51,27 @@ });
		beforeEach(function() {
		this.spy = spyOn(this.reporter, 'printLine_');
		this.spy = spyOn(this.reporter.config, 'print');

		var runner = {
		topLevelSuites: function() {
		var suites = [];
		var suite = { id: 25 };
		suites.push(suite);
		return suites;
		}
		totalSpecsDefined: 3
		};
		this.reporter.reportRunnerStarting(runner);
		this.reporter.jasmineStarted(runner);
		});

		it('sets the started_ field to true', function() {
		expect(this.reporter.started_).toBeTruthy();
		});

		it('sets the startedAt field', function() {
		// instanceof does not work cross-context (such as when run with requirejs)
		var ts = Object.prototype.toString;
		expect(ts.call(this.reporter.startedAt)).toBe(ts.call(new Date()));
		expect(ts.call(this.reporter.startedAt)).toBe(ts.call(+new Date()));
		});

		it('buildes the suites_ collection', function() {
		expect(this.reporter.suites_.length).toEqual(1);
		expect(this.reporter.suites_[0].id).toEqual(25);
		});
		});

		describe('the summarize_ creates suite and spec tree', function() {
		beforeEach(function() {
		this.spec = {
		id: 1,
		description: 'the spec',
		isSuite: false
		}
		});

		it('creates a summary object from spec', function() {
		var result = this.reporter.summarize_(this.spec);

		expect(result.id).toEqual(1);
		expect(result.name).toEqual('the spec');
		expect(result.type).toEqual('spec');
		expect(result.children.length).toEqual(0);
		});

		it('creates a summary object from suite with 1 spec', function() {
		var env = { nextSuiteId: false }
		var suite = new jasmine.Suite(env, 'suite name', undefined, undefined);
		suite.description = 'the suite';
		suite.parentSuite = null;
		suite.children_.push(this.spec);

		var result = this.reporter.summarize_(suite);
		expect(result.name).toEqual('the suite');
		expect(result.type).toEqual('suite');
		expect(result.children.length).toEqual(1);

		var suiteChildSpec = result.children[0];
		expect(suiteChildSpec.id).toEqual(1);
		});
		});

		describe('reportRunnerResults', function() {
		beforeEach(function() {
		this.printLineSpy = spyOn(this.reporter, 'printLine_');
		});

		it('generates the report', function() {
		var failuresSpy = spyOn(this.reporter, 'reportFailures_');
		var printRunnerResultsSpy = spyOn(this.reporter, 'printRunnerResults_').
		andReturn('this is the runner result');

		var callbackSpy = spyOn(this.reporter, 'callback_');

		var runner = {
		results: function() {
		var result = { failedCount: 0 };
		return result;
		},
		specs: function() { return []; }
		it('buildes the suites collection', function() {
		suite = {
		"description": "jasmine-node-flat",
		"fullName": "jasmine-node-flat",
		"id": "suite1",
		"status": ""
		};
		this.reporter.startedAt = new Date();

		this.reporter.reportRunnerResults(runner);

		expect(failuresSpy).toHaveBeenCalled();
		expect(this.printLineSpy).toHaveBeenCalled();
		expect(callbackSpy).toHaveBeenCalled();
		this.reporter.suiteStarted(suite);
		expect(this.reporter.suiteTimes['suite1']).toEqual(jasmine.any(Number));
		});
		});

		describe('reportSpecResults', function() {
		beforeEach(function() {
		this.printSpy = spyOn(this.reporter, 'print_');
		this.spec = {
		id: 1,
		description: 'the spec',
		isSuite: false,
		results: function() {
		var result = {
		passed: function() { return true; }
		}
		return result;
		}
		}
		});

		it('prints a \'.\' for pass', function() {
		this.reporter.reportSpecResults(this.spec);
		expect(this.printSpy).toHaveBeenCalledWith('.');
		});

		it('prints an \'F\' for failure', function() {
		var addFailureToFailuresSpy = spyOn(this.reporter, 'addFailureToFailures_');
		var results = function() {
		var result = {
		passed: function() { return false; }
		}
		return result;
		}
		this.spec.results = results;

		this.reporter.reportSpecResults(this.spec);

		expect(this.printSpy).toHaveBeenCalledWith('F');
		expect(addFailureToFailuresSpy).toHaveBeenCalled();
		});
		});

		describe('addFailureToFailures', function() {
		it('adds message and stackTrace to failures_', function() {
		var spec = {
		suite: {
		getFullName: function() { return 'Suite name' }
		},
		description: 'the spec',
		results: function() {
		var result = {
		items_: function() {
		var theItems = new Array();
		var item = {
		passed_: false,
		message: 'the message',
		trace: {
		stack: 'the stack'
		}
		}
		theItems.push(item);
		return theItems;
		}.call()
		};
		return result;
		}
		};

		this.reporter.addFailureToFailures_(spec);

		var failures = this.reporter.failures_;
		expect(failures.length).toEqual(1);
		var failure = failures[0];
		expect(failure.spec).toEqual('Suite name the spec');
		expect(failure.message).toEqual('the message');
		expect(failure.stackTrace).toEqual('the stack');
		});
		});

		describe('prints the runner results', function() {
		beforeEach(function() {
		this.runner = {
		results: function() {
		var _results = {
		totalCount: 23,
		failedCount: 52
		};
		return _results;
		},
		specs: function() {
		var _specs = new Array();
		spec = {
		results: function() {
		var _results = {
		skipped: false
		}
		return _results;
		}
		};
		_specs.push(spec);
		return _specs;
		}
		};
		});

		it('uses the specs\'s length, totalCount and failedCount', function() {
		var message = this.reporter.printRunnerResults_(this.runner);
		expect(message).toEqual('1 test, 23 assertions, 52 failures, 0 skipped\n');
		});
		});

		describe('reports failures', function() {
		beforeEach(function() {
		this.printSpy = spyOn(this.reporter, 'print_');
		this.printLineSpy = spyOn(this.reporter, 'printLine_');
		});

		it('does not report anything when there are no failures', function() {
		this.reporter.failures_ = new Array();

		this.reporter.reportFailures_();

		expect(this.printLineSpy).not.toHaveBeenCalled();
		});

		it('prints the failures', function() {
		var failure = {
		spec: 'the spec',
		message: 'the message',
		stackTrace: 'the stackTrace'
		}

		this.reporter.failures_ = new Array();
		this.reporter.failures_.push(failure);

		this.reporter.reportFailures_();

		var generatedOutput =
		[ [ '\n' ],
		[ '\n' ],
		[ ' 1) the spec' ],
		[ ' Message:' ],
		[ ' the message' ],
		[ ' Stacktrace:' ] ];

		expect(this.printLineSpy).toHaveBeenCalled();
		expect(this.printLineSpy.argsForCall).toEqual(generatedOutput);

		expect(this.printSpy).toHaveBeenCalled();
		expect(this.printSpy.argsForCall[0]).toEqual(['Failures:']);
		expect(this.printSpy.argsForCall[1]).toEqual([' the stackTrace']);
		});

		it('prints the failures without a Stacktrace', function () {
		var config = { includeStackTrace: false };
		this.reporter = new jasmineNode.TerminalReporter(config);
		this.printSpy = spyOn(this.reporter, 'print_');
		this.printLineSpy = spyOn(this.reporter, 'printLine_');

		var failure = {
		spec: 'the spec',
		message: 'the message',
		stackTrace: 'the stackTrace'
		}

		this.reporter.failures_ = new Array();
		this.reporter.failures_.push(failure);

		this.reporter.reportFailures_();

		var generatedOutput =
		[ [ '\n' ],
		[ '\n' ],
		[ ' 1) the spec' ],
		[ ' Message:' ],
		[ ' the message' ] ];

		expect(this.printLineSpy).toHaveBeenCalled();
		expect(this.printLineSpy.argsForCall).toEqual(generatedOutput);

		expect(this.printSpy).toHaveBeenCalled();
		expect(this.printSpy.argsForCall[0]).toEqual(['Failures:']);
		expect(this.printSpy.argsForCall[1]).toBeUndefined();
		});
		});
		});

		describe('TerminalVerboseReporter', function() {
		beforeEach(function() {
		var config = {}
		this.verboseReporter = new jasmineNode.TerminalVerboseReporter(config);
		this.addFailureToFailuresSpy = spyOn(this.verboseReporter, 'addFailureToFailures_');
		this.spec = {
		id: 23,
		results: function() {
		return {
		failedCount: 1,
		getItems: function() {
		return ["this is the message"];
		}
		}
		}
		};
		});

		describe('#reportSpecResults', function() {
		it('adds the spec to the failures_', function() {
		this.verboseReporter.reportSpecResults(this.spec);

		expect(this.addFailureToFailuresSpy).toHaveBeenCalledWith(this.spec);
		});

		it('adds a new object to the specResults_', function() {
		this.verboseReporter.reportSpecResults(this.spec);

		expect(this.verboseReporter.specResults_[23].messages).toEqual(['this is the message']);
		expect(this.verboseReporter.specResults_[23].result).toEqual('failed');
		});
		});

		describe('#buildMessagesFromResults_', function() {
		beforeEach(function() {
		this.suite = {
		id: 17,
		type: 'suite',
		name: 'a describe block',
		suiteNestingLevel: 0,
		children: [],
		getFullName: function() { return "A spec"; },
		};

		this.spec = {
		id: 23,
		type: 'spec',
		name: 'a spec block',
		children: []
		};

		this.verboseReporter.specResults_['23'] = {
		result: 'passed',
		runtime: 200
		};

		this.verboseReporter.suiteResults_['17'] = {
		runtime: 500
		};

		});

		it('does not build anything when the results collection is empty', function() {
		var results = [],
		messages = [];

		this.verboseReporter.buildMessagesFromResults_(messages, results);

		expect(messages.length).toEqual(0);
		});

		it('adds a single suite to the messages', function() {
		var results = [],
		messages = [];

		results.push(this.suite);

		this.verboseReporter.buildMessagesFromResults_(messages, results);

		expect(messages.length).toEqual(2);
		expect(messages[0]).toEqual('');
		expect(messages[1]).toEqual('a describe block - 500 ms');
		});

		it('adds a single spec with success to the messages', function() {
		var results = [],
		messages = [];

		this.passSpy = spyOn(this.verboseReporter.color_, 'pass');

		results.push(this.spec);

		this.verboseReporter.buildMessagesFromResults_(messages, results);

		expect(this.passSpy).toHaveBeenCalled();
		expect(messages.length).toEqual(1);
		expect(messages[0]).toEqual('a spec block - 200 ms');
		});

		it('adds a single spec with failure to the messages', function() {
		var results = [],
		messages = [];

		this.verboseReporter.specResults_['23'].result = 'failed';

		this.passSpy = spyOn(this.verboseReporter.color_, 'pass');
		this.failSpy = spyOn(this.verboseReporter.color_, 'fail');

		results.push(this.spec);

		this.verboseReporter.buildMessagesFromResults_(messages, results);

		expect(this.failSpy).toHaveBeenCalled();
		expect(this.passSpy).not.toHaveBeenCalled();
		});

		it('adds a suite, a suite and a single spec with success to the messages', function() {
		var results = [],
		messages = [];

		var subSuite = new Object();
		subSuite.id = '29';
		subSuite.type = 'suite';
		subSuite.name = 'a sub describe block';
		subSuite.suiteNestingLevel = 1;
		subSuite.children = [];
		subSuite.children.push(this.spec);

		this.suite.children.push(subSuite);
		results.push(this.suite);

		this.verboseReporter.suiteResults_['29'] = {
		runtime: 350
		};

		this.verboseReporter.buildMessagesFromResults_(messages, results);

		expect(messages.length).toEqual(5);
		expect(messages[0]).toEqual('');
		expect(messages[1]).toEqual('a describe block - 500 ms');
		expect(messages[2]).toEqual('');
		expect(messages[3]).toEqual(' a sub describe block - 350 ms');
		expect(messages[4]).toEqual(' a spec block - 200 ms');
		});
		});
		});

35

spec/TestSpec.js

		@@ -1,2 +0,1 @@

		describe('jasmine-node-flat', function(){
		@@ -6,2 +5,10 @@ it('should pass', function(){
		});
		xit('should skip this one', function(){
		expect(1+2).toEqual(3);
		});
		describe('jasmine-node-flat-nested', function(){
		it('should also pass', function(){
		expect(3).toBe(3);
		});
		});
		});
		@@ -27,23 +34,7 @@

		describe('Testing some characters', function() {
		var chars = ['&', '\'', '"', '<', '>'];
		for(var i = 0; i < chars.length; i+=1) {
		currentChar = chars[i];
		it('should reject ' + currentChar, (function(currentChar) {
		expect(false).toEqual(false);
		})(currentChar));
		}
		});

		describe('Testing waitsfor functionality', function() {
		it("Runs and then waitsFor", function() {
		runs(function() {
		1+1;
		});
		waitsFor(function() {
		return true === false;
		}, "the impossible", 1000);
		runs(function() {
		expect(true).toBeTruthy();
		});
		describe('Testing done functionality', function() {
		it("calls done", function(done) {
		1+1;
		expect(true).toBeTruthy();
		done();
		});
		@@ -50,0 +41,0 @@ });

19

spec/TimerSpec.js

		@@ -6,4 +6,7 @@ describe("Manually ticking the Jasmine Mock Clock", function() {
		timerCallback = jasmine.createSpy('timerCallback');
		jasmine.Clock.useMock();
		jasmine.clock().install();
		});
		afterEach(function() {
		jasmine.clock().uninstall();
		});

		@@ -15,3 +18,3 @@ it("causes a timeout to be called synchronously", function() {

		jasmine.Clock.tick(101);
		jasmine.clock().tick(101);

		@@ -26,12 +29,12 @@ expect(timerCallback).toHaveBeenCalled();

		jasmine.Clock.tick(102);
		jasmine.clock().tick(102);
		expect(timerCallback).toHaveBeenCalled();
		expect(timerCallback.callCount).toEqual(1);
		expect(timerCallback.calls.count()).toEqual(1);

		jasmine.Clock.tick(50);
		expect(timerCallback.callCount).toEqual(1);
		jasmine.clock().tick(50);
		expect(timerCallback.calls.count()).toEqual(1);

		jasmine.Clock.tick(50);
		expect(timerCallback.callCount).toEqual(2);
		jasmine.clock().tick(50);
		expect(timerCallback.calls.count()).toEqual(2);
		});
		});

lib/jasmine-node/async-callback.js

lib/jasmine-node/autotest.js

lib/jasmine-node/cs.js

lib/jasmine-node/index.js

lib/jasmine-node/requirejs-runner.js

lib/jasmine-node/requirejs-spec-loader.js

lib/jasmine-node/requirejs-wrapper-template.js

lib/jasmine-node/spec-collection.js

scripts/specs

spec-requirejs-coffee/requirecs.sut.coffee

spec-requirejs-coffee/RequireCsSpec.coffee

spec-requirejs-coffee/requirejs-setup.js

spec-requirejs-coffee/RequireJsSpec.coffee

spec-requirejs/requirejs-setup.js

spec-requirejs/requirejs-wrapper-template.js

spec-requirejs/requirejs.spec.js

spec-requirejs/requirejs.sut.js

spec/async-callback_spec.js

spec/AsyncSpec.coffee

spec/sample_helper.js

spec/SampleSpecs.js

specs.sh

bin/jasmine-node

Sorry, the diff of this file is not supported yet

jasmine-node - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes