grunt-mocha-concurrent

Run mocha tests via concurrent grunt tasks.

Installation

1npm install grunt-mocha-concurrent --save-dev

Overview

Even though there are lots of posts online that don't recommend running tests in parallel, I've almost halved the time it takes for my tests to run. Sure, it can be harder to debug issues, but since this uses grunt-concurrent to spawn separate processes there won't be any "cross wire" bugs. Besides, if your test fails you can just revert to running your regular serial grunt test task along with a mocha .only. But when things are green then why not go faster? :thumbsup:

Getting started

This plugin requires grunt-mocha-test and grunt-concurrent. grunt-env is optional.

Check that your Gruntfile.js looks something similar to this. It's important that Concurrent.init(grunt); appears after you call initConfig().

1const Concurrent = require("grunt-mocha-concurrent");
2...
3grunt.loadNpmTasks('grunt-mocha-test');
4grunt.loadNpmTasks('grunt-concurrent');
5grunt.loadNpmTasks('grunt-mocha-concurrent');
6...
7grunt.initConfig({
8  ...
9});
10Concurrent.init(grunt);
11

mocha_concurrent task

Simple example

If your tests don't have any central external dependencies like a database, then this is the example for you.

1grunt.initConfig({
2  ...
3  mocha_concurrent: {
4    your_target: {
5      specs: [
6        {
7          mochaSpec: {
8            options: { 
9              reporter: 'dot', 
10              timeout: '2000'
11            },
12            src: ['tests/unit/**/test*.js']
13          }
14        },
15        {
16          mochaSpec: {
17            options: { 
18              reporter: 'dot', 
19              timeout: '2000'
20            },
21            src: ['tests/functional/**/test*.js']
22          }
23        }        
24      ]
25    },
26  }
27  ...
28});
29...
30grunt.registerTask('spec:concurrent', ['mocha_concurrent:your_target']);

When you run grunt spec:concurrent it will run your unit tests and your functional tests in parallel.

mochaSpec is just forwarded directly to grunt-mocha-test so look up their documentation if you want to know more about the options.

Advanced example

Say your functional tests read and/or write to the database. You can't run parallel tests in the same process as your tests will step all over each other. You can't run parallel tests in different processes pointing to the same database either! So we get around this by using a different database instance in each task. :v:

If you use an environment variable to set which database to connect to, then you can use this example. This assumes that your test framework will dynamically create your database/schema for you. I'm using mongodb so this just happens automagically.

1grunt.initConfig({
2  grunt.loadNpmTasks('grunt-env');
3  ...
4  mocha_concurrent: {
5    your_target: {
6      specs: [
7        {
8          mochaSpec: {
9            options: { 
10              reporter: 'dot', 
11              timeout: '2000'
12            },
13            src: ['tests/unit/**/test*.js']
14          }
15        },
16        {
17          mochaSpec: {
18            options: { 
19              reporter: 'dot', 
20              timeout: '2000'
21            },
22            src: ['tests/functional/controllers/**/test*.js']
23          },
24          envSpec: {
25            MONGODB_URI: 'mongodb://localhost:27017/my-test-db-1'
26          }          
27        },
28        {
29          mochaSpec: {
30            options: { 
31              reporter: 'dot', 
32              timeout: '2000'
33            },
34            src: ['tests/functional/models/**/test*.js']
35          },
36          envSpec: {
37            MONGODB_URI: 'mongodb://localhost:27017/my-test-db-2'
38          }
39        }
40      ]
41    },
42  }
43  ...
44});
45...
46grunt.registerTask('spec:concurrent', ['mocha_concurrent:your_target']);

When you run grunt spec:concurrent it will run your unit tests and two of your functional test flavours in parallel.

Default Options

1grunt.initConfig({
2  mocha_concurrent: {
3    options: {
4      concurrentLimit: 1,   // Number of concurrent tasks to run in parallel. Defaults to number of cpu cores.
5      envDefault: {},       // Environment variables to pass to all tasks. Defaults to null.
6      envTaskPrefix: "",    // Prefix to use for grunt-env tasks. Defaults to mochaConcurrent-.
7      mochaTaskPrefix: "",  // Prefix to use for grunt-env tasks. Defaults to mochaConcurrent-.
8    },
9    ...
10  },
11});

Tips

• You can get fancy and generate your mocha_concurrent target specs depending on what you need. E.g. I looped over each folder under tests/functional/controllers and created a separate spec for each, each with a unique database connection string.
• If your application is a HTTP API and you call it in your tests, you can also just increment the port number for each spec using the env variable.
• There is overhead involved in spinning up separate tasks with their own database etc. The more cores you have the more time this will save. Otherwise it may actually be slower than a single task!
• Clean up old databases after the tests to save space. I defined a global mocha post test using .after() and included it in the mochaSpec src for each spec. Mongoose gives you a way to delete the database.
• If you don't want grunt to stop when it encounters a failed test, consider using grunt-continue.