Actor’s Factory

Actors are often used, so it’s worthwhile to have a class that creates dependencies based on specifications. For example, it can create an authorized or anonymous user, one with items in a cart, or one who visited specific pages. Below is an example of an anonymous user for my latest app:

class AnonymousUserFactory:
    """
    Class responsible for the creation and distribution of AnonymousUsers.
    """

    def __init__(self):
        self._users = {}

    def get_user(self, name: str) -> AsyncClientForTests:
        """
        Gets a user by name. If a user is not in the factory, it creates a new one.
        """

        if name not in self._users:
            self._users[name] = self._create(name)

        return self._users[name]

    def _create(self, name: str):
        """
        Creates a new anonymous user with cookies as name.
        """

        client = AsyncClientForTests({})
        client.cookies = {"ANONYMOUS_USER_EXTERNAL_ID": name}
        client.uid = name
        return client

Thanks to the factory, you can create as many clients as you want, ready to use in tests. You just need to turn them into a fixture:

@pytest.fixture
def anonymous_user_for_testing_subscription(anonymous_user_factory) -> AsyncClientForTests:
    return anonymous_user_factory.get_user("subscription_test")

Actors in Your Story

Since actors play such a big role in tests, we must simplify their use as much as possible. In Hollywood, it’s said that the more backstory an actor knows, the better they perform. Similarly, in programming, it helps to ensure that the actors you create include basic information about who they are—perhaps which organization they belong to, or other specifics. Design this class to serve you well.

Actors in tests are mainly responsible for sending requests and providing responses. To simplify future work, I advocate for creating additional layers. For example, in Django with pytest, abstract the client to protected values in a class. You’ll find all these principles detailed in my GitHub repository.

class AsyncClientForTests:
    def __init__(self, headers, email: str = None, uid: str = None, password: str = None, organization_id: str = None):
        self.email = email
        self.uid = uid
        self.password = password
        self.organization_id = organization_id
        self.organization_name = None
        self._headers = headers
        self._client = AsyncClient()

    @property
    def headers(self):
        return self._headers

    @property
    def cookies(self):
        return self._client.cookies

    @cookies.setter
    def cookies(self, cookies: dict):
        self._client.cookies = SimpleCookie(cookies)

    @headers.setter
    def headers(self, headers):
        self._headers = headers

    async def get(self, path) -> ResponseChecker:
        response = await self._client.get(path, headers=self._headers)
        response_checker = ResponseChecker(response)
        return response_checker

I also implemented a ResponseChecker abstraction to consolidate rules and common repetitions in response checking. This way, predefined methods are used instead of endlessly repeating similar checks. Pagination is an excellent example. If your project requires a specific pagination structure, you can add it to ResponseChecker to validate individual elements.

class ResponseChecker:
    """
    Class responsible for response checking during end-to-end testing.
    """

    def __init__(self, response: Response):
        """
        Initialize the ResponseChecker with a response object.
        Automatically processes the response to extract status and JSON content.
        """
        self._response = response
        self._status = None
        self._json = None
        self._process_response()

    def _process_response(self):
        """
        Extracts JSON data and status code from the response object.
        If the response has no content, sets JSON to an empty dictionary.
        """
        self._json = self._response.json() if self._response.content else {}
        self._status = self._response.status_code

    def key_value(self, key: str) -> dict | object | str:
        """
        Retrieve a specific key's value from the response JSON.
        Asserts if the key is not found in the JSON data.
        """
        value = self._json.get(key, None)
        assert value, f"Key {key} not found in response data."
        return value

    def has_cookies(self, key: str) -> str:
        """
        Check if a specific cookie key exists in the response cookies.
        Asserts if the key is not present.
        """
        cookies = self._response.cookies
        assert key in cookies, f"Key {key} is not in cookies."
        return cookies[key].value

    def paginated(self, min_number_of_records: int = 0):
        """
        Validate and retrieve pagination data and results from the response JSON.
        Asserts if results or pagination data are missing or insufficient.
        """
        results = self._json.get("results", None)
        pagination_data = self._json.get("pagination", None)
        results_number = len(results)
        assert results_number > 0, f"Results number is {results_number}, " \
                                   f"but should be at least {min_number_of_records}"
        assert results is not None, "No results data"
        assert pagination_data is not None, "No pagination data"
        pagination = PaginationDTO(**pagination_data)
        return results, pagination

Additionally, with normalized errors transformed into responses, you can check their structure and content. In my project, an error class automatically generates a specific response via middleware that catches errors and builds responses. This ensures the API creates a user-friendly response during errors:

    def check_exception(self, api_exception: ApiException):
        """
        Verify that the response matches the expected API exception.
        Asserts if the status code or error message does not match.
        """
        exception_status_code = getattr(api_exception, '_status_code')
        assert self._response.status_code == exception_status_code, f"Status is: {self._status} " \
                                                                    f"but should be: {exception_status_code}"
        error_message = getattr(api_exception, '_api_client_message')
        message = self.key_value("message")
        assert error_message == message, f"Message to client is: {message}" \
                                         f"but should be: {error_message}"

Summary

Movies without actors would be dull, and so would your end-to-end tests without actors—they might as well qualify for a Razzie. Actors save time, let you write business scenarios for testing your solution, and focus on what matters most: how your solution is perceived by clients. Even a great script falters if a B-list actor shows up on screen.

Alex

P.S.: You can find my test package in my repository