Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.
Test-Driven Design | Additional Design Approaches
Software Architecture Fundamentals

bookTest-Driven Design

Now that we've covered the essentials of low-level design, let's explore how to test the effectiveness of our design before full implementation. This is where Test-Driven Design (TDD) comes into play.

Test-Driven Design (TDD) is a software development process where tests are written before the actual code. The idea is simple: first, define the requirements through tests, and then write code to make these tests pass.
TDD helps developers write code that fulfills specific needs by focusing on test cases early. It also provides a built-in mechanism for verifying the code’s behavior, making maintenance and debugging easier.

The TDD Cycle: Red, Green, Refactor

TDD follows a structured cycle:

  • Red: write a test that defines an aspect of the desired functionality. Initially, this test should fail because the feature isn't implemented yet;
  • Green: write the minimum code required to pass the test;
  • Refactor: review and improve the code without changing its behavior, keeping it clean and efficient.

Example

In an e-commerce platform, suppose we need to implement a method that calculates the total price of items in a shopping cart. Here's how we might approach it using TDD.

Step 1: Write the Test (Red)

Let's create a test to define our expectations for the total price calculation.

import unittest

class ShoppingCartTest(unittest.TestCase):
def test_calculate_total(self):
# Arrange: Create a shopping cart with two items
cart = ShoppingCart()
cart.add_item("Wireless Headphones", 99.99)
cart.add_item("Running Shoes", 49.99)

# Act: Calculate the total price
total = cart.calculate_total()

# Assert: Verify the total price is correct
self.assertEqual(total, 149.98)

# This test will initially fail since calculate_total() isn’t implemented yet.

Step 2: Implement the Code (Green)

Next, let's implement the minimum code to make this test pass.

class ShoppingCart:
def __init__(self):
self.items = []

def add_item(self, item_name, price):
self.items.append(price)

def calculate_total(self):
return sum(self.items)

Step 3: Refactor

Since the calculate_total() method is simple, it may not need much refactoring. However, this function could become more complex in a real-world scenario, so TDD would allow us to iterate and improve with confidence.

Benefits of TDD

By adopting TDD, we not only ensure that our code meets requirements but also cultivate a mindset focused on precision and maintainability. This is especially useful in complex systems like an e-commerce platform, where every function—from price calculation to inventory management—needs to perform reliably under diverse conditions.

What does the "Red-Green-Refactor" cycle in TDD stand for?

What does the "Red-Green-Refactor" cycle in TDD stand for?

Selecione a resposta correta

Tudo estava claro?

Como podemos melhorá-lo?

Obrigado pelo seu feedback!

Seção 4. Capítulo 1
some-alt