Published on

Mastering the Arrange, Act, and Assert Pattern

A Guide to Effective Unit Testing

Unit testing is a vital aspect of software development, ensuring code correctness and reliability. However, writing clear and effective tests can be challenging as projects grow in complexity. To simplify this process, developers use the “Arrange, Act, and Assert” (AAA) pattern.

What is the Arrange, Act, and Assert (AAA) Pattern?

The Arrange, Act, and Assert pattern is a structured approach to writing unit tests. It helps in organizing the test code into three distinct sections, making the intent and flow of the tests clearer and easier to comprehend. Let’s break down each part of the AAA pattern:

  1. Arrange: In this first section, you set up the test environment by initializing the objects, creating the required test data, and configuring the necessary dependencies. The primary goal of this step is to arrange all the preconditions necessary to test the target code effectively. By establishing the context for the test, you ensure that it remains isolated and independent of external influences.

  2. Act: The second section involves executing the method or function that you intend to test. This is the step where the actual action occurs, simulating how the code would run in the real application. The objective here is to observe the behavior of the method being tested and capture any output or state changes.

  3. Assert: Finally, in the assert section, you verify the expected outcomes and ensure that the code behaved as intended during the “Act” phase. You compare the actual results obtained during the test execution with the expected outcomes.

Benefits of the AAA Pattern

  • Clarity and Readability: The AAA pattern enhances test readability by structuring the code into well-defined sections. This makes it easier for other developers to understand the purpose and flow of the test, even if they are not familiar with the specific implementation.

  • Maintainability: Separating the test into distinct sections makes it more maintainable in the long run. If changes are required in the test setup (Arrange) or test verification (Assert), you can easily locate and modify the relevant sections without affecting the other parts of the test.

  • Faster Debugging: If a test fails, the AAA pattern can make it easier to pinpoint the cause of the failure. By isolating the Arrange, Act, and Assert phases, you can quickly identify which specific part of the test contributed to the failure.

Using the AAA Pattern with pytest

Let’s illustrate the AAA pattern with two examples: a simple test case for the split string method and a more complex test case for a FastAPI endpoint from a URL Shortener app. We’ll use the pytest framework for both examples.

Example 1: Testing the split String Method

def test_split():
    # Arrange
    s = 'hello world'

    # Act
    result = s.split()

    # Assert
    assert result == ['hello', 'world']

Explanation of the unit test:

  • Arrange: In the test_split function, we define one variable s as the input values for the split method. In this case, the input string is 'hello world'.

  • Act: We then call the split method on the defined input value (s), and the result is stored in the result variable.

  • Assert: Finally, we use the assert statement to verify that the result is equal to the expected value ['hello', 'world'].

Example 2: Testing a FastAPI Endpoint for URL Shortener

from fastapi.testclient import TestClient
from app.main import app

def test_create_url():
    # Arrange
    test_client = TestClient(app)
    target_url = ""

    # Act
    response =
        json={"target_url": target_url}
    payload = response.json()

    # Assert
    assert response.status_code == 200
    assert payload["target_url"] == target_url
    assert payload["is_active"]
    assert payload["clicks"] == 0

Explanation of the unit test:

  • Arrange: In the test_create_url function, we set up a test client using TestClient to simulate HTTP requests against our FastAPI app. We define the target_url, which represents the URL to be shortened.

  • Act: We make a POST request to the /url endpoint with the target_url as JSON data. The response is stored in the response variable, and we extract the JSON payload using response.json().

  • Assert: We use assert statements to verify the following:

    • The response.status_code should be 200, indicating a successful request.
    • The payload["target_url"] in the response should match the target_url we provided.
    • The payload["is_active"] should be True, indicating that the shortened URL is active.
    • The payload["clicks"] should be 0, as the URL is newly created and has not been clicked yet.


The Arrange, Act, and Assert (AAA) pattern is a powerful testing technique that brings structure and clarity to your unit tests. By following this pattern, you can improve the readability and maintainability. Embracing this approach will not only make your tests easier to manage but also help you catch potential bugs early in the development process, contributing to the overall quality of your software.

See also