BDD vs Gherkin vs TDD

This table highlights the fundamental aspects of BDD, Gherkin, and TDD, their purposes, the stakeholders they involve, and how they are typically used in the software development lifecycle.

Feature	BDD (Behavior-Driven Development)	Gherkin	TDD (Test-Driven Development)
Category	Software Development Methodology	Domain Specific Language (DSL)	Software Development Methodology
Primary Focus	Collaboration between technical and non-technical stakeholders	Writing scenarios in human-readable format	Writing tests before code
Language	Uses domain-specific language indirectly through tools like Cucumber	Structured, English-like language	Any programming language used for development
Purpose	Enhance understanding across team members, drive development through behavior	Describe software behavior in understandable terms	Ensure code meets the specified requirements first
Stakeholders Involved	Developers, Testers, Business Analysts, Product Owners	Developers, Testers, Business Analysts	Developers, sometimes Testers
Output	Executable specifications, living documentation	Scenarios that guide development and testing	Unit tests, software design
Workflow	Define behavior in scenarios -> Implement functionality -> Refactor	Used within BDD as a format for writing scenarios	Write a test -> Make it pass -> Refactor
Tool Examples	Cucumber, SpecFlow, Behave	Cucumber (interprets Gherkin), SpecFlow	JUnit, NUnit, xUnit

BDD (Behavior-Driven Development) Example

In BDD, behavior is described in a format that is understandable to all stakeholders. Here's an example of how a feature might be described:

Feature: User login

Scenario: Successful login with correct credentials

Given a user has navigated to the login page
When the user enters their correct username and password
And the user clicks on the login button
Then the user is taken to the dashboard page

This scenario is then implemented by developers and automated by testers using tools that support BDD, such as Cucumber or SpecFlow.

Gherkin Example

Gherkin is the language used to write the scenarios in BDD. The above BDD example is actually written in Gherkin syntax. Here's a brief snippet:

Feature: User Login
As a registered user
I want to log in with my credentials
So that I can access my dashboard

Scenario: Successful login with correct credentials
Given I am on the login page
When I enter my correct username and password
And I click the login button
Then I should be redirected to my dashboard

Gherkin focuses on the "Given-When-Then" syntax to describe preconditions, actions, and expected outcomes.

TDD (Test-Driven Development) Example

TDD involves writing a test before writing the code that makes the test pass. Here's a simplified example in C# using NUnit for a function that adds two numbers:

1. Write the Test First:

[Test]
public void Should_AddTwoNumbers_Correctly()
{
    // Arrange
    var calculator = new Calculator();

    // Act
    var result = calculator.Add(2, 3);

    // Assert
    Assert.AreEqual(5, result);
}

2. Run the Test (it fails because Calculator.Add doesn't exist yet).
3. Write the Minimal Code to Pass the Test:

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

4. Refactor both test and code, if necessary, and re-run the test to ensure it still passes.

Every Bit of Support Helps!

If you have enjoyed this post, please consider buying me a coffee ☕ to help me keep writing!