Fixture organization in FastAPI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a simple FastAPI fixture that provides a test client.

FastAPI

import pytest
from fastapi.testclient import TestClient
from myapp.main import app

@pytest.fixture
 def client():
    return [1](app)

Drag options to blanks, or click blank then click option'

ATestClient

BFastAPI

CClientSession

DHttpClient

Attempts:

3 left

💡 Hint

Common Mistakes

Using FastAPI class instead of TestClient

Using unrelated HTTP client classes

The TestClient is used to create a test client for FastAPI apps in fixtures.

2fill in blank

medium

Complete the fixture to yield a database session for tests.

FastAPI

import pytest
from myapp.database import SessionLocal

@pytest.fixture
 def db_session():
    db = [1]()
    try:
        yield db
    finally:
        db.close()

Drag options to blanks, or click blank then click option'

ASessionLocal

Bcreate_session

CDatabaseSession

Dget_db

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function name that does not create a session

Forgetting to close the session

SessionLocal is the factory that creates new database sessions for tests.

3fill in blank

hard

Fix the error in this fixture that overrides the dependency for the database session.

FastAPI

from fastapi.testclient import TestClient
from myapp.main import app
from myapp.database import SessionLocal
import pytest
from myapp.database import get_db

@pytest.fixture
 def client_override_db():
    def override_get_db():
        db = SessionLocal()
        try:
            yield db
        finally:
            db.close()

    app.dependency_overrides[[1]] = override_get_db
    with TestClient(app) as c:
        yield c
    app.dependency_overrides.clear()

Drag options to blanks, or click blank then click option'

Aoverride_get_db

BSessionLocal

Cget_db

Ddb_session

Attempts:

3 left

💡 Hint

Common Mistakes

Using the session class as the key

Using the override function as the key

The dependency_overrides dictionary keys must be the original dependency function, here get_db.

4fill in blank

hard

Fill both blanks to create a fixture that resets the database before each test.

FastAPI

import pytest
from myapp.database import Base, engine

@pytest.fixture(autouse=True)
 def reset_db():
    Base.metadata.[1](bind=engine)
    Base.metadata.[2](bind=engine)

Drag options to blanks, or click blank then click option'

Adrop_all

Bcreate_all

Cinitialize

Dreset

Attempts:

3 left

💡 Hint

Common Mistakes

Reversing the order of drop_all and create_all

Using non-existent methods like initialize or reset

First, drop_all removes all tables, then create_all recreates them for a clean state.

5fill in blank

hard

Fill all three blanks to define a fixture that provides an authenticated test client.

FastAPI

import pytest
from fastapi.testclient import TestClient
from myapp.main import app
from myapp.auth import create_access_token

