Test the App in Process

Your app has two path operations and no way yet to receive a request. In Lesson 10.4 you gave an httpx client a transport of your own, httpx.MockTransport, whose handler answered every request in the same process, with no server and no port. FastAPI ships the same idea pointed at an app. Open tests/test_app.py; its first test already uses it:

def fresh_client(state=None):
    reading_app.reset_state(state)
    return TestClient(reading_app.app)


def test_list_books_is_json():
    response = fresh_client().get("/books")
    assert response.status_code == 200
    assert response.json()["books"][0]["title"] == "Kindred"

TestClient(app) is an httpx client whose transport calls the app directly. get("/books") builds an httpx.Request, the transport hands it to FastAPI as if it had arrived on a connection, and FastAPI’s reply comes back as an httpx.Response with the status_code, headers, and json() you used in Chapter 10. The client’s base URL is http://testserver, a name nobody looks up: no connection is made, no port is opened, and nothing leaves the Python process. That is why this chapter can test the app without a server.

Chapter 5’s cases, asked again

Here are the read cases from Chapters 4 to 6, asked of your Chapter 9 server in reading_server.py and of the FastAPI app with Lesson 1’s functions, on the versions this course uses (the ones in requirements.txt):

The first four rows answer as before, with a fraction of the code. The last four are decisions FastAPI made for you:

• HEAD. The @app.get line registers a route for GET only, and FastAPI does not add HEAD to it, so the app answers 405. In Lesson 4.5 you made your own server answer HEAD like GET.

• The allow list. Two routes share the path /books, one for GET and one for POST. When neither accepts the method, FastAPI’s 405 lists the methods of only the first route whose path matched. RFC 9110 says Allow lists the methods the resource supports, so this list leaves out POST.

• /books/abc. The book_id: int annotation from Lesson 1: FastAPI cannot make an int of abc, so it answers 422 before your function runs.

• The trailing slash. FastAPI redirects /books/ to /books with a 307, to an absolute URL built from the host the request named. A 307 keeps the method, as a 308 does, but says the move is temporary. TestClient follows redirects unless you pass follow_redirects=False, so a plain get("/books/") shows you the 200 at the end.

So the table splits at one line. Find where each request stops on its way in:

GET /nowhere, HEAD /books, DELETE /books, GET /books/abc and GET /books/ never reach your code: FastAPI answers them itself. Only GET /books, GET /books/2 and GET /books/99 call your functions.

Tests that record a decision

The rows for /books, /books/2, and /books/99 test your functions. The others test FastAPI: even the 404 for /nowhere is FastAPI’s, since no route matches. A test that asserts HEAD /books gets 405 does not claim that 405 is right. It records what this app does today, on these versions. If a later FastAPI starts answering HEAD, that test fails, and the failure tells you the framework changed under you, which is worth knowing before a client does. Lesson 2’s second test records two of these answers.

Build the client in each test

fresh_client() resets STATE and builds a TestClient for reading_app.app each time a test calls it. That matters for Check my work: it runs your tests against other versions of the app, each with one mistake, and puts each version in place by replacing reading_app.app. Replacing reading_app.get_book would change nothing, because the route keeps the function it was given when the @app.get line ran. A test that calls fresh_client() looks up reading_app.app when it runs, so it meets whichever version is in place. A client built once at the top of the file, such as client = TestClient(reading_app.app), keeps the original app, and so does from reading_app import app.

One warning

Run the tests in the Shell tab:

python -m pytest -q

The summary line ends with 1 warning, and the warnings summary above it has one entry whose last line ends like this:

DeprecationWarning: The anyio.abc.BlockingPortal alias is deprecated, use anyio.from_thread.BlockingPortal instead.

It is from anyio, the library that Starlette, the toolkit FastAPI is built on, uses to run the app’s async code. The notice is about a name Starlette uses inside. It comes from importing the test client, and it does not change a result.

Your task

Replace Lesson 2’s two placeholders in tests/test_app.py, each building its client with fresh_client():

1. test_unknown_book_is_404: GET /books/99 answers 404. The sample state has books 1 and 2 only.

2. test_choices_fastapi_makes: HEAD /books answers 405, and GET /books/abc answers 422.

Assert statuses; you may also check allow or your detail. If you want one test to try several requests, pytest.mark.parametrize from Python in Practice is one tidy form, and plain asserts in one function work as well.

Run python -m pytest -q again. It ends 2 failed, 3 passed, 1 warning: the two failures are Lesson 5’s placeholders, assert False, "not written yet", which wait for Lesson 5, and Check my work leaves them out. Then press Check my work. Lesson 3 gives the request body to the model.