Missing query param `args` when using dependency_overrides

[ascended121]

First check

• I added a very descriptive title to this issue.
• I used the GitHub search to find a similar issue and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.
• After submitting this, I commit to one of:
  • Read open issues with questions until I find 2 issues where I can help someone and add a comment to help there.
  • I already hit the "watch" button in this repository to receive notifications and I commit to help at least 2 people that ask questions in the future.
  • Implement a Pull Request for a confirmed bug.

Example

Note that this is not a self-contained example (extracting the database code into something others would be able to easily run proved challenging), but hopefully its enough to illustrate the problem:

main.py

from fastapi import Depends, FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from sqlalchemy.orm import Session

import database

app = FastAPI()
templates = Jinja2Templates(directory="templates/")

def get_db():
    """Get and manage closure of database."""
    db_session = database.get_session()
    db = db_session()
    try:
        yield db
    finally:
        db.close()

@app.get("/", response_class=HTMLResponse)
async def home(
    request: Request,
    db: Session = Depends(get_db),
    param1="",
    param2="",
):
    # do stuff
    return templates.TemplateResponse(
            "home.html",
            {
                "request": request,
                "param1": param1,
                "param2": param2,
            },
        )

conftest.py

import unittest.mock as mock
import pytest
from fastapi.testclient import TestClient
import sqlalchemy
from main import app

@pytest.fixture
def test_app_mock_db():
    """Create a TestClient and mock out the database."""
    # Use FASTAPI's mocking framework to replace the get_db dependency with a
    # mock
    #
    # Note that this is implemented on the app object itself and so will persist
    # until undone
    app.dependency_overrides[main.get_db] = mock.MagicMock(
        spec=sqlalchemy.orm.Session
    )
    with TestClient(app) as client:
        yield client

    # remove the mock at the end of the test
    del app.dependency_overrides[main.get_db]

test_home.py

def test_home(test_app_mock_db):
    """Verify home page is created properly."""
    response = test_app_mock_db.get("/")
    print(response.json())
    assert response.status_code == 200

Description

When attempting to test and endpoint, I'm getting a 422 response and

{'detail': [{'loc': ['query', 'args'], 'msg': 'field required', 'type': 'value_error.missing'}, {'loc': ['query', 'kwargs'], 'msg': 'field required', 'type': 'value_error.missing'}]}

args is not the name of any of the parameters the endpoint takes, so its unclear why FASTAPI thinks its missing. I've been unable to find problems similar to this by searching google with that error information, so it appears that its not common for this to occur.

I have several other endpoints returning TemplateResponses for which this problem does not occur (I get HTTP 200 in the tests). It seems to only affect the endpoints which use the database, which I'm attempting to mock in my fixture, and affects the tests for all endpoints which use the database.

I can confirm that get_db is getting overridden and is not being called (since it throws an error in my test environment), however I do not know why mocking it appears to make FASTAPI expects an args query parameter.

For kicks and giggles, I've tried modifying my test query to provide an args query parameter:

    response = test_app_mock_db.get("/?args=True")

which yields the error:

{'detail': [{'loc': ['query', 'kwargs'], 'msg': 'field required', 'type': 'value_error.missing'}]}

If I also pass in kwargs:

    response = test_app_mock_db.get("/?args=True&kwargs=True")

I do indeed get a 200 back, but clearly this is incorrect usage since FASTAPI should not expect python's args/kwargs as query parameters???

What is the proper way to mock out the database calls in this context?

Environment

• OS: Ubuntu
• FastAPI Version: 0.65.0
• Python version: 3.8.5

[eboddington]

I'm having a similar issue and have simplified it to a minimal, self-contained example:

import unittest.mock
from functools import lru_cache

from fastapi import FastAPI, Depends, HTTPException
from fastapi.testclient import TestClient


@lru_cache
class FooStore:
    def __init__(self):
        self.__store = {}

    def get(self, foo_id: int):
        try:
            return self.__store[foo_id]
        except KeyError:
            raise HTTPException(status_code=404, detail="Foo not found")


app = FastAPI()


@app.get("/foo/{foo_id}")
def get_query(foo_id: int, foo_store: FooStore = Depends()):
    return foo_store.get(foo_id)


