Automatically run client-side mocha specs via grunt/mocha/PhantomJS
For a grunt task for server-side mocha tests, see grunt-mocha-test or grunt-simple-mocha
This plugin requires Grunt ~0.4.0
. Use a 0.1.x
tag of this plugin to use with Grunt ~0.3.0
.
If you haven't used Grunt before, be sure to check out the Getting Started guide, as it explains how to create a Gruntfile as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:
npm install grunt-mocha --save-dev
Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:
grunt.loadNpmTasks('grunt-mocha');
Run this task with the grunt mocha
command.
Type: String|Array
This defines which HTML spec files to run using PhantomJS. These are the same files you would open to run tests in a browser.
There are a number of options available. Please review the minimatch options here.
Example:
mocha: {
test: {
src: ['tests/**/*.html'],
},
},
Type: String
Default: undefined
Write reporter output to a file. Useful if you need a file to feed your CI bot.
Example:
mocha: {
test: {
options: {
reporter: 'XUnit'
},
src: ['tests/**/*.html'],
dest: './test/output/xunit.out',
},
},
Type: Boolean
Default: false
NOTE: This will probably default to true in 0.5
.
grunt-mocha injects a script into the PhantomJS instance that loads your HTML spec files. The file sets up a reporter and listeners so the output can be output in the command line. This option will call mocha.run()
after the script is injected, ensuring that the proper listeners are setup.
You may want to set this to false if your files are loaded asynchronously via AMD and call mocha.run
in your own callback.
In HTML spec:
<!-- run mocha after all test are loaded -->
<script type="text/javascript" charset="utf-8">
// Only tests run in real browser, injected script run if options.run == true
if (navigator.userAgent.indexOf('PhantomJS') < 0) {
mocha.run();
}
</script>
Gruntfile:
mocha: {
test: {
src: ['tests/**/*.html'],
options: {
run: true,
},
},
},
Type: Array|String
Default: []
Instead of files, hit these URLs. Usually used in conjunction with the connect task to spin up a server for testing.
connect: {
server: {
options: {
port: 8888,
base: '.',
},
},
},
mocha: {
test: {
options: {
urls: [ 'http://localhost:8888/example/test/test2.html' ],
},
},
},
Then run:
grunt connect mocha
Type: Number
Default: 5000
PhantomJS timeout in milliseconds. If nothing happens within 5 seconds, exit.
Example:
mocha: {
test: {
src: ['tests/**/*.html'],
options: {
timeout: 10000,
},
},
},
Type: Boolean
Default: false
Call grunt.warn
and exit the grunt task on the first failed test. This only calls grunt.warn
after the entire spec file is finished.
Example:
mocha: {
test: {
src: ['tests/**/*.html'],
options: {
bail: true,
},
},
},
Type: Boolean
Default: true
Display a Growl notification when all tests successfully pass.
Example:
mocha: {
test: {
src: ['tests/**/*.html'],
options: {
growlOnSuccess: false,
},
},
},
Type: Boolean
Default: false
Print any console.log
calls from PhantomJS to the command line. Only used for very quick and dirty debugging. It is highly recommended that you open the failing spec file in a browser so you can use much richer debugging tools.
Example:
mocha: {
test: {
src: ['tests/**/*.html'],
options: {
log: true,
},
},
},
Type: Boolean
Default: false
Fail and output script errors.
Example:
mocha: {
test: {
src: ['tests/**/*.html'],
options: {
logErrors: true,
},
},
},
Type: Object
A mocha options simple object. Very few options are currently supported. Actually, I think grep
is the only one.
Example:
mocha: {
test: {
src: ['tests/**/*.html'],
options: {
mocha: {
grep: 'router*'
}
}
},
},
Type: String
Default: 'Dot'
The reporter to use. Note: XUnit and those types of reporters should probably use the dest
option.
Example:
mocha: {
test: {
files: ['tests/**/*.html'],
options: {
reporter: 'Nyan',
}
},
},
Custom reporter example: Example:
mocha: {
test: {
files: ['tests/**/*.html'],
options {
reporter: './path/to/custom/reporter', // included via require
},
},
},
grunt-mocha contains an API to subscribe to all of mocha's runner hooks. The mochaHooks
object which is available as a global variable in phantomjs allows a user to subscribe a single synchronous function to each event through the mochaHooks.on
function. Any code within the hook is guarenteed to run before the event is bubbled into the grunt process.
The mocha events that can be subscribed to are: start
, test
, test end
, suite
, suite end
, fail
, pass
, pending
, and end
.
Example: Hook when mocha finishes running everything
mochaHooks.on('end', function() {
//stuff...
}
The PhantomJS -> Grunt superdimensional conduit uses alert
. If you have disabled or aliased alert in your app, this won't work. I have conveniently set a global PHANTOMJS
on window
so you can conditionally override alert in your app.
- Write mocha task description in grunt config using and specify
run: true
option (see this task's Gruntfile.js for details); - Check for PhantomJS
userAgent
in a test html file and run tests only in a real browser (see test2.html for details).
In this case you shouldn't include bridge.js (it will be included automatically) and tests will be run from bridge.js.
Alternatively, include bridge.js
from tasks/phantomjs
after you include mocha.js
and run mocha.setup
in your HTML file. The helper will override mocha.setup
if it detects PhantomJS. See test.html.
Mocha must be included via script tag in the header. There is no need to load Mocha via AMD. You may load other testing libs via AMD if that gives you a fuzzy feeling.
Example setup with AMD (advanced): https://gist.github.com/2655876
Copyright (c) 2013 Kelly Miyashiro Licensed under the MIT license.