Introduction to the AAA Pattern in TDD with Go and Testify

Welcome to the final lesson of our Foundations of TDD in Go and Testify: The Principles course using Go and the Testify library. You have come a long way, mastering various facets of TDD, from setting up your environment to managing dependencies. In this lesson, we’ll delve into the AAA pattern — Arrange, Act, Assert — which is integral to writing structured and clear tests. This lesson ties together all you've learned and prepares you to implement complex testing scenarios with confidence.

In our previous practice, we separated the test code into three sections: Setup, Action, and Validate. In TDD, these sections have defined names: Arrange, Act, and Assert. You can remember it easily as AAA.

Let’s now explore how the AAA pattern complements TDD.

The AAA pattern is essential for writing well-structured tests. It involves three distinct steps:

• Arrange: Set up the context for your test, which may include initializing objects or preparing data.
• Act: Execute the function or method that you are testing, triggering the behavior you're checking.
• Assert: Verify that the results of the act step are as expected, ensuring the test accurately measures the code's behavior.

Applying the AAA pattern ensures your tests are not only readable but also maintainable, providing clear separation between setup, execution, and verification.

Let us explore how to implement a task management system using the AAA pattern. We will apply the Red-Green-Refactor cycle as we work through our tests.

In this example, we will demonstrate how to use the AAA pattern to test the functionality of adding a task to a task management system.

• Arrange: We begin by setting up the necessary context for the test. Here, we create a new instance of TaskList, which will be used to add and manage tasks.

• Act: Next, we invoke the method AddTask on our TaskList instance, passing 'Test task' as the task description. This method call represents the action we are testing.

• Assert: Finally, we verify the outcome. We check that the returned value task is an instance of the Task struct, that its description is 'Test task', and that the task list now contains this new task.

func TestShouldAddTaskToList(t *testing.T) {
    // Arrange
    taskList := &TaskList{}

    // Act
    task := taskList.AddTask("Test task")

    // Assert
    assert.Equal(t, "Test task", task.Description)
    assert.Contains(t, taskList.GetTasks(), task)
}