CodeceptJS provides API to run custom code before and after the test and inject custom listeners into the event system.

Bootstrap & Teardown

In case you need to execute arbitrary code before or after the tests, you can use bootstrap and teardown config. Use it to start and stop webserver, Selenium, etc.

There are different ways to define bootstrap and teardown functions:

  • JS file executed as is (synchronously).
  • JS file exporting function with optional callback for async execution.
  • JS file exporting an object with bootstrap and teardown methods.
  • Inside JS config file

Corresponding examples provided in next sections.

Example: Async Bootstrap in a Function

Add to codecept.json:

"bootstrap": "./run_server.js"

Export a function in your bootstrap file:

// bootstrap.js
var server = require('./app_server');
module.exports = function(done) {
  // on error call done('error description') to stop
  if (!server.validateConfig()) {
    done("Can't execute server with invalid config, tests stopped");
  // call done() to continue execution

Example: Async Teardown in a Function

Stopping a server from a previous example can be done in a similar manner. Create a teardown file and add it to codecept.json:

"teardown": "./stop_server.js"

Inside stop_server.js:

var server = require('./app_server');
module.exports = function(done) {

Example: Bootstrap & Teardown Inside an Object

Examples above can be combined into one file.

Add to config (codecept.json):

  "bootstrap": "./server.js"
  "teardown": "./server.js"

server.js should export object with bootstrap and teardown functions:

// bootstrap.js
var server = require('./app_server');
module.exports = {
  bootstrap: function(done) {
  teardown: function(done) {

Example: Bootstrap & Teardown Inside Config

If you are using JavaScript-style config codecept.conf.js, bootstrap and teardown functions can be placed inside of it:

var server = require('./app_server');

exports.config = {
  tests: "./*_test.js",
  helpers: {},

  // adding bootstrap/teardown
  bootstrap: function(done) {
  teardown: function(done) {
  // ...
  // other config options

Custom Hooks

To extend internal CodeceptJS functionality you can use hooks. CodeceptJS provides API to connect to its internal event dispatcher, container, output, promise recorder, so you could hook into it to create your own reporters, test listeners, etc.

Hooks are JavaScript files same as for bootstrap and teardown, which can be registered inside hooks section of config. Unlike bootstrap you can have multiple hooks registered:

"hooks": [

Inside those JS files you can use CodeceptJS API to access its internals.


CodeceptJS provides an API which can be loaded via require('codeceptjs') when CodeceptJS is installed locally. These internal objects are available:

  • codecept: test runner class
  • config: current codecept config
  • event: event listener
  • recorder: global promise chain
  • output: internal printer
  • container: dependency injection container for tests, includes current helpers and support objects
  • helper: basic helper class
  • actor: basic actor (I) class

API reference is available on GitHub. Also please check the source code of corresponding modules.


CodeceptJS config can be accessed from require('codeceptjs').config.get():

let config = require('codeceptjs').config.get();

if (config.myKey == 'value') {
  // run hook

Event Listeners

CodeceptJS provides a module with event dispatcher and set of predefined events.

It can be required from codeceptjs package if it is installed locally.

const event = require('codeceptjs').event;

module.exports = function() {

  event.dispatcher.on(event.test.before, function (test) {

    console.log('--- I am before test --');


Available events:

  • event.test.started(test) - at the very beginning of a test. Passes a current test object.
  • event.test.before - when Before hooks from helpers and from test is executed
  • event.test.after - after each test
  • event.test.passed(test) - when test passed
  • event.test.failed(test, error) - when test failed
  • event.suite.before(suite) - before a suite
  • event.suite.after(suite) - after a suite
  • event.step.started(step) - when step hooks from helpers executed. Passes current step object.
  • event.step.before - at the very beginning of a step
  • event.step.after- after a step
  • event.all.before - before running tests
  • event.all.after - after running tests
  • event.all.result - when results are printed

For further reference look for currently available listeners using event system.

Test Object

Test events provide a test object with following fields:

  • title title of a test
  • body test function as a string
  • opts additional test options like retries, and others
  • pending true if test is scheduled for execution and false if a test has finished
  • file path to a file with a test.
  • steps array of executed steps (available only in test.passed or test.failed event)

and others

Step Object

Step events provide step objects with following fields:

  • name name of a step, like 'see', 'click', and others
  • actor current actor, in most cases it I
  • helper current helper instance used to execute this step
  • helperMethod corresponding helper method, in most cases is the same as name
  • status status of a step (passed or failed)
  • prefix if a step is executed inside within block contain within text, like: 'Within .js-signup-form'.
  • args passed arguments


To inject asynchronous functions in a test or before/after a test you can subscribe to corresponding event and register a function inside a recorder object. Recorder represents a global promises chain.

Provide a function description as a first parameter, function should return a promise:

const event = require('codeceptjs').event;
const recorder = require('codeceptjs').recorder;
module.exports = function() {

  event.dispatcher.on(event.test.before, function (test) {

    const request = require('request');

    recorder.add('create fixture data via API', function() {
      return new Promise((doneFn, errFn) => {
          baseUrl: 'http://api.site.com/',
          method: 'POST',
          url: '/users',
          json: { name: 'john', email: 'john@john.com' }
        }), (err, httpResponse, body) => {
          if (err) return errFn(err);

Whenever you execute tests with --verbose option you will see registered events and promises executed by a recorder.


Output module provides 4 verbosity levels. Depending on the mode you can have different information printed using corresponding functions.

  • default: prints basic information using output.print
  • steps: toggled by --steps option, prints step execution
  • debug: toggled by --debug option, prints steps, and debug information with output.debug
  • verbose: toggled by --verbose prints debug information and internal logs with output.log

It is recommended to avoid console.log and use output.* methods for printing.

const output = require('codeceptjs').output;

output.print('This is basic information');
output.debug('This is debug information');
output.log('This is verbose logging information');


CodeceptJS has a dependency injection container with Helpers and Support objects. They can be retrieved from the container:

let container = require('codeceptjs').container;

// get object with all helpers
let helpers = container.helpers();

// get helper by name
let WebDriverIO = container.helpers('WebDriverIO');

// get support objects
let support = container.support();

// get support object by name
let UserPage = container.support('UserPage');

New objects can also be added to container in runtime:

let container = require('codeceptjs').container;

  helpers: { // add helper
    MyHelper: new MyHelper({ config1: 'val1' });
  support: { // add page object
    UserPage: require('./pages/user');

Container also contains current Mocha instance:

let mocha = container.mocha();

Custom Runner

CodeceptJS can be imported and used in custom runners. To initialize Codecept you need to create Config and Container objects.

let Container = require('codeceptjs').container;
let Codecept = require('codeceptjs').codecept;

let config = { helpers: { WebDriverIO: { browser: 'chrome', url: 'http://localhost' } } };
let opts = { steps: true };

// create runner
let codecept = new Codecept(config, opts);

// create helpers, support files, mocha
Container.create(config, opts);

// initialize listeners

// load tests

// run tests

In this way Codecept runner class can be extended.


© 2015 DavertMik <davert@codegyre.com> (http://codegyre.com)
Licensed under the MIT License.