pytest add arf to decorator function

Yulia Chive

2 min read

·

08-12-2024

5

0

Share

Adding ARF (Assert, Rearrange, Follow-up) to pytest Decorator Functions

Pytest's power lies in its ability to streamline testing, and decorators are a key component of that. They allow you to encapsulate common setup and teardown logic, making your tests cleaner and more maintainable. However, simply using a decorator doesn't automatically guarantee well-structured tests. This article explores how to incorporate the ARF (Assert, Rearrange, Follow-up) pattern into pytest decorator functions for more robust and readable tests.

The ARF pattern encourages a clear separation of concerns within your test functions:

• Assert: This section contains your assertions – the checks that verify the behavior of your code. It should be concise and focused on validating the expected outcomes.

• Rearrange: This part (optional, but highly recommended) handles any necessary modifications to the system under test after the assertions have passed. This often involves cleaning up resources, resetting state, or preparing for subsequent tests.

• Follow-up: This section performs any post-test actions that aren't directly related to assertions or rearrangement. This might include logging, reporting, or additional analyses.

Example without ARF

Let's start with a simple example of a pytest decorator without explicitly following the ARF pattern:

import pytest

@pytest.fixture
def my_fixture():
    # Setup
    data = {'value': 10}
    yield data
    # Teardown (implicitly part of the fixture)


@pytest.mark.parametrize('input_val', [5, 10, 15])
def test_my_function(my_fixture, input_val):
    result = my_function(input_val)  # Assume my_function exists
    assert result == input_val * 2  # Assertion
    # ... more assertions or cleanup mixed in? ... This becomes messy quickly.

This example mixes assertion and implicit cleanup within the test function. While functional, it lacks clarity as the test grows.

Implementing ARF with a Decorator

Now let's refactor this to explicitly follow the ARF pattern using a decorator:

import pytest

def arf_decorator(func):
    def wrapper(*args, **kwargs):
        test_instance = func(*args, **kwargs)  #Allows access to the test function's attributes.

        # Assert Section
        assert test_instance.assertions_passed, "Assertions failed!"

        # Rearrange Section (optional)
        if hasattr(test_instance, 'rearrange'):
            test_instance.rearrange()

        #Follow-up Section (optional)
        if hasattr(test_instance, 'follow_up'):
            test_instance.follow_up()
    return wrapper


@pytest.fixture
def my_fixture():
    data = {'value': 10}
    yield data


@pytest.mark.parametrize('input_val', [5, 10, 15])
@arf_decorator
class TestMyFunction:
    def __init__(self, input_val, my_fixture):
        self.input_val = input_val
        self.my_fixture = my_fixture
        self.assertions_passed = False

    def __call__(self):
        result = my_function(self.input_val)  # Assume my_function exists
        self.assertions_passed = (result == self.input_val * 2) #Assertion Result.
        return self

    def rearrange(self):
        #Cleanup Logic Here, for example:
        print("Cleaning up resources after test")

    def follow_up(self):
        # Additional analysis or logging
        print(f"Test completed with input: {self.input_val}")

This improved version separates the concerns. The arf_decorator manages the flow, ensuring assertions are checked before rearrangement and follow-up. The test is now encapsulated within a class providing a structured container for the ARF sections.

Remember to adapt this structure based on your specific needs. You might not always require all three ARF sections in every test. The key is to organize your test logic for clarity and maintainability, particularly as your tests grow in complexity. This approach promotes better readability and makes it easier to understand the purpose of each part of the test.