Introduction to TDD with Kotlin and JUnit

Welcome to the first lesson of our course on Test Driven Development (TDD) in Kotlin using JUnit and Mockito. TDD is an iterative software development process where tests are written before developing the actual functionality. This methodology emphasizes understanding and meeting the requirements first, which helps create reliable and maintainable code.

In this lesson, we'll introduce you to the essential elements of TDD, including the Red-Green-Refactor cycle, which forms the backbone of this practice. We'll be utilizing tools suited for Kotlin: JUnit, a widely used testing framework for unit testing, and Mockito for mock and behavior-driven development. These tools are excellent for defining and running tests in Kotlin. Let’s get started by exploring the core components of TDD with a practical example.

The TDD process begins with writing a test that fails, marking the "Red" phase. This step helps you define precisely what the code should achieve before creating the actual implementation. Let's write a test for a sum function that will add two numbers.

Create a file named CalculatorTest.kt in the tests directory:

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test

class CalculatorTest {

    @Test
    fun testSumAddsTwoNumbersCorrectly() {
        val calculator = Calculator()
        assertEquals(5, calculator.sum(2, 3))
    }
}

This test script:

• Uses @Test to denote a single test case.
• Instantiates a Calculator class.
• Calls the sum method and checks if the result equals 5.
• assertEquals(expected, actual) verifies that the actual result matches the expected value.

This failure emphasizes the "Red" phase's role in TDD, validating that our test effectively identifies missing features and sets clear goals for implementation.

Expected output:

e: file:///usercode/FILESYSTEM/src/test/kotlin/CalculatorTest.kt:8:26 Unresolved reference: Calculator

This is a normal failure, showing that our test is effective in identifying unimplemented features.

Our next goal is to write the simplest code possible to make the test pass — the "Green" step. In TDD, this means implementing minimal functionality to satisfy the test conditions. Let’s define the sum function in a new file Calculator.kt under the src directory:

class Calculator {
    fun sum(a: Int, b: Int): Int {
        return 5
    }
}

Though this implementation seems simplistic as it doesn't truly add two numbers, it highlights the TDD focus on making the test pass with minimal code. We've thus satisfied the test condition.

Re-running the test should provide the following outcome:

> Task :test

CalculatorTest > testSumAddsTwoNumbersCorrectly PASSED

Seeing the test pass confirms that our code meets the current test scenario. Future tests will guide refinements of this implementation.