Step Definitions

Step definitions are defined in ruby files under features/step_definitions/*_steps.rb. Here is a simple example:

Given /^I have (\d+) cucumbers in my belly$/ do |cukes|
   # Some Ruby code here
end

A step definition is analogous to a method definition / function definition in any kind of OO/procedural programming language. Step definitions can take 0 or more arguments, identified by groups in the Regexp (and an equal number of arguments to the Proc).

Then there are Steps. Steps are declared in your features/*.feature files. Here is an example:

Given I have 93 cucumbers in my belly

A step is analogous to a method or function invocation. In this example, you’re “calling” the step definition above with one argument – the string “93”. Arguments are identified by matching the regexp in the step definition and sending the capture groups to the step definition’s block parameters.

In addition to a Regexp and a Proc, Step Definitions start with an adjective or an adverb methods. All Step definitions are loaded (and defined) before Cucumber starts to execute the plain text.

When Cucumber executes the plain text, it will for each step look for a registered Step Definition with a matching Regexp. If it finds one it will execute its Proc, passing all groups from the Regexp match as arguments to the Proc.

The adjective/adverb has no significance when Cucumber is registering or looking for Step Definitions.

Undefined steps

When Cucumber can’t find a matching Step Definition the step gets marked as yellow, and all subsequent steps in the scenario are skipped. If you use --strict this will cause Cucumber to exit with 1

Pending steps

When a Step Definition’s Proc invokes the #pending method, the step is marked as yellow. Pending never causes errors – even with --strict, it just reminds you that you have work to do.

Failed steps

When a Step Definition’s Proc is executed and raises an error, the step is marked as red.

Skipped steps

Steps that follow pending or failed steps are never executed (even if there is a matching Step Definition), and are marked cyan.

Ambiguous steps

Consider these step definitions:

Given /Three (.*) mice/ do |disability|
end

Given /Three blind (.*)/ do |animal|
end

And a plain text step:

Given Three blind mice

Cucumber can’t make a decision about what Step Definition to execute, and wil raise an error telling you to fix the ambiguity.

Duplicate Step Definitions

In Cucumber you’re not allowed to use a regexp more than once in a Step Definition (even across files, even with different code inside the Proc), so the following would cause an error:

Given /Three (.*) mice/ do |disability|
  # some code
end

Given /Three (.*) mice/ do |disability|
  # some other code
end