ReqNRoll / Specflow and Cucumber - The Master Guide [2025]

Discover how rock and roll boosts acceptance testing within behavior driven development. Learn to install rock and roll extensions for automated tests in Visual Studio and Visual Studio Code.

Discover how rock n roll replaces specflow for .NET BDD, enabling Gherkin with given when then scenarios and automated tests across Windows, macOS, and Linux with MSTest and xUnit support.

Discover how ReqNRoll replaces Specflow to drive behavioural driven development, uncover missing requirements, and boost confidence by creating concrete scenarios that guide code and testing.

Define acceptance tests in BDD to validate the system meets business requirements. Ensure a non-developer SME writes them in plain language, serving as living documentation from database to UI.

Explore unit, integration, API, UI, and end-to-end rock and roll tests, and learn how to craft vertical-slice tests that validate user journeys.

Get a high level overview of writing tests in Specflow with Gherkin feature files. Link Gherkin steps to dot net class methods and build reusable test steps across scenarios.

Install ReqnRoll extensions for Visual Studio 2022 by opening extensions manager, searching for rec n roll, installing, restarting Visual Studio, and verifying the extension is installed.

Install the cucumber gherkin full support extension in Visual Studio Code, then configure cucumberautocomplete.steps to point to the steps folder containing cs files, linking feature files to step definitions.

Create a rock and roll project in Visual Studio 2022, select a test framework and dotnet version, and connect feature files with step definitions via msbuild code generation.

Migrate existing spec flow projects to ReqNRoll by creating a new rock and roll project, copying feature files and JSON, and updating namespaces and hooks.

Explore rock and roll as a replacement for the old spec flow, and learn why developers study it, plus acceptance tests, test types, and installation.

Learn to create a rock and roll class from scratch, understand all components, and link Gherkin scenarios to code behind files using various binding styles, then run tests.

Create a from-scratch rock and roll test project by configuring NuGet packages, organizing features and step definitions, and binding gherkin steps to C# for test execution.

Strip the rock and roll project to a clean state, upgrade the test framework and adapter to version 3.73, and set up a minimal feature with bindings.

Explore an additional ReqNRoll binding method in Specflow and cucumber by defining steps in a C sharp class, using define steps, and pasting them after you go to definition.

Bind gherkin steps to C# step definitions, diagnose pink or purple bindings, and rebuild to resolve unbound steps through synchronization of feature files and code.

Learn how to run tests in ReqNRoll using test explorer, inspect generated tests from Gherkin scenarios, and interpret pass, fail, and pending results along with basic assertions.

Review how to create a rock and roll class from scratch, bind Gherkin to code, fix broken steps, adjust binding styles, and run tests for the first time.

Explore how parameters are handled in SpecFlow, including passing to code-behind, debugging, and handling string and integer arguments with Gherkin data tables and SpecFlow helpers for automated tests.

Learn how ReqNRoll parameters flow from feature files into the code behind, and master debugging with breakpoints, test runners, and stepping through gherkin steps.

Demonstrate passing data tables as parameters into reqnroll tests, including background and scenario outline tables. Explain headers, rows, and how to access values in steps and code-behind.

Create a strongly typed data table by building a product quantities class and mapping data table rows to product id, stock, and basket, with string-to-int conversion for testing.

Learn how to read data tables in a scenario outline, map columns to a product quantities list, and handle naming and alignment issues in SpecFlow and Cucumber.

Recap and advance parameter handling in SpecFlow by debugging parameters, managing string and integer argument parameters, and passing Gherkin data tables to code-behind files.

Discover how Gherkin data tables are handled and parsed by rock and roll, with parameters, extraction of values, and weakly to strongly typed data tables plus table assist methods.

Launch a one-line create set helper method to map data table rows to a product quantities class, resolving column name differences through table aliases and ignoring spaces and case.

Use the create instance helper with a single row data table to map product quantities to stock and product id, avoiding create set and reducing plumbing in SpecFlow tests.

Explore alternative techniques for implementing data tables in Gherkin by converting table data into parameterized steps, creating stock and basket quantities, and constructing objects directly from individual values.

Explore gherkin vertical tables in specflow and cucumber, using a two-column field and value format to map data like stock and basket, working the same as horizontal tables.

Implement test steps for an e-commerce flow by wiring the add to basket action to update stock and basket quantities, using seeded data, given steps, and assertions.

Fix test scenarios by adding a stock check in the add-to-basket step, ensuring not in stock remains when stock is zero and all three tests pass with specflow and cucumber.

Explore table assist methods in SpecFlow and Cucumber, including create instance and data table compare to instance, to cleanly assert stock and basket values from data tables.

Explore how the table assist helper methods fill instance and is equivalent to instance populate and compare object properties in data tables, including horizontal and vertical Gherkin tables.

Explore how to use compare to set to validate multiple basket and stock rows by comparing seeded products against a data table, after removing items from the basket.

Rewrite the then step to test the compare to instance method with one data row, using stock level and basket quantity, remove the data table, and confirm tests go green.

Explore how Gherkin data tables are handled and read from Gherkin tables into the rock and roll implementation code, and compare weakly versus strongly typed tables with table assist methods.

Explore the types of hooks in rock and roll, master debugging and logging, learn why hooks matter, and study hook order and error logging to databases or monitoring systems.

Discover how rock and roll hooks trigger before and after test run, feature, scenario, and step events, and how scenario blocks and gherkin steps sequence these hooks.

Create a hooks class in a rock and roll binding, declare public sealed and static as needed, and wire before test run and scenario hooks.

Learn to add logging to hooks for debugging and trace, outputting hook names and feature/scenario context - title, description, and step text - into the debug window.

