You can also truncate the tables after each test run. This clears all data in them without actually removing the schema so it’s not as slow as doing Base.metadata.drop_all(bind=engine):

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base
from contextlib import contextmanager

engine = create_engine('postgresql://...')
Session = sessionmaker(bind=engine)
Base = declarative_base()


@contextmanager
def session_scope():
    """Provide a transactional scope around a series of operations."""
    session = Session()
    try:
        yield session
        session.commit()
    except:
        session.rollback()
        raise
    finally:
        session.close()


def clear_tables():
    with session_scope() as conn:
        for table in Base.metadata.sorted_tables:
            conn.execute(
                f"TRUNCATE {table.name} RESTART IDENTITY CASCADE;"
            )
        conn.commit()


@pytest.fixture
def test_db_session():
    yield engine
    engine.dispose()
    clear_tables()


def test_some_feature(test_db_session):
    test_db_session.query(...)
    (...)

Here’s a solution for a full FastAPI test environment, including database setup and teardown. Despite the fact that there is already an accepted answer, I’d like to contribute my thoughts.

When configuring a test environment, you’ll want to include these fixtures in your conftest.py file. Fixtures defined within it will be automatically accessible to any of your tests contained within the test package.

a) First of all, do the imports.

Remember that your imports path may differ from mine, so double-check that as well.

import pytest
from fastapi.testclient import TestClient

# Import the SQLAlchemy parts
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
from app.main import app
from app.database import get_db,Base

# Create the new database session

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(SQLALCHEMY_DATABASE_URL)

TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Following that, we’ll use Pytest fixtures, which are functions that run before each test function to which they’re applied.

b). Session fixture

@pytest.fixture()
def session():

    Base.metadata.drop_all(bind=engine)
    Base.metadata.create_all(bind=engine)

    db = TestingSessionLocal()

    try:
        yield db
    finally:
        db.close()

The above session fixture ensures that every time a test is run, we connect to a testing database, create tables, and then delete the tables once the test is finished.

c) client fixture

@pytest.fixture()
def client(session):

    # Dependency override

    def override_get_db():
        try:

            yield session
        finally:
            session.close()

    app.dependency_overrides[get_db] = override_get_db

    yield TestClient(app)

The above fixture connects us to the new test database and overrides the initial database connection made by the main app. The session fixture is required for this client fixture to function.

After that, you can use the fixtures as shown without needing to import anything as shown below.

def test_index(client):
    res = client.get("/")
    assert res.status_code == 200

Your complete conftest.py file should now look like this:

import pytest
from fastapi.testclient import TestClient

# Import the SQLAlchemy parts
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
from app.main import app
from app.database import get_db, Base

# Create the new database session

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(SQLALCHEMY_DATABASE_URL)

TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)


@pytest.fixture()
def session():

    # Create the database

    Base.metadata.drop_all(bind=engine)
    Base.metadata.create_all(bind=engine)

    db = TestingSessionLocal()
    try:
        yield db
    finally:
        db.close()


@pytest.fixture()
def client(session):

    # Dependency override

    def override_get_db():
        try:
            yield session
        finally:
            session.close()

    app.dependency_overrides[get_db] = override_get_db

    yield TestClient(app)

Create a file in the tests folder named confest.py, in this file, we will keep the test database settings and make fixtures that will use in our test API. i m using postgres database.

from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from app.main import app
from app.db.database import Base, get_db
import pytest

TEST_DATABASE_URL = 'postgresql://postgres:admin@localhost:5432/yourdatabsename'
main_app = app    # this app comes from my main file, in which i declared FAST API as app

def start_application():   # start application
  return main_app

SQLALCHEMY_DATABASE_URL = TEST_DATABASE_URL
engine = create_engine(SQLALCHEMY_DATABASE_URL)  # create engine

SessionTesting = sessionmaker(autocommit=False, autoflush=False, bind=engine)  # now we create test-session 


@pytest.fixture(scope="function")
def app():
   """
   Create a fresh database on each test case.
   """
   Base.metadata.create_all(engine)  # Create the tables.
   _app = start_application()
   yield _app
   Base.metadata.drop_all(engine)    # drop that tables


@pytest.fixture(scope="function")
def db_session(app: FastAPI):
   connection = engine.connect()
   transaction = connection.begin()
   session = SessionTesting(bind=connection)
   yield session  # use the session in tests.
   session.close()
   transaction.rollback()
   connection.close()

@pytest.fixture(scope="function")
def client(app: FastAPI, db_session: SessionTesting):
   """
   Create a new FastAPI TestClient that uses the `db_session` fixture to override the `get_db` dependency that is injected into routes.
   """
   
   def _get_test_db():
      db_session = SessionTesting()
      try:
         yield db_session
      finally:
         db_session.close()  

   app.dependency_overrides[get_db] = _get_test_db
   with TestClient(app) as client:
     yield client      

Now this contest.py will use in every test file

For example

In my Organization Type Api, I create a file named test_organization_type in tests folder

from app.models.models import OrganizationType


def test_get_organization_type(client, db_session):
    response_post = client.post(URL will comes Here, json={'type_name': 'test_organization'})
    assert response_post.status_code == 201

    response_get = client.get(URL will come Here)  # get_request
    data = response_get.json()
    assert response_get.status_code == 200

Note: Your local database will be separate and the test database will be separate but in the test database, Objects will create on POST request and after the test it will be removed automatically.