npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

jakobmattsson-cucumber

v0.3.3

Published

The official JavaScript implementation of Cucumber.

Downloads

5

Readme

Cucumber.js Build Status

Cucumber, the popular Behaviour-Driven Development tool, brought to your JavaScript stack.

It runs on both Node.js and modern web browsers.

Development status

Cucumber.js is still a work in progress. Here is its current status.

Cucumber Technology Compatibility Kit

  1. Not certified by Cucumber TCK yet.
  2. Considered for removal from Cucumber TCK.
  3. Missing 'matches' attributes. Simple wrapper for Gherkin's JsonFormatter pending porting of:
  • https://github.com/cucumber/gherkin/blob/master/lib/gherkin/listener/formatter_listener.rb
  • https://github.com/cucumber/gherkin/blob/master/lib/gherkin/formatter/filter_formatter.rb

in Gherkin itself.

Cucumber.js-specific features

  1. Will be certified by Cucumber TCK.

Prerequesites

Cucumber.js is tested on:

  • Node.js 0.6 and 0.8 (see CI builds)
  • Google Chrome
  • Firefox
  • Safari
  • Opera

There are plans to have CI builds on browsers too.

Usage

Install

Cucumber.js is available as an npm module.

Install globally with:

$ npm install -g cucumber

OR

You may also define cucumber.js as a development dependency of your application by including it in a package.json file.

// package.json

{ "devDependencies" : {
    "cucumber": "latest"
  }
}

Then install with npm install --dev

Features

Features are written with the Gherkin syntax

# features/myFeature.feature

Feature: Example feature
  As a user of cucumber.js
  I want to have documentation on cucumber
  So that I can concentrate on building awesome applications

  Scenario: Reading documentation
    Given I am on the Cucumber.js Github repository
    When I go to the README file
    Then I should see "Usage" as the page title

Support Files

Support files let you setup the environment in which steps will be run, and define step definitions. Both JavaScript (.js) and CoffeeScript (.coffee) source files are supported.

World

World is a constructor function with utility properties, destined to be used in step definitions:

// features/support/world.js

var zombie = require('zombie');
var World = function World(callback) {
  this.browser = new zombie.Browser(); // this.browser will be available in step definitions

  this.visit = function(url, callback) {
    this.browser.visit(url, callback);
  };

  callback(); // tell Cucumber we're finished and to use 'this' as the world instance
};
exports.World = World;

It is possible to tell Cucumber to use another object instance than the constructor:

// features/support/world.js

var zombie = require('zombie');
var WorldConstructor = function WorldConstructor(callback) {
  this.browser = new zombie.Browser(); // this.browser will be available in step definitions

  var world = {
    visit: function(url, callback) {
      this.browser.visit(url, callback);
    }
  };

  callback(world); // tell Cucumber we're finished and to use our world object instead of 'this'
};
exports.World = WorldConstructor;

Step Definitions

Step definitions are the glue between features written in Gherkin and the actual SUT (system under test). They are written in JavaScript.

All step definitions will run with this set to what is known as the World in Cucumber. It's an object exposing useful methods, helpers and variables to your step definitions. A new instance of World is created before each scenario.

Step definitions are contained within one or more wrapper functions.

Those wrappers are run before executing the feature suite. this is an object holding important properties like the Given(), When() and Then() functions. Another notable property is World; it contains a default World constructor that can be either extended or replaced.

Step definitions are run when steps match their name. this is an instance of World.

// features/step_definitions/myStepDefinitions.js

var myStepDefinitionsWrapper = function () {
  this.World = require("../support/world.js").World; // overwrite default World constructor

  this.Given(/^I am on the Cucumber.js Github repository$/, function(callback) {
    // Express the regexp above with the code you wish you had.
    // `this` is set to a new this.World instance.
    // i.e. you may use this.browser to execute the step:

    this.visit('http://github.com/cucumber/cucumber-js', callback);

    // The callback is passed to visit() so that when the job's finished, the next step can
    // be executed by Cucumber.
  });

  this.When(/^I go to the README file$/, function(callback) {
    // Express the regexp above with the code you wish you had. Call callback() at the end
    // of the step, or callback.pending() if the step is not yet implemented:

    callback.pending();
  });

  this.Then(/^I should see "(.*)" as the page title$/, function(title, callback) {
    // matching groups are passed as parameters to the step definition

    if (!this.isOnPageWithTitle(title))
      // You can make steps fail by calling the `fail()` function on the callback:
      callback.fail(new Error("Expected to be on page with title " + title));
    else
      callback();
  });
};