Inject the rock and roll output helper into hooks to enable in-context logging, replacing debug writes and ensuring logs appear after each relevant step.

Explore how hooks manage test setup and teardown, including the before test run and after test run hooks. Learn data seeding, database reset, transactions, and browser reuse to improve efficiency.

Explore how identical before hooks fire in order by testing with the order attribute; lower numbers run first, defaults are 10000, and without an explicit order results are non-deterministic.

Inject debugging properties into hooks to access the test assembly location, threading, and framework details via the AI test runner manager, test runner, test method, and test run context.

Discover two methods to inject feature and scenario context into hooks: parameter injection and constructor-based injection via private variables for non-static hooks, with static methods needing parameter injection.

Use the after scenario hook to access the scenario context test error, perform defensive checks for null, and log the stack trace to Grafana or a database.

Explore debugging and logging hooks, learn hook order and preconditions, and identify errors when executing hooks to reinforce rock and roll concepts.

Learn to split features and step definitions into separate files to prevent maintenance issues as your SpecFlow and Cucumber project grows, and organize them using the course project.

Mark steps as pending in Gherkin tests to pause implementation until ready, using a pending step exception or the scenario context pending method via dependency injection.

Discover practical strategies to organize Cucumber and SpecFlow step definitions by feature and by step type, using folder structures to prevent pollution and scale projects.

Refactor step definitions by splitting into three files, remove partial, and move definitions to a new public products class using static fields with bindings for shared test data.

Explore different ways to organize features and steps, and weigh their pros and cons. Organize projects by splitting step files and adopt a better way to organize step definitions.

Explore how to share data between classes with the context based approach, context system, merging scenario context properties, the property bag approach, and dependency injection in this module.

Demonstrates passing data between step classes using the scenario context via dependency injection, removing static state. Seeds data with context keys and updates by reference across tests.

Merge two scenario context entries into a single product test data context, containing seeded products and the product under test, with updates by reference.

Implement a context base class approach by creating a public context helper to access the product test data context from the scenario context and seed products for tests.

Leverage Rocknrolls built-in dependency injection with the resolve method to auto-create and inject context objects, eliminating boilerplate and enabling simple one-line access to product test data context.

Learn a rock and roll dependency injection approach that directly injects the product test data context into step definitions via constructors, eliminating the context helper.

Compare data sharing approaches for test steps, from simple classes with private fields to static methods, Rock'n'roll built-in context objects, and custom context providers, highlighting multi-class support and thread safety.

Recap the module by reviewing the context base class approach, the rock n roll context system with its property bag, merging scenario context properties, and the record roles dependency injection.

Introduce value retrievers in SpecFlow to automate tests, covering date time conversions, enumeration values, and custom string retrievers. Explore handling nulls, dynamic data retrievers, and writing custom comparers.

Learn how to handle date time parameters in rock and roll by converting strings, using value retrievers, and validating dates, with examples of offer codes and expiry dates.

Explore the enum value retriever to convert feature file strings into enum values for step definitions, using offer codes with expiry dates and types like by date and by product.

Implement a custom value retriever to map sizes like XXL, L, and S to an internal size object. Use a data table and tests to validate the translation.

Register a custom value retriever with rock and roll, fix null size values, and ensure key-based retrieval returns sizes like XXL, L, and S.

Build a custom clothes size comparer to translate internal sizes back to public names, and validate the translation with a data table in a SpecFlow and Cucumber workflow.

Create a custom boolean value retriever for Specflow and Cucumber by mapping yes/no and y/t/f to true/false, registering it, unregistering the built-in retriever, and validating with tests.

Take on a challenge to convert user type strings into internal database values using a custom value retriever, building models and a user type enum.

Implement a custom value retriever for the user type enum, mapping to an internal access level. Register the retriever in hooks and validate results via data tables and tests.

Explore how date time fields become null when empty, set last logged in date as nullable, and distinguish between nulls and empty strings in table columns using rock and roll.

Register a null value retriever to distinguish nulls from empty strings in rock and roll, using the word 'null' (case-insensitive) to interpret null, and support asterisks as null markers.

Create a custom string value retriever for Specflow and cucumber by replacing the built-in null value retriever in rock and roll, implementing value retriever interface, and registering the new retriever.

Create a custom string value retriever to parse comma-separated GPS coordinates for stores, populate a geolocation model, and register it for map integration.

Install and use the rock and roll dynamic helper to create dynamic instances and sets, then manipulate incoming data for a table assist workflow while handling geolocation coordinates.

Learn to handle date times, interpret enums with value retrievers, and build a custom string and dynamic data retriever, plus create a custom comparer and manage nulls.

Explore transforming step arguments in rock and roll, including date times, enumerations, and data tables, and understand how they are converted, parsed, and ordered through step transformations and precedence.

Learn to use step argument transformations to convert human-readable strings into date times in feature steps, using custom transformation classes, binding attributes, and regex in rock and roll.

Practice creating a step argument transformation class using a regular expression to extract an ordinal integer and calculate a date, then implement a new transformation for future ordinals.

Implement a step argument transformation class to convert strings like first, second, and third into integer indices, and verify the solution with a feature-driven test.

Transform gherkin data tables into IEnumerable model collections using step argument transformations, replacing create set logic with a dedicated step transformation class for offer codes and product quantities.

Learn the precedence of step argument conversions in rock and roll. The process tries no conversion first, then a custom transformation, then standard dotnet conversions (enums and Guid).

Recap the module topics: step arguments and transformations, data tables, options, and order precedence, plus how steps convert and parse inputs.