Kotlin BDD

Introduction to Behavior-Driven Development

Behavior-Driven Development (BDD) is a software development methodology that extends Test-Driven Development (TDD) by focusing on the behavior of an application from the end user's perspective. BDD tests are written in a natural language format that non-technical stakeholders can understand, making them valuable for communication between developers, testers, product owners, and business analysts.

In this tutorial, we'll explore how to implement BDD in Kotlin applications. We'll cover:

• The core principles of BDD
• Popular BDD frameworks for Kotlin
• Writing BDD-style specifications
• Implementing tests based on those specifications
• Integrating BDD into your development workflow

Core Principles of BDD

BDD emphasizes three main principles:

1. Tests as documentation: BDD tests are written in a way that documents how the system should behave.
2. Ubiquitous language: Everyone involved in the project uses the same terminology, reducing misunderstandings.
3. Focus on behavior: Tests describe the behavior of the system, not its implementation details.

A typical BDD test follows the "Given-When-Then" structure:

• Given: the initial context
• When: an event occurs
• Then: ensure some outcomes

BDD Frameworks for Kotlin

Kotlin has several frameworks that support BDD-style testing:

1. Kotest

Kotest is a flexible and comprehensive testing framework for Kotlin with built-in support for multiple testing styles, including BDD.

First, add Kotest to your project:

kotlin

// build.gradle.kts
dependencies {
    testImplementation("io.kotest:kotest-runner-junit5:5.5.5")
    testImplementation("io.kotest:kotest-assertions-core:5.5.5")
}

Let's write a simple test using Kotest's BDD style:

kotlin

import io.kotest.core.spec.style.BehaviorSpec
import io.kotest.matchers.shouldBe

class CalculatorTest : BehaviorSpec({
    given("A calculator") {
        val calculator = Calculator()
        
        `when`("adding 2 and 3") {
            val result = calculator.add(2, 3)
            
            then("the result should be 5") {
                result shouldBe 5
            }
        }
        
        `when`("subtracting 3 from 5") {
            val result = calculator.subtract(5, 3)
            
            then("the result should be 2") {
                result shouldBe 2
            }
        }
    }
})

class Calculator {
    fun add(a: Int, b: Int) = a + b
    fun subtract(a: Int, b: Int) = a - b
}

Kotest also offers other specification styles like StringSpec, FunSpec, and DescribeSpec.

2. Spek Framework

Spek is another BDD framework designed specifically for Kotlin:

kotlin

// build.gradle.kts
dependencies {
    testImplementation("org.spekframework.spek2:spek-dsl-jvm:2.0.19")
    testImplementation("org.spekframework.spek2:spek-runner-junit5:2.0.19")
}

Here's an example using Spek:

kotlin

import org.spekframework.spek2.Spek
import org.spekframework.spek2.style.gherkin.Feature
import kotlin.test.assertEquals

class CalculatorFeature : Spek({
    Feature("Calculator") {
        val calculator = Calculator()
        
        Scenario("Adding two numbers") {
            var result = 0
            
            Given("a calculator") {
                // Calculator is already initialized
            }
            
            When("adding 2 and 3") {
                result = calculator.add(2, 3)
            }
            
            Then("the result should be 5") {
                assertEquals(5, result)
            }
        }
        
        Scenario("Subtracting numbers") {
            var result = 0
            
            Given("a calculator") {
                // Calculator is already initialized
            }
            
            When("subtracting 3 from 5") {
                result = calculator.subtract(5, 3)
            }
            
            Then("the result should be 2") {
                assertEquals(2, result)
            }
        }
    }
})

3. Cucumber with Kotlin

For more complex BDD testing that includes Gherkin feature files, you can use Cucumber with Kotlin:

kotlin

// build.gradle.kts
dependencies {
    testImplementation("io.cucumber:cucumber-java8:7.11.1")
    testImplementation("io.cucumber:cucumber-junit:7.11.1")
}

First, create a feature file (e.g., src/test/resources/features/calculator.feature):

gherkin

Feature: Calculator
  As a user
  I want to use a calculator to perform basic arithmetic operations
  So that I can avoid making calculation errors

  Scenario: Adding two numbers
    Given I have a calculator
    When I add 2 and 3
    Then the result should be 5

  Scenario: Subtracting numbers
    Given I have a calculator
    When I subtract 3 from 5
    Then the result should be 2

Then implement the step definitions:

kotlin

import io.cucumber.java8.En
import kotlin.test.assertEquals

class CalculatorStepDefs : En {
    private lateinit var calculator: Calculator
    private var result = 0

    init {
        Given("I have a calculator") {
            calculator = Calculator()
        }

        When("I add {int} and {int}") { a: Int, b: Int ->
            result = calculator.add(a, b)
        }

        When("I subtract {int} from {int}") { a: Int, b: Int ->
            result = calculator.subtract(b, a)
        }

        Then("the result should be {int}") { expected: Int ->
            assertEquals(expected, result)
        }
    }
}

