Define extra parameters to use in Cucumber steps.

Description

The following parameter types are available by default:

To use custom parameter types, call define_parameter_type before cucumber::test is called.

Usage

define_parameter_type(name, regexp, transformer)

Arguments

Value

An object of class parameter, invisibly. Function should be called for side effects.

Examples

define_parameter_type("color", "red|blue|green", as.character)
define_parameter_type(
  name = "sci_number",
  regexp = "[+-]?\\\\d*\\\\.?\\\\d+(e[+-]?\\\\d+)?",
  transform = as.double
)

## Not run: 
#' tests/testthat/test-cucumber.R
cucumber::define_parameter_type("color", "red|blue|green", as.character)
cucumber::test(".", "./steps")

## End(Not run)

Hooks

Description

Hooks are blocks of code that can run at various points in the Cucumber execution cycle. They are typically used for setup and teardown of the environment before and after each scenario.

Where a hook is defined has no impact on what scenarios it is run for.

If you want to run a hook only before or after a specific scenario, use it's name to execute hook only for this scenario.

Usage

before(hook)

after(hook)

Arguments

Before

Whatever happens in a before hook is invisible to people who only read the features. You should consider using a background as a more explicit alternative, especially if the setup should be readable by non-technical people. Only use a before hook for low-level logic such as starting a browser or deleting data from a database.

After

After hooks run after the last step of each scenario, even when the scenario failed or thrown an error.

Examples

## Not run: 
before(function(context, scenario_name) {
  context$session <- selenider::selenider_session()
})

after(function(context, scenario_name) {
  selenider::close_session(context$session)
})

after(function(context, scenario_name) {
  if (scenario_name == "Playing one round of the game") {
    context$game$close()
  }
})

## End(Not run)

cucumber Options

Description

Internally used, package-specific options. They allow overriding the default behavior of the package.

Details

The following options are available:

• cucumber.indent

  Regular expression for the indent of the feature files.

  default: ⁠^\\s{2}⁠

See base::options() and base::getOption() on how to work with options.

Run Cucumber tests in a testthat context

Description

It's purpose is to be able to run Cucumber tests alongside testthat tests.

To do that, place a call to run() in one of the ⁠test-*.R⁠ files in your tests/testthat directory.

Usage

run(path = ".", filter = NULL, ...)

Arguments

Value

NULL, invisibly. To get result and a report, use cucumber::test(), or inspect the result of testthat function call.

Examples

## Not run: 
#' tests/testthat/test-cucumber.R
cucumber::run()

## End(Not run)

Define a step

Description

Provide a description that matches steps in feature files and the implementation function that will be run.

Usage

given(description, implementation)

when(description, implementation)

then(description, implementation)

Arguments

Given there is money in my account
Then there is money in my account

Given my account has a balance of £430
Then my account should have a balance of £430

Given my account has a balance of £430

given("my account has a balance of £{float}", function(balance, context) {

})

Details

Placeholders in expressions are replaced with regular expressions that match values in the feature file. Regular expressions are generated during runtime based on defined parameter types.

The expression "I have {int} cucumbers in my basket" will be converted to "I have [+-]?(?<![.])[:digit:]+(?![.]) cucumbers in my basket". The extracted value of {int} will be passed to the implementation function after being transformed with as.integer.

To define your own parameter types use define_parameter_type.

Value

A function of class step, invisibly. Function should be called for side effects.

See Also

define_parameter_type()

Examples

given("I have {int} cucumbers in my basket", function(n_cucumbers, context) {
  context$n_cucumbers <- n_cucumbers
})

given("I have {int} cucumbers in my basket and a table", function(n_cucumbers, table, context) {
  context$n_cucumbers <- n_cucumbers
  context$table <- table
})

when("I eat {int} cucumbers", function(n_cucumbers, context) {
  context$n_cucumbers <- context$n_cucumbers - n_cucumbers
})

then("I should have {int} cucumbers in my basket", function(n_cucumbers, context) {
  expect_equal(context$n_cucumbers, n_cucumbers)
})

Run Cucumber tests

Description

It runs tests from specifications in .feature files found in the path.

To run Cucumber tests alongside testthat tests, see cucumber::run().

Usage

test(
  path = "tests/acceptance",
  filter = NULL,
  reporter = NULL,
  env = NULL,
  load_helpers = TRUE,
  stop_on_failure = TRUE,
  stop_on_warning = FALSE,
  ...
)

Arguments

Good Practices

• Use a separate directory for your acceptance tests, e.g. tests/acceptance.

  It's not prohibited to use tests/testthat directory, but it's not recommended as those tests serve a different purpose and are better run separately, especially if acceptance tests take longer to run than unit tests.

  If you want to run Cucumber tests alongside testthat tests, you can use cucumber::run() in one of the ⁠test-*.R⁠ files in your tests/testthat directory.

• Use ⁠setup-*.R⁠ files for calling step(), define_parameter_type() and hook() to leverage testthat loading mechanism.

  If your step(), define_parameter_type() and hook() are called from somewhere else, you are responsible for loading them.

  Read more about testthat special files in the testthat documentation.

• Use ⁠test-*.R⁠ files to test the support code you might have implemented that is used to run Cucumber tests.

  Those tests won't be run when calling test(). To run those tests use testthat::test_dir("tests/acceptance").

Examples

## Not run: 
cucumber::test("tests/acceptance")
cucumber::test("tests/acceptance", filter = "addition|multiplication")

## End(Not run)

Validate lines read from a feature file

Description

Validate lines read from a feature file

Usage

validate_feature(lines)