In this lesson, we'll deepen our understanding of the Test-Driven Development (TDD) mindset by focusing on the Red-Green-Refactor cycle with a practical example centered on a CalculateTotal function. This example will guide you through the process of thinking in tests, prioritizing test writing, and leveraging TDD to enhance code clarity, reliability, and maintainability.

Using C# and xUnit, we'll follow these steps:

• Begin with the Red phase by identifying and writing failing tests for the CalculateTotal function, which will compute the total price of items in a shopping cart.
• Move to the Green phase to implement the minimal code required to pass each test, ensuring that the CalculateTotal function behaves as expected.
• Enter the Refactor phase to improve the code structure and readability of CalculateTotal, employing techniques like LINQ aggregation while keeping tests green.
• Utilize xUnit as a testing framework to efficiently integrate the TDD approach within our .NET project.

By working through this example, you'll gain practical experience with TDD principles and develop the CalculateTotal function in a way that showcases how TDD fosters code quality and robustness.

Let's begin by writing tests for a function named CalculateTotal, designed to compute the total price of items in a shopping cart. This is where you engage with the Red phase: Write a failing test.

Let's think about how to build a method that calculates lists of items. What should the interface be? How does the consumer of the code use it? These are the questions we think about first when we "think in tests." Here's one way we might think about it in C#.

Explanation:

• We know we want a method called CalculateTotal(), so we'll write a test that uses it.
• For now, we know that we want an empty array as input to return 0, so we can write that test.
• The expectation is that these tests will initially fail, which is an integral part of the Red phase.

Running these tests confirms they fail, creating a clear path for subsequent development.

Now, let’s move to the Green phase where we implement the minimal code to pass these tests.

Implement the CalculateTotal method in your class:

Explanation:

• The CalculateTotal method takes an array of CartItem objects. We don't really know the shape of the data yet, and that's okay!
• Returning 0 is enough to get the test to pass.

By running the test suite again, we should see all tests passing, demonstrating that our function meets the required condition.

Now is the time to think about what kind of data we want to pass to our CalculateTotal method. We consider that we'd like to pass the name, price, and quantity as properties in the CartItem class. The total will be the product of price * quantity. Let's do that and see how it feels:

That feels pretty good; the interface seems clear. Let's see if we can get those tests passing.

Now we need to think about how to make these tests pass. What is the minimum necessary to get this to pass?

When we run the tests, we should see that both tests pass! We're Green!

Now we ask ourselves: is there anything we can do to make this code better? One thing I might do is get rid of the repetition of accessing the first item in the array. Another thing I might do is ensure each CartItem has well-defined properties.

When we run the tests again, we're still green. The code is more expressive now and reflects the properties of CartItem more clearly, so let's do the Red-Green-Refactor loop again!

The existing code works! But it won't be very useful to only use the first item. If we add one more test, we can generalize more.

As expected, this new test will fail and we can move to the Green step.

Let's take a stab at getting the test to pass:

This does the job, and we're Green again. I can't help but feel like we could have written that code a bit better. Now that we have tests that cover everything we want this function to do, let's move to the Refactor step!

When we look at the CalculateTotal function, it is clear that this is an "aggregate function." It takes a list of items and reduces it to an aggregate value. Times like this call for the use of LINQ!

The Sum method aggregates the total price by multiplying the price and quantity of each CartItem. I like this code a lot better! Best of all, our tests tell us that we're still Green! We've successfully refactored the code.

Running the tests one more time shows we're still green!

In C#, you can run your xUnit tests using a test runner, such as the one integrated into Visual Studio or the command-line tool dotnet test.

Throughout this lesson, we focused on refining the TDD mindset by emphasizing writing tests prior to coding and following the Red-Green-Refactor cycle. Here's what we covered:

• Red Phase: We started by writing failing tests, like determining that CalculateTotal should return 0 for an empty cart and a specific total for a single item. This helped us clearly define our interface and objectives.
• Green Phase: We implemented minimal solutions to pass each test condition. For instance, returning a simple calculation for a single CartItem or a total for an entire list of items.
• Refactor Phase: We improved the code structure and readability, utilizing techniques like LINQ for aggregation, ensuring that the function remains expressive and maintainable while tests continue passing.

These steps in the TDD workflow have shown how test-first development can clarify requirements, ensure accuracy, and guide continuous improvement. This foundation prepares you for practice exercises aimed at reinforcing these techniques, highlighting how TDD fosters clarity, reliability, and robustness in software development.