class FooTestCase(unittest.TestCase):
    def setUp(self) -> None:
        app.dependency_overrides[FooStore] = unittest.mock.MagicMock()
        self.client = TestClient(app)

    def test_get_foo_404(self):
        response = self.client.get("/foo/1")
        json = response.json()
        print(json)

        self.assertEqual(404, response.status_code)

In this example, FooStore is a singleton instance of a class providing access to some shared storage. It's used directly with Depends.

I'm then using unittest and dependency_overrides to override it with a MagicMock, and once I do that, I get this output:
{'detail': [{'loc': ['query', 'args'], 'msg': 'field required', 'type': 'value_error.missing'}, {'loc': ['query', 'kwargs'], 'msg': 'field required', 'type': 'value_error.missing'}]}

The test, of course, fails, because it receives a 422 code instead of 404.

The code above more closely matches my real code, but an even simpler example reveals that the same thing happens with a dependency function:

def get_db():
    return {1: "foobar"}


app = FastAPI()


@app.get("/foo/{foo_id}")
def get_query(foo_id: int, db: dict = Depends(get_db)):
    try:
        return db[foo_id]
    except KeyError:
        raise HTTPException(status_code=404)


class FooTestCase(unittest.TestCase):
    def setUp(self) -> None:
        app.dependency_overrides[get_db] = unittest.mock.MagicMock()
        self.client = TestClient(app)

    def test_get_foo_404(self):
        response = self.client.get("/foo/1")
        json = response.json()
        print(json)

        self.assertEqual(404, response.status_code)

Environment

• OS: macOS 11.5
• FastAPI version: 0.68.0
• Python version: 3.9.6

[Mause]

Try

app.dependency_overrides[get_db] = lambda: unittest.mock.MagicMock()

Instead

[eboddington]

Try

app.dependency_overrides[get_db] = lambda: unittest.mock.MagicMock()

Instead

This seems to be working, thanks! Do you know why? Is it because FastAPI expects the dependency overrides to be a callable returning the dependency, so we were getting the equivalent of MagicMock()()?

[Mause]

To override a dependency for testing, you put as a key the original dependency (a function), and as the value, your dependency override (another function).

https://fastapi.tiangolo.com/advanced/testing-dependencies/#use-the-appdependency_overrides-attribute

[eboddington]

But dependencies can of course be a class as well.

Interestingly though, on doing more testing, it seems there's something specific to MagicMock here. If I do something similar to what the docs suggest, but with my own override class, it works as expected (this test passes):

import unittest.mock

from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient

app = FastAPI()


class Foo:
    def get(self, foo_id: int):
        return foo_id


class FooOverride:
    def get(self, _):
        return 999


@app.get("/foo/{foo_id}")
def get(foo_id: int, foo: Foo = Depends(Foo)):
    # The regular dependency returns what we pass in, the override returns something different
    return foo.get(foo_id)


class FooTestCase(unittest.TestCase):
    def setUp(self) -> None:
        app.dependency_overrides[Foo] = FooOverride
        self.client = TestClient(app)

    def test_get_foo_overriden(self):
        response = self.client.get("/foo/1")

        self.assertEqual(200, response.status_code)
        self.assertNotEqual(1, response.json())

Replacing app.dependency_overrides[Foo] = FooOverride with app.dependency_overrides[Foo] = unittest.mock.MagicMock causes the test to fail. Replace it with app.dependency_overrides[Foo] = lambda: unittest.mock.MagicMock() and the test passes again.

[sy-be]

Probably late to the discussion, but setting dependency overrides to lambda: None works as well:
app.dependency_overrides[Foo] = lambda: None

[klaa97]

The problem of the signature is specific to MagicMock, which must be able to be called with any parameters (therefore, the signature is *args, **kwargs). FastAPI to check the dependencies simply inspect the signature, therefore you get those missing parameters error. Check out the code in FastAPI.

A simple solution would be to do something like this:

from mock import create_autospec

app.dependency_overrides[Foo] = create_autospec(lambda: None)

The main advantage is that you keep a mock as your dependency, therefore you can assert whether it has been called for example.

It works due to the fact that lambda: None has an empty signature, and Python mocks support the signature injection after Python 3.8.