Popularity
0.6
Growing
Activity
7.1
Declining
10
1
0

Description

This library allows you to easily replace FastAPI dependencies in your tests.

Programming language: Python
License: MIT
Tags: Testing     Dependency Injection     Pytest     FastAPI    

pytest-fastapi-deps alternatives and similar packages

Based on the "Testing" category.
Alternatively, view pytest-fastapi-deps alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of pytest-fastapi-deps or a related project?

Add another 'Testing' Package

README

pytest-fastapi-deps

Build status Python Version Dependencies Status

Code style: black Security: bandit Pre-commit Semantic Versions License

A fixture which allows easy replacement of fastapi dependencies for testing

Installation

pip install -U pytest-fastapi-deps

or install with Poetry

poetry add pytest-fastapi-deps

Use case

Suppose that you have this fastapi endpoint which has a couple of dependencies:

from fastapi import Depends, FastAPI

app = FastAPI()


async def first_dep():
    return {"skip": 0, "limit": 100}


def second_dep():
    return {"skip": 20, "limit": 50}


@app.get("/depends/")
async def get_depends(
    first_dep: dict = Depends(first_dep), second_dep: dict = Depends(second_dep)
):
    return {"first_dep": first_dep, "second_dep": second_dep}

For simplicity, this example holds static dictionaries, but in reality these dependencies can be anything: dynamic configuration, database information, the current user's information, etc.

If you want to test your fastapi endpoint you might wish to mock or replace these dependencies with your test code.

This is where the fastapi_dep fixture comes to play.

Usage

The most basic usage is to replace a dependency with a context manager:

from my_project.main import app, first_dep, second_dep
from fastapi.testclient import TestClient

client = TestClient(app)

def my_second_override():
    return {"another": "override"}


def test_get_override_two_dep(fastapi_dep):
    with fastapi_dep(app).override(
        {
            first_dep: lambda: {"my": "override"},
            second_dep: my_second_override,
        }
    ):
        response = client.get("/depends")
        assert response.status_code == 200
        assert response.json() == {
            "first_dep": {"my": "override"},
            "second_dep": {"another": "override"},
        }

Note how easy it is: you add the fastapi_dep fixture, initialize it with the fastapi app and send a dictionary of overrides: the keys are the original functions while the values are replacement functions.

If your use case is to replace the dependencies for the entire duration of your test, you can use pytest indirect parameters to simplify the body of your test:

import pytest

from my_project.main import app, first_dep, second_dep
from fastapi.testclient import TestClient

client = TestClient(app)

@pytest.mark.parametrize(
    "fastapi_dep",
    [
        (
            app,
            {first_dep: lambda: {"my": "override"}},
        )
    ],
    indirect=True,
)
def test_get_override_indirect_dep_param(fastapi_dep):
    response = client.get("/depends")
    assert response.status_code == 200
    assert response.json() == {
        "first_dep": {"my": "override"},
        "second_dep": {"skip": 20, "limit": 50},
    }

You must use indirect=True and pass a tuple where the first item is the app and the second item is the dictionary with replacement functions.

You can do more fancy stuff and utilize the nature of nested python context managers:

from my_project.main import app, first_dep, second_dep
from fastapi.testclient import TestClient

client = TestClient(app)


def test_get_override_dep_inner_context(fastapi_dep):
    with fastapi_dep(app).override({first_dep: lambda: {"my": "override"}}):
        response = client.get("/depends")
        assert response.status_code == 200
        assert response.json() == {
            "first_dep": {"my": "override"},  # overridden 
            "second_dep": {"skip": 20, "limit": 50},  # stayed the same
        }

        # add another override
        with fastapi_dep(app).override({second_dep: lambda: {"another": "override"}}):
            response = client.get("/depends")
            assert response.status_code == 200
            assert response.json() == {
                "first_dep": {"my": "override"},  # overridden 
                "second_dep": {"another": "override"},  # overridden 
            }

        # second override is gone - expect that only the first is overridden
        response = client.get("/depends")
        assert response.status_code == 200
        assert response.json() == {
            "first_dep": {"my": "override"},  # overridden 
            "second_dep": {"skip": 20, "limit": 50},  # returned to normal behaviour 
        }

    # back to normal behaviour
    response = client.get("/depends")
    assert response.status_code == 200
    assert response.json() == {
        "first_dep": {"skip": 0, "limit": 100},
        "second_dep": {"skip": 20, "limit": 50},
    }

๐Ÿ“ˆ Releases

You can see the list of available releases on the GitHub Releases page.

We follow Semantic Versions specification.

๐Ÿ›ก License

License

This project is licensed under the terms of the MIT license. See LICENSE for more details.

๐Ÿ“ƒ Citation

@misc{pytest-fastapi-deps,
  author = {Peter Kogan},
  title = {A fixture which allows easy replacement of fastapi dependencies for testing},
  year = {2022},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/pksol/pytest-fastapi-deps}}
}

Credits ๐Ÿš€ Your next Python package needs a bleeding-edge project structure.

This project was generated with python-package-template


*Note that all licence references and agreements mentioned in the pytest-fastapi-deps README section above are relevant to that project's source code only.