About the course
Effective collaboration and crystal-clear requirements are the cornerstones of building successful software. Behaviour-Driven Development (BDD) provides a powerful framework to foster shared understanding by defining system behaviour through concrete, collaborative examples. This 3-day hands-on training course is specifically designed for .NET professionals who want to master the automation of these behaviours using Reqnroll, the modern, actively maintained open-source BDD framework and successor to SpecFlow. Participants will gain the practical skills to translate business-readable specifications into robust, maintainable, and collaborative automated acceptance tests that serve as valuable living documentation.
The course begins with a reinforcement of BDD fundamentals and a deep dive into the Gherkin language, equipping participants with the ability to write clear and unambiguous feature files that accurately describe system behaviour. Participants will then transition to mastering the core techniques of automating these specifications with Reqnroll in a .NET environment, learning how to set up a Reqnroll project, link Gherkin steps to executable C# code by writing Step Definitions, and effectively work with data within scenarios using DataTables and the powerful Reqnroll.Assist helpers. A significant portion is dedicated to understanding and applying Reqnroll's Context Injection for safely and cleanly sharing state between steps, a crucial technique for building well-structured and maintainable automation frameworks.
Beyond the core automation mechanics, the course covers essential strategies for structuring and organising Reqnroll assets in larger projects and implementing common automation patterns for interacting with different application layers (such as APIs or user interfaces). Participants will learn how to manage complex data scenarios and leverage Reqnroll's data-driven features like Scenario Outline. The course concludes by demonstrating how to run Reqnroll tests using various methods, interpret the reporting capabilities, and integrate their automated BDD tests into Continuous Integration (CI) pipelines, equipping .NET teams with the comprehensive skills needed to build, maintain, and leverage a powerful suite of automated BDD tests for their applications.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Explain key BDD fundamentals and write clear specifications using Gherkin syntax.
- Set up and configure a BDD automation project using Reqnroll and its tooling (Extension, CLI).
- Write Step Definitions in C# that effectively link Gherkin steps to executable code.
- Work with data in scenarios using Reqnroll DataTables and helper methods (Reqnroll.Assist).
- Manage and share state safely between steps using Reqnroll Context Injection.
- Structure and organise Reqnroll feature files and step definitions for maintainability.
- Implement patterns for automating interactions with different application layers (e.g., API, UI basics) within Reqnroll step definitions.
- Manage complex data scenarios using techniques like Composite Givens and Scenario Outline.
- Run Reqnroll tests using different test runners/CLI, interpret reports, and integrate tests into CI pipelines.
-
This 3-day hands-on training course is designed for .NET Developers, Quality Assurance (QA) professionals, and Automation Engineers who work within the .NET ecosystem and want to learn how to effectively automate Behaviour-Driven Development specifications using the Reqnroll framework. It is ideal for:
.NET teams that are adopting BDD or need to automate their existing Gherkin specifications.
.NET developers and QAs who want to gain practical skills in building robust, maintainable, and collaborative automated acceptance tests.
Automation engineers focusing on .NET applications who are looking to learn Reqnroll and best practices for structuring automation frameworks.
Anyone involved in defining and verifying requirements for .NET applications who wants to gain practical skills in BDD automation.
-
Participants should have:
Practical experience with software development or testing in the .NET environment (preferably using C# as the programming language).
Attended our intro to BDD workshop or have equivalent experience - for instance a basic understanding of Behaviour-Driven Development (BDD) principles (what BDD is, why use it, the concept of Gherkin scenarios).
A development environment set up for .NET development, with a supported .NET SDK installed and a suitable IDE (e.g., Visual Studio, VS Code with C# and Reqnroll extensions, JetBrains Rider).
This course is hands-on and focuses on the automation aspects of BDD using the Reqnroll framework in .NET.
-
This BDD with Reqnroll course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
BDD Fundamentals Review
Quick review of Behaviour-Driven Development (BDD) principles and benefits.
The importance of collaboration (The Three Amigos) and shared understanding.
The Discovery phase: Exploring requirements using examples (Example Mapping/Specification by Example).
The Formulation phase: Writing good BDD scenarios using the Gherkin syntax.
Good and bad scenario writing patterns (The 6 BRIEF principles).
Separation of problem domain (Gherkin) and solution domain (automation code).
Hands-On Lab: Collaborative exercise on Example Mapping for a feature, writing initial Gherkin feature files.
Gherkin Syntax Deep Dive
The Purpose and Structure of Gherkin Feature Files (Feature, Scenario).
Keywords: Given, When, Then - defining context, action, and outcome.
Connecting Steps: And, But.
Providing Context: Background.
Testing Multiple Examples: Scenario Outline and Examples table.
Organising Features: Using Tags (@tagname).
Writing Clear, Concise, and Unambiguous Gherkin.
Hands-On Lab: Writing comprehensive Gherkin Feature files and Scenarios using all key syntax elements, ensuring clarity and adherence to best practices.
Introduction to Reqnroll
What is Reqnroll? Its role as the leading .NET BDD automation framework and successor to SpecFlow.
Installing Reqnroll NuGet packages.
Setting up a Reqnroll project within a .NET solution.
Reqnroll Tooling: Installing and using the Reqnroll Visual Studio/Rider Extension.
Reqnroll Tooling: Using the Reqnroll Command-Line Interface (CLI).
The role of generated code-behind files (.feature.cs) - how Reqnroll links Gherkin to code.
Basic Reqnroll project structure and file naming conventions.
Scenario automation workflow (the test-first thinking, outside-in development loop with Reqnroll).
Hands-On Lab: Setting up a new .NET project and adding Reqnroll, creating a first simple feature file and running it (demonstrating the framework looking for step definitions), exploring generated files and basic Reqnroll tooling features.
Writing Step Definitions with Reqnroll
What are Step Definitions in Reqnroll? The C# code implementation of Gherkin steps.
Matching Gherkin steps to Step Definition methods ([Given], [When], [Then] attributes).
Using Regular Expressions vs. Cucumber Expressions for step matching.
Parameterising Steps: Extracting data from Gherkin text into Step Definition method parameters.
Organising Step Definition files (.cs) and classes.
Best practices for writing maintainable and reusable Step Definitions.
Hands-On Lab: Writing Step Definitions in C# for the Gherkin scenarios from previous labs, implementing the necessary code to make the steps executable, practicing step parameterisation.
Working with Reqnroll DataTables
Introduction to Gherkin DataTables for structured data within scenarios.
Accessing DataTables in Step Definitions using the Reqnroll Table object.
Reqnroll.Assist Helpers: Using methods like CreateInstance<T>(), CreateSet<T>(), FillInstance<T>() to easily map DataTable data to .NET objects (POCOs).
Performing Table Assertions using helper methods like CompareToInstance<T>(), CompareToSet<T>().
Best practices for effectively using DataTables in scenarios.
Hands-On Lab: Updating selected scenarios to incorporate DataTables, writing Step Definitions that process and map DataTable data using Reqnroll.Assist helpers.
Sharing State between Steps with Reqnroll
The challenge of safely and cleanly sharing state between independently executed Step Definitions within a scenario.
Comparing different state sharing options (e.g., static variables - avoid!, ScenarioContext, Context Bags).
Understanding the execution context and scope of Step Definitions in Reqnroll.
Reqnroll Context Injection:
How Reqnroll's built-in dependency injection mechanism works.
Defining and injecting custom state classes or services into Step Definition constructors.
Managing mutable state within injected context classes.
Integrating with other .NET dependency injection containers (brief overview).
Hands-On Lab: Refactoring Step Definitions to implement Reqnroll Context Injection for safely and cleanly sharing necessary state (e.g., created objects, test data) between steps within a scenario.
Structuring Scenarios and Organising Reqnroll Assets
Finding the right structure for Feature files within the project.
Strategies for Organising Step Definition files and classes for maintainability and discoverability in larger projects.
Using Reqnroll Tags (@tagname) effectively for grouping, filtering, and categorising scenarios.
Excluding scenarios or features using tags (@ignore).
Traceability: Linking scenarios to requirements, user stories, or backlog items (using conventions or integration tools - concept).
Reqnroll Configuration (reqnroll.json): Overview of basic configuration options.
Hands-On Lab: Restructuring feature files and step definitions in the project, applying tags for filtering, practicing running subsets of scenarios using tags via the Reqnroll CLI or test runner options.
Managing Data and Scenarios
Strategies for managing complex test data in scenarios and automation code.
Techniques for Pushing data down to the automation layer (reducing excessive data in Gherkin).
Composite Given steps: Creating reusable blocks of setup steps by calling other steps.
Implementing Field and workflow-level defaults for common scenario data.
Strategies for managing Baseline data and implementing test data management.
Reqnroll Data-Driven Scenarios (Scenario Outline): Deep dive into using Scenario Outline and the Examples table for managing data variations for the same scenario structure.
Hands-On Lab: Refactoring scenarios to use Composite Givens, implementing data-driven scenarios using Scenario Outline and Examples in Reqnroll, exploring strategies for test data management.
Module 9: Scenarios vs. Tests & The Testing Pyramid
Clarifying the purpose: Scenarios as illustrations of behaviour vs. Tests for comprehensive coverage.
When to use Data-Driven Scenarios vs. multiple distinct scenarios.
Understanding the Automated Testing Pyramid (Unit, Integration, Acceptance/BDD, UI).
Mapping Reqnroll scenarios to the Testing Pyramid – where automated BDD tests typically fit (Acceptance, Integration levels).
Balancing different levels of automation in a .NET project.
Hands-On Lab: Discussion and analysis exercise on where different types of tests fit within the testing pyramid in a .NET project context, evaluating existing test suites (conceptual).
Structuring the Reqnroll Automation Layer
Separation of automation logic and testing concerns within the Reqnroll project.
Layering the automation solution (e.g., separating UI interaction, API calls, service layer logic).
Common Automation Patterns for Test Maintainability:
Page Object Model (POM) for UI automation (if applicable).
Patterns for API/Service automation clients.
Using the Builder pattern or Factory pattern within automation code.
Where to place Assertions in the automation layer (typically in Step Definitions or dedicated assertion helpers).
Designing for reusability, readability, and maintainability of the automation code.
Hands-On Lab: Restructuring automation code using a layered approach or a pattern like POM (simplified), demonstrating how to keep Step Definitions clean by delegating complex interactions to other classes/layers, integrated via Context Injection.
Running, Reporting & CI Integration with Reqnroll
Running Reqnroll tests:
Using the Test Explorer in Visual Studio/Rider.
Running tests from the .NET CLI (dotnet test) with Reqnroll test runners (NUnit, xUnit, MSTest).
Running tests using the Reqnroll CLI for specific features or tags.
Understanding Reqnroll Reports: Default console output and generating different report formats (e.g., LivingDoc HTML report using Reqnroll.Plus, JUnit XML for CI).
Integrating Reqnroll Tests into Continuous Integration (CI) pipelines:
Configuring CI platforms to execute .NET test with Reqnroll test runners.
Examples: Setting up steps in common CI platforms used in the .NET ecosystem (Azure DevOps Pipelines, GitHub Actions, GitLab CI) to run Reqnroll tests and publish results/reports.
Maintaining BDD Assets (Feature files and Step Definitions) in a CI/CD environment.
Hands-On Lab: Running Reqnroll tests using the CLI and dotnet test, generating test reports, configuring a simple CI pipeline (simulated or using a basic online tool) to run Reqnroll tests and publish reports.
-
Reqnroll Documentation: The official and comprehensive guide for installing, configuring, writing tests, and advanced features in the Reqnroll framework. This should be your primary reference.
Gherkin Reference: Official documentation for the Gherkin language syntax used in feature files.
.NET Testing Documentation: Official Microsoft Learn documentation on testing .NET applications using command-line tools and different test runners (NUnit, xUnit, MSTest), which are used to execute Reqnroll tests.
Trusted by
