StandardCucumberSteps 1.0.5

Standard Cucumber Steps

TLDR: Reusable Cucumber step definitions for TypeScript, Java, Go, and C# — a single canonical DSL for BDD testing across languages. An excellent fit for hands-off, agentic code development.

What this is

The downside of BDD / Cucumber is having to maintain the step code - code that links step text (Given... When... Then...) to executable code in the tests themselves.

Standard Cucumber Steps (SCS) is a library of pre-built Cucumber step definitions, available for TypeScript, Java, Go, and C#. Instead of writing Given, When, and Then glue code yourself, you import SCS and immediately get a rich vocabulary for calling functions, inspecting results, and asserting on data — all driven by a shared scenario language.

Why this is useful

Cucumber is a good fit for some testing problems and a poor fit for others. Before reaching for it, it is worth understanding the trade-offs:

SCS addresses the maintenance cost directly: writing step definitions is repetitive boilerplate that every project reimplements. SCS does it once, correctly, across four languages.

This is especially valuable when:

• Testing a cross-language API or SDK — write the scenarios once, run them in each language's test suite to verify consistent behaviour.
• Migrating between languages — the same feature files document the expected contract before, during, and after a migration.
• Adopting BDD on an existing codebase — wire up your service with a few lines in a @Before hook and the step library covers the rest.
• Writing tests for generated code — code generators that target multiple languages can share a single golden test suite.
• Working with agentic AI coding - Feature files are an unusually clear form of instruction both for an AI coding agent and a human reviewer. See BDD and SCS for AI agentic coding for a full discussion.

Quick example

Let's say you have this interface (TypeScript):

interface BankAccount {

  deposit(amt: number)

  getBalance(): number

}

We can write this feature file to test the implementation:

Scenario: Depositing money increases the balance
  Given "account" is set up as a bank account with balance "0"
  When I call "{account}" with "deposit" using argument "100"
  And I call "{account}" with "deposit" using argument "50"
  And I call "{account}" with "getBalance"
  Then "{result}" is "150"

The Given step is the only language-specific glue you need to write — it puts your object into the shared props store. Every other step comes from SCS.

See the tutorial for a full walkthrough.

Quick Start

TypeScript

npm install @robmoffat/standard-cucumber-steps

import { setupGenericSteps, PropsWorld } from '@robmoffat/standard-cucumber-steps';

setWorldConstructor(PropsWorld);
setupGenericSteps();

Java (Maven)

<dependency>
  <groupId>io.github.robmoffat</groupId>
  <artifactId>standard-cucumber-steps</artifactId>
  <version>0.1.0</version>
</dependency>

Go

go get github.com/robmoffat/standard-cucumber-steps/go

import generic "github.com/robmoffat/standard-cucumber-steps/go"

world := generic.NewPropsWorld()
world.RegisterSteps(ctx)

C# (NuGet)

dotnet add package StandardCucumberSteps

See it in action

The same feature files run across all supported languages, producing consistent test results:

TypeScript

Java

Go

Bank account examples

The examples/ directory contains two small runnable TypeScript projects that illustrate the difference between the anti-pattern and the correct approach:

Step Reference

Full documentation with examples for each step group:

• Variables — storing and referencing props, boolean/null/numeric literals
• JSONPath — navigating nested objects and arrays inside {...} references
• Assertions — equality, contains, numeric comparisons, error assertions
• Method Calls — calling functions and object methods
• Async Steps — async functions and background jobs
• Array Assertions — matching arrays and objects against data tables
• Test Setup — invocation counters, async functions, delays

Variables

JSONPath

Any {...} reference containing a dot or bracket is resolved as a path into the stored object. This applies in step arguments and DataTable column headers.

Assertions

Method Calls

Async Steps

Array Assertions

Test Setup

Shared Feature Files

The features/ directory contains .feature files that exercise every canonical step. Each language implementation points its test runner at this shared directory, so the same scenarios validate all four implementations.

Used by

SCS was extracted from three FINOS open-source projects. Factoring it out into a shared library means each project gets consistent behaviour.

Each of these projects wires up its own domain objects in a single @Before hook and then delegates all step execution to SCS.

License

Apache 2.0