module.exports = myStepDefinitionsWrapper;

It is also possible to use simple strings instead of regexps as step definition patterns:

this.Then('I should see "$title" as the page title', function(title, callback) {
  // the above string is converted to the following Regexp by Cucumber:
  // /^I should see "([^"]*)" as the page title$/

  if (!this.isOnPageWithTitle(title))
    // You can make steps fail by calling the `fail()` function on the callback:
    callback.fail(new Error("Expected to be on page with title " + title));
  else
    callback();
});

'I have $count "$string"' would translate to /^I have (.*) "([^"]*)")$/.

Hooks

Hooks can be used to prepare and clean the environment before and after each scenario is executed.

Before hooks

To run something before every scenario, use before hooks:

// features/support/hooks.js (this path is just a suggestion)

var myHooks = function () {
  this.Before(function(callback) {
    // Just like inside step definitions, "this" is set to a World instance.
    // It's actually the same instance the current scenario step definitions
    // will receive.

    // Let's say we have a bunch of "maintenance" methods available on our World
    // instance, we can fire some to prepare the application for the next
    // scenario:

    this.bootFullTextSearchServer();
    this.createSomeUsers();

    // Don't forget to tell Cucumber when you're done:
    callback();
  });
};

module.exports = myHooks;
After hooks

The before hook counterpart is the after hook. It's similar in shape but is executed, well, after every scenario:

// features/support/after_hooks.js

var myAfterHooks = function () {
  this.After(function(callback) {
    // Again, "this" is set to the World instance the scenario just finished
    // playing with.

    // We can then do some cleansing:

    this.emptyDatabase();
    this.shutdownFullTextSearchServer();

    // Release control:
    callback();
  });
};

module.exports = myAfterHooks;
Around hooks

It's also possible to combine both before and around hooks in one single definition with the help of around hooks:

// features/support/advanced_hooks.js

myAroundHooks = function() {
  this.Around(function(runScenario) {
    // "this" is - as always - an instance of World promised to the scenario.

    // First do the "before scenario" tasks:

    this.bootFullTextSearchServer();
    this.createSomeUsers();

    // When the "before" duty is finished, tell Cucumber to execute the scenario
    // and pass a function to be called when the scenario is finished:

    runScenario(function(callback) {
      // Now, we can do our "after scenario" stuff:

      this.emptyDatabase();
      this.shutdownFullTextSearchServer();

      // Tell Cucumber we're done:
      callback();
    });
  });
};

module.exports = myAroundHooks;
Tagged hooks

Hooks can be conditionally elected for execution based on the tags of the scenario.

// features/support/hooks.js (this path is just a suggestion)

var myHooks = function () {
  this.Before("@foo", "@bar,@baz", function(callback) {
    // This hook will be executed before scenarios tagged with @foo and either
    // @bar or @baz.

    // ...

    callback();
  });
};

module.exports = myHooks;

Run cucumber

Cucumber.js includes a binary file to execute the features.

If you installed cucumber.js globally, you may run it with:

$ cucumber.js

You may specify the features to run:

$ cucumber.js features/my_feature.feature

And require specific step definitions and support code files with the --require option:

$ cucumber.js features/my_feature.feature --require features/step_definitions/my_step_definitions.js

If you installed Cucumber locally or with npm install --dev, you'll need to specify the path to the binary:

$ ./node_modules/.bin/cucumber.js

Note to Windows users: invoke Cucumber.js with cucumber-js instead of cucumber.js. The latter is causing the operating system to invoke JScript instead of Node.js, because of the so-called file extension.

Examples

A few example apps are available for you to browse:

Contribute

See CONTRIBUTE.

Help & support