@pytest.fixture
 def auth_client():
    token = create_access_token(data={"sub": [1])
    headers = {"Authorization": f"Bearer [2]"}
    client = TestClient(app)
    client.headers.update([3])
    return client

Drag options to blanks, or click blank then click option'

A"testuser"

Btoken

Cheaders

D"admin"

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong username string

Not updating client headers correctly

The token is created for user "testuser", then used in the Authorization header, which is added to the client headers.

Practice

1. What is the main purpose of using fixtures in FastAPI testing with pytest?

easy

A. To deploy the FastAPI app to production

B. To prepare resources and keep test code clean

C. To write the main application logic

D. To create database models

Solution

1. Step 1: Understand the role of fixtures

   Fixtures are used to prepare resources like database connections or test clients before tests run.

2. Step 2: Recognize their benefit in test code

   They help keep test code clean by avoiding repeated setup code in each test.

3. Final Answer:

   To prepare resources and keep test code clean -> Option B

4. Quick Check:

   Fixtures = prepare resources + clean tests [OK]

Hint: Fixtures set up test resources to avoid repeating code [OK]

Common Mistakes:

• Confusing fixtures with app logic
• Thinking fixtures deploy the app
• Using fixtures to define database models

2. Which of the following is the correct way to declare a fixture in pytest for FastAPI tests?

easy

A. class MyFixture: pass

B. def my_fixture(): return client

C. @app.get('/test')
def my_fixture(): return client

D. @pytest.fixture
def my_fixture(): yield client

Solution

1. Step 1: Identify pytest fixture syntax

   Fixtures require the decorator @pytest.fixture before the function.

2. Step 2: Recognize yield usage for setup/teardown

   Using yield allows setup before and teardown after the test.

3. Final Answer:

   @pytest.fixture\ndef my_fixture(): yield client -> Option D

4. Quick Check:

   Use @pytest.fixture and yield for fixtures [OK]

Hint: Use @pytest.fixture decorator and yield inside function [OK]

Common Mistakes:

• Missing @pytest.fixture decorator
• Using FastAPI route decorators instead
• Declaring fixture as a class without decorator

3. Given this conftest.py fixture code:

import pytest

@pytest.fixture
def client():
    from fastapi.testclient import TestClient
    from myapp.main import app
    with TestClient(app) as c:
        yield c

What will client.get('/items') return inside a test?

medium

A. A TestClient response object for the '/items' endpoint

B. A syntax error because yield is used incorrectly

C. An exception because app is not imported

D. None, because the fixture does not return anything

Solution

1. Step 1: Analyze the fixture setup

   The fixture creates a TestClient instance for the FastAPI app and yields it for use in tests.

2. Step 2: Understand what client.get('/items') does

   Calling client.get('/items') sends a test HTTP GET request to the '/items' route and returns a response object.

3. Final Answer:

   A TestClient response object for the '/items' endpoint -> Option A

4. Quick Check:

   Fixture yields TestClient, so client.get returns response [OK]

Hint: Fixture yields TestClient; get() returns response object [OK]

Common Mistakes:

• Thinking yield causes syntax error
• Assuming fixture returns None
• Forgetting to import app in fixture

4. Consider this fixture code in conftest.py:

import pytest

@pytest.fixture
def db():
    connection = connect_to_db()
    yield connection
    connection.close()

When running tests, you get an error: NameError: name 'connect_to_db' is not defined. How do you fix it?

medium

A. Import or define the function connect_to_db before using it

B. Remove yield and return connection instead

C. Change fixture to a class instead of a function

D. Rename the fixture to database()

Solution

1. Step 1: Identify cause of NameError

   The error means the function connect_to_db is not defined or imported in the file.

2. Step 2: Fix by importing or defining connect_to_db

   To fix, add the proper import statement or define the function before using it in the fixture.

3. Final Answer:

   Import or define the function connect_to_db before using it -> Option A

4. Quick Check:

   NameError means missing import or definition [OK]

Hint: NameError means missing import or definition [OK]

Common Mistakes:

• Removing yield does not fix NameError
• Changing fixture name won't fix missing function
• Converting to class does not solve missing import

5. You want to share a database fixture across multiple test files in FastAPI. Which is the best way to organize it?

hard

A. Put the fixture inside the main FastAPI app file

B. Copy the fixture code into every test file

C. Define the fixture in conftest.py at the root test folder

D. Define the fixture inside each test function

Solution

1. Step 1: Understand fixture sharing in pytest

   Fixtures defined in conftest.py are automatically discovered and shared across test files in the same folder or subfolders.

2. Step 2: Recognize why other options are poor

   Copying code duplicates it, defining inside test functions prevents reuse, and putting fixtures in app files mixes concerns.

3. Final Answer:

   Define the fixture in conftest.py at the root test folder -> Option C

4. Quick Check:

   conftest.py shares fixtures across tests [OK]

Hint: Use conftest.py to share fixtures across test files [OK]

Common Mistakes:

• Duplicating fixture code in every test file
• Defining fixtures inside test functions
• Mixing fixtures with app code