Real-World Example: Shopping Cart

Let's create a more comprehensive example using a shopping cart application with Kotest:

kotlin

import io.kotest.core.spec.style.BehaviorSpec
import io.kotest.matchers.shouldBe

class ShoppingCartTest : BehaviorSpec({
    given("An empty shopping cart") {
        val cart = ShoppingCart()
        
        `when`("a product is added") {
            cart.addProduct(Product("Laptop", 999.99))
            
            then("the cart should contain 1 item") {
                cart.itemCount shouldBe 1
            }
            
            then("the cart total should be the product price") {
                cart.total shouldBe 999.99
            }
        }
        
        `when`("multiple products are added") {
            cart.addProduct(Product("Mouse", 24.99))
            cart.addProduct(Product("Keyboard", 59.99))
            
            then("the cart should contain the correct number of items") {
                cart.itemCount shouldBe 2
            }
            
            then("the cart total should be the sum of product prices") {
                cart.total shouldBe 84.98
            }
        }
    }
    
    given("A shopping cart with products") {
        val cart = ShoppingCart()
        cart.addProduct(Product("Phone", 799.99))
        cart.addProduct(Product("Case", 29.99))
        
        `when`("a product is removed") {
            cart.removeProduct("Phone")
            
            then("the cart should not contain that product") {
                cart.contains("Phone") shouldBe false
            }
            
            then("the cart total should be updated") {
                cart.total shouldBe 29.99
            }
        }
        
        `when`("applying a discount") {
            cart.applyDiscount(10.0) // 10% discount
            
            then("the cart total should reflect the discount") {
                cart.total shouldBe 747.97 // (799.99 + 29.99) * 0.9
            }
        }
    }
})

// Implementation classes
data class Product(val name: String, val price: Double)

class ShoppingCart {
    private val products = mutableListOf<Product>()
    private var discountPercentage = 0.0
    
    val itemCount get() = products.size
    val total get() = products.sumOf { it.price } * (1 - discountPercentage / 100)
    
    fun addProduct(product: Product) = products.add(product)
    
    fun removeProduct(productName: String) {
        products.removeIf { it.name == productName }
    }
    
    fun contains(productName: String): Boolean = 
        products.any { it.name == productName }
    
    fun applyDiscount(percentage: Double) {
        discountPercentage = percentage
    }
}

This example demonstrates how BDD tests can document application behavior in a clear, readable manner.

BDD Best Practices

1. Start with user stories: Begin by writing user stories that capture what users need.
2. Use scenario titles that convey intent: Make them clear and descriptive.
3. Focus on behavior, not implementation: Your tests should remain valid even if you change the implementation.
4. Keep scenarios independent: Each scenario should be able to run in isolation.
5. Use plain language: Avoid technical jargon where possible.
6. Avoid implementation details in specifications: Focus on "what" not "how".

Common Pitfalls to Avoid

1. Writing too many scenarios: Focus on key behaviors.
2. Making scenarios too complex: Each scenario should test one thing.
3. Testing implementation details: BDD is about behavior, not implementation.
4. Duplication between scenarios: Reuse Given steps where appropriate.

Integration with Development Workflow

BDD can be integrated into your development workflow:

1. Collaboration: Business analysts, developers, and testers collaborate to write scenarios.
2. Automated testing: Scenarios are automated as part of the CI/CD pipeline.
3. Living documentation: Test results can be published as documentation.

For example, you can generate reports with Cucumber:

kotlin

// Add to build.gradle.kts
plugins {
    id("com.github.spacialcircumstances.gradle-cucumber-reporting") version "0.1.25"
}

cucumberReporting {
    outputDir = file("$buildDir/reports/cucumber")
    buildId = "1"
    reports = listOf(
        mapOf("json" to file("$buildDir/cucumber/cucumber.json"))
    )
}

Summary

Behavior-Driven Development provides a structured approach to testing that focuses on application behavior from the user's perspective. By using Kotlin's BDD frameworks like Kotest, Spek, or Cucumber, you can create readable tests that serve as living documentation for your system.

BDD helps bridge the gap between technical and non-technical team members by using a common language to describe application behavior. This leads to better understanding of requirements, fewer defects, and more maintainable code.

Exercises

1. Create a BDD test suite for a simple StringUtils class with methods like reverse(), isPalindrome(), and countWords().

2. Implement a UserAuthenticator class with BDD tests for login, logout, and password validation behaviors.

3. Choose an existing project and refactor some of its unit tests to follow BDD patterns using one of the frameworks discussed.

Additional Resources

• Kotest Documentation
• Spek Framework Guide
• Cucumber JVM Documentation
• BDD in Action (Book)
• The RSpec Book (While focused on Ruby, the concepts apply to any BDD implementation)