Test-driven development (TDD) approach

What is Test-Driven Development (TDD)?

Test-Driven Development (TDD) is a software development approach where you write tests for your code before you write the code itself. This might sound a bit backward at first, but let me explain why it can be a really smart way to write software!

Why Use TDD?

Imagine you’re building a LEGO model. Before you start putting the pieces together, you look at the instruction manual (tests) to see how the final model should look and work. Then, you start building each small part (writing code) to make sure it fits perfectly into the whole model (your software).

How Does TDD Work?

1. Write a Test: You start by writing a test that defines what your code should do. This test should fail because you haven’t written the code yet!

# Example Test (Python)
import unittest

def add_numbers(a, b):
    return a + b

class TestAddNumbers(unittest.TestCase):
    def test_add_positive_numbers(self):
        result = add_numbers(3, 5)
        self.assertEqual(result, 8)

    def test_add_negative_numbers(self):
        result = add_numbers(-3, -5)
        self.assertEqual(result, -8)

Here, we wrote tests (test_add_positive_numbers and test_add_negative_numbers) that check if our add_numbers function works correctly.

2. Run the Test: When you run the test, it fails because the add_numbers function doesn’t exist yet. That’s okay!
3. Write the Code: Now, you write the simplest code that makes the test pass.

def add_numbers(a, b):
    return a + b

After writing this code, run your tests again. They should pass now!

4. Refactor (Optional): Once your test passes, you can make your code better without changing what it does. Refactoring means cleaning up or improving your code.

Practice Questions

1. Question 1: Implement a function multiply_numbers that multiplies two numbers together. Write a test first that checks if your function correctly multiplies two positive numbers.

import unittest

def multiply_numbers(a, b):
    return a * b

class TestMultiplyNumbers(unittest.TestCase):
    def test_multiply_positive_numbers(self):
        result = multiply_numbers(4, 5)
        self.assertEqual(result, 20)

Write the multiply_numbers function so that the test passes.pythonCopy codedef multiply_numbers(a, b): return a * b

2. Question 2: Write a function is_even that returns True if a given number is even, and False otherwise. Write a test first that checks if your function correctly identifies even numbers.

import unittest

def is_even(number):
    return number % 2 == 0

class TestIsEven(unittest.TestCase):
    def test_even_numbers(self):
        self.assertTrue(is_even(4))
        self.assertFalse(is_even(7))

Write the is_even function so that the test passes.

def is_even(number):
    return number % 2 == 0

Test-Driven Development (TDD) helps ensure your code works as expected from the very beginning. By writing tests first, you clarify what your code needs to do and catch bugs early. It’s like building a LEGO model step-by-step with a clear plan in mind!

In summary, TDD can make your coding process more efficient and your software more reliable. Happy coding!

Feel free to ask if you have more questions or want to dive deeper into any part of Test-Driven Development (TDD)!