Using pytest fixture to save results of requests in a JSON file

What will you learn?

Discover how to utilize pytest fixtures, manage HTTP requests with the requests library, and store data in a JSON file using Python effectively.

Introduction to the Problem and Solution

In this scenario, we aim to streamline the handling of responses obtained from HTTP requests made using the popular requests library within our test cases. By harnessing pytest fixtures, we can encapsulate this functionality into reusable components for improved organization and maintainability of our test code.

The solution entails creating a custom pytest fixture that initializes a class object capable of storing response data and serializing it into a JSON file after each request execution. This structured approach simplifies the testing process while ensuring neat storage and retrieval of request results.


import json
import pytest
import requests

class ResponseHandler:
    def __init__(self):
        self.responses = []

    def save_response_as_json(self, response_data, filename):
        with open(filename, 'w') as file:
            json.dump(response_data.json(), file)

def api_response_handler():
    handler = ResponseHandler()
    yield handler
    handler.save_response_as_json(handler.responses[-1], 'response.json')

def test_example_api(api_response_handler):
    response = requests.get('')

# Copyright PHD



  • pytest Fixture: Define a custom fixture named api_response_handler that creates an instance of the ResponseHandler class before each test function runs.
  • ResponseHandler Class: This class maintains a list of responses received during tests. The method save_response_as_json() saves the latest response as JSON in a specified file.
  • Test Function: In the sample test function (test_example_api), an API request is made using requests.get() and appends the response object to our handler’s list.
  • Fixture Teardown: After each test function run (specified by scope=’function’), serialize the last appended response into ‘response.json’ using our defined method.
    How do fixtures enhance testing efficiency?

    Fixtures enhance testing efficiency by reducing repetitive setup code across multiple tests through reusable components.

    Can I pass parameters or dependencies to fixtures?

    Yes, fixtures support parameterization via arguments passed directly within your test functions or through fixture dependency injection.

    Is it possible to have module-scoped fixtures?

    Certainly! You can create module-scoped fixtures by setting the scope attribute within the @pytest.fixture decorator (e.g., scope=’module).

    Are there predefined built-in fixtures available in pytest?

    Pytest provides several useful built-in fixtures like capsys for capturing stdout/stderr output or tmp_path for managing temporary directories seamlessly during testing procedures.

    How can I conditionally skip running tests based on certain criteria?

    You can skip tests based on specific conditions by utilizing markers such as @pytest.mark.skipif(condition) above your test functions or incorporating skip() calls within your fixture logic for conditional skipping behavior.


    Mastering pytest fixtures allows us to construct robust automation frameworks efficiently while maintaining clean separation between setup actions and actual tests. This proficiency enhances overall testing productivity significantly by promoting reusability and modular design paradigms across diverse project scopes effortlessly. For more insights on advanced Python programming techniques and best practices, visit

    Leave a Comment