├── src
    ├── app
    │   ├── __init__.py
    │   ├── api
    │   │   ├── __init__.py
    │   │   ├── ping.py
    │   │   ├── models.py
    │   │   ├── crud.py
    │   │   └── notes.py
    │   ├── main.py
    │   └── db.py
    ├── tests
    │   ├── __init__.py
    │   ├── test_ping.py
    │   ├── conftest.py
    │   └── test_notes.py
    ├── requirements.txt
    └── Dockerfile
├── .gitignore
├── README.md
├── docker-compose.yml
└── LICENSE


/src/app/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/app/api/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/src/tests/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__
2 | env


--------------------------------------------------------------------------------
/src/requirements.txt:
--------------------------------------------------------------------------------
1 | psycopg2-binary==2.9.5
2 | SQLAlchemy==1.4.41
3 | fastapi==0.87.0
4 | uvicorn==0.20.0
5 | 
6 | # dev
7 | pytest==7.2.0
8 | httpx==0.23.1


--------------------------------------------------------------------------------
/src/app/api/ping.py:
--------------------------------------------------------------------------------
1 | from fastapi import APIRouter
2 | 
3 | router = APIRouter()
4 | 
5 | 
6 | @router.get("/ping")
7 | def pong():
8 |     return {"ping": "pong!"}
9 | 


--------------------------------------------------------------------------------
/src/tests/test_ping.py:
--------------------------------------------------------------------------------
1 | def test_ping(test_app):
2 |     response = test_app.get("/ping")
3 |     assert response.status_code == 200
4 |     assert response.json() == {"ping": "pong!"}
5 | 


--------------------------------------------------------------------------------
/src/tests/conftest.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | from starlette.testclient import TestClient
 3 | 
 4 | from app.main import app
 5 | 
 6 | 
 7 | @pytest.fixture(scope="module")
 8 | def test_app():
 9 |     client = TestClient(app)
10 |     yield client  # testing happens here
11 | 


--------------------------------------------------------------------------------
/src/app/main.py:
--------------------------------------------------------------------------------
 1 | from fastapi import FastAPI
 2 | 
 3 | from app.api import ping, notes
 4 | from app.api.models import Base
 5 | from app.db import engine
 6 | 
 7 | 
 8 | Base.metadata.create_all(bind=engine)
 9 | 
10 | app = FastAPI()
11 | 
12 | 
13 | app.include_router(ping.router)
14 | app.include_router(notes.router, prefix="/notes", tags=["notes"])
15 | 


--------------------------------------------------------------------------------
/src/app/db.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | 
 3 | from sqlalchemy import create_engine
 4 | from sqlalchemy.ext.declarative import declarative_base
 5 | from sqlalchemy.orm import sessionmaker
 6 | 
 7 | 
 8 | DATABASE_URL = os.getenv("DATABASE_URL")
 9 | 
10 | engine = create_engine(DATABASE_URL)
11 | 
12 | SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
13 | 
14 | Base = declarative_base()
15 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Developing and Testing an API with FastAPI and Pytest
 2 | 
 3 | Synchronous Example
 4 | 
 5 | ## Want to use this project?
 6 | 
 7 | Build the images and run the containers:
 8 | 
 9 | ```sh
10 | $ docker-compose up -d --build
11 | ```
12 | 
13 | Test out the following routes:
14 | 
15 | 1. [http://localhost:8003/ping](http://localhost:8003/ping)
16 | 1. [http://localhost:8003/docs](http://localhost:8003/docs)
17 | 1. [http://localhost:8003/notes](http://localhost:8003/notes)
18 | 


--------------------------------------------------------------------------------
/src/Dockerfile:
--------------------------------------------------------------------------------
 1 | # pull official base image
 2 | FROM python:3.11.0-alpine
 3 | 
 4 | # set work directory
 5 | WORKDIR /usr/src/app
 6 | 
 7 | # set environment variables
 8 | ENV PYTHONDONTWRITEBYTECODE 1
 9 | ENV PYTHONUNBUFFERED 1
10 | 
11 | # copy requirements file
12 | COPY ./requirements.txt /usr/src/app/requirements.txt
13 | 
14 | # install dependencies
15 | RUN set -eux \
16 |     && apk add --no-cache --virtual .build-deps build-base \
17 |          openssl-dev libffi-dev gcc musl-dev python3-dev \
18 |         postgresql-dev bash \
19 |     && pip install --upgrade pip setuptools wheel \
20 |     && pip install -r /usr/src/app/requirements.txt \
21 |     && rm -rf /root/.cache/pip
22 | 
23 | # copy project
24 | COPY . /usr/src/app/
25 | 


--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: '3.8'
 2 | 
 3 | services:
 4 |   web:
 5 |     build: ./src
 6 |     command: |
 7 |       bash -c 'while !</dev/tcp/db/5432; do sleep 1; done; uvicorn app.main:app --reload --workers 1 --host 0.0.0.0 --port 8000'
 8 |     volumes:
 9 |       - ./src/:/usr/src/app/
10 |     ports:
11 |       - 8003:8000
12 |     environment:
13 |       - DATABASE_URL=postgresql://hello_fastapi:hello_fastapi@db/hello_fastapi_dev
14 |   db:
15 |     image: postgres:15.1-alpine
16 |     volumes:
17 |       - postgres_data:/var/lib/postgresql/data/
18 |     expose:
19 |       - 5432
20 |     environment:
21 |       - POSTGRES_USER=hello_fastapi
22 |       - POSTGRES_PASSWORD=hello_fastapi
23 |       - POSTGRES_DB=hello_fastapi_dev
24 | 
25 | volumes:
26 |   postgres_data:
27 | 


--------------------------------------------------------------------------------
/src/app/api/models.py:
--------------------------------------------------------------------------------
 1 | from pydantic import BaseModel, Field
 2 | from sqlalchemy import Column, Integer, String, DateTime
 3 | from sqlalchemy.sql import func
 4 | 
 5 | from app.db import Base
 6 | 
 7 | 
 8 | # SQLAlchemy Model
 9 | 
10 | 
11 | class Note(Base):
12 | 
13 |     __tablename__ = "notes"
14 | 
15 |     id = Column(Integer, primary_key=True)
16 |     title = Column(String(50))
17 |     description = Column(String(50))
18 |     created_date = Column(DateTime, default=func.now(), nullable=False)
19 | 
20 |     def __init__(self, title, description):
21 |         self.title = title
22 |         self.description = description
23 | 
24 | 
25 | # Pydantic Model
26 | 
27 | 
28 | class NoteSchema(BaseModel):
29 |     title: str = Field(..., min_length=3, max_length=50)
30 |     description: str = Field(..., min_length=3, max_length=50)
31 | 
32 | 
33 | class NoteDB(NoteSchema):
34 |     id: int
35 | 
36 |     class Config:
37 |         orm_mode = True
38 | 


--------------------------------------------------------------------------------
/src/app/api/crud.py:
--------------------------------------------------------------------------------
 1 | from sqlalchemy.orm import Session
 2 | 
 3 | from app.api.models import Note, NoteSchema
 4 | 
 5 | 
 6 | def post(db_session: Session, payload: NoteSchema):
 7 |     note = Note(title=payload.title, description=payload.description)
 8 |     db_session.add(note)
 9 |     db_session.commit()
10 |     db_session.refresh(note)
11 |     return note
12 | 
13 | 
14 | def get(db_session: Session, id: int):
15 |     return db_session.query(Note).filter(Note.id == id).first()
16 | 
17 | 
18 | def get_all(db_session: Session):
19 |     return db_session.query(Note).all()
20 | 
21 | 
22 | def put(db_session: Session, note: Note, title: str, description: str):
23 |     note.title = title
24 |     note.description = description
25 |     db_session.commit()
26 |     return note
27 | 
28 | 
29 | def delete(db_session: Session, id: int):
30 |     note = db_session.query(Note).filter(Note.id == id).first()
31 |     db_session.delete(note)
32 |     db_session.commit()
33 |     return note
34 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Michael Herman
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/app/api/notes.py:
--------------------------------------------------------------------------------
 1 | from typing import List
 2 | 
 3 | from fastapi import APIRouter, Depends, HTTPException, Path
 4 | from sqlalchemy.orm import Session
 5 | 
 6 | from app.api import crud
 7 | from app.api.models import NoteDB, NoteSchema
 8 | from app.db import SessionLocal
 9 | 
10 | 
11 | router = APIRouter()
12 | 
13 | 
14 | def get_db():
15 |     try:
16 |         db = SessionLocal()
17 |         yield db
18 |     finally:
19 |         db.close()
20 | 
21 | 
22 | @router.post("/", response_model=NoteDB, status_code=201)
23 | def create_note(*, db: Session = Depends(get_db), payload: NoteSchema):
24 |     note = crud.post(db_session=db, payload=payload)
25 |     return note
26 | 
27 | 
28 | @router.get("/{id}/", response_model=NoteDB)
29 | def read_note(
30 |     *, db: Session = Depends(get_db), id: int = Path(..., gt=0),
31 | ):
32 |     note = crud.get(db_session=db, id=id)
33 |     if not note:
34 |         raise HTTPException(status_code=404, detail="Note not found")
35 |     return note
36 | 
37 | 
38 | @router.get("/", response_model=List[NoteDB])
39 | def read_all_notes(db: Session = Depends(get_db)):
40 |     return crud.get_all(db_session=db)
41 | 
42 | 
43 | @router.put("/{id}/", response_model=NoteDB)
44 | def update_note(
45 |     *, db: Session = Depends(get_db), id: int = Path(..., gt=0), payload: NoteSchema
46 | ):
47 |     note = crud.get(db_session=db, id=id)
48 |     if not note:
49 |         raise HTTPException(status_code=404, detail="Note not found")
50 |     note = crud.put(
51 |         db_session=db, note=note, title=payload.title, description=payload.description
52 |     )
53 |     return note
54 | 
55 | 
56 | @router.delete("/{id}/", response_model=NoteDB)
57 | def delete_note(
58 |     *, db: Session = Depends(get_db), id: int = Path(..., gt=0),
59 | ):
60 |     note = crud.get(db_session=db, id=id)
61 |     if not note:
62 |         raise HTTPException(status_code=404, detail="Note not found")
63 |     note = crud.delete(db_session=db, id=id)
64 |     return note
65 | 


--------------------------------------------------------------------------------
/src/tests/test_notes.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | 
  3 | import pytest
  4 | 
  5 | from app.api import crud
  6 | 
  7 | 
  8 | def test_create_note(test_app, monkeypatch):
  9 |     test_data = {"title": "something", "description": "something else", "id": 1}
 10 | 
 11 |     def mock_post(db_session, payload):
 12 |         return test_data
 13 | 
 14 |     monkeypatch.setattr(crud, "post", mock_post)
 15 | 
 16 |     response = test_app.post("/notes/", content=json.dumps(test_data),)
 17 |     assert response.status_code == 201
 18 |     assert response.json() == test_data
 19 | 
 20 | 
 21 | def test_create_note_invalid_json(test_app):
 22 |     response = test_app.post("/notes/", content=json.dumps({"title": "something"}))
 23 |     assert response.status_code == 422
 24 | 
 25 |     response = test_app.post(
 26 |         "/notes/", content=json.dumps({"title": "1", "description": "2"})
 27 |     )
 28 |     assert response.status_code == 422
 29 | 
 30 | 
 31 | def test_read_note(test_app, monkeypatch):
 32 |     test_data = {"title": "something", "description": "something else", "id": 1}
 33 | 
 34 |     def mock_get(db_session, id):
 35 |         return test_data
 36 | 
 37 |     monkeypatch.setattr(crud, "get", mock_get)
 38 | 
 39 |     response = test_app.get("/notes/1")
 40 |     assert response.status_code == 200
 41 |     assert response.json() == test_data
 42 | 
 43 | 
 44 | def test_read_note_incorrect_id(test_app, monkeypatch):
 45 |     def mock_get(db_session, id):
 46 |         return None
 47 | 
 48 |     monkeypatch.setattr(crud, "get", mock_get)
 49 | 
 50 |     response = test_app.get("/notes/999")
 51 |     assert response.status_code == 404
 52 |     assert response.json()["detail"] == "Note not found"
 53 | 
 54 |     response = test_app.get("/notes/0")
 55 |     assert response.status_code == 422
 56 | 
 57 | 
 58 | def test_read_all_notes(test_app, monkeypatch):
 59 |     test_data = [
 60 |         {"title": "something", "description": "something else", "id": 1},
 61 |         {"title": "someone", "description": "someone else", "id": 2},
 62 |     ]
 63 | 
 64 |     def mock_get_all(db_session):
 65 |         return test_data
 66 | 
 67 |     monkeypatch.setattr(crud, "get_all", mock_get_all)
 68 | 
 69 |     response = test_app.get("/notes/")
 70 |     assert response.status_code == 200
 71 |     assert response.json() == test_data
 72 | 
 73 | 
 74 | def test_update_note(test_app, monkeypatch):
 75 |     test_data = {"title": "something", "description": "something else", "id": 1}
 76 |     test_update_data = {"title": "someone", "description": "someone else", "id": 1}
 77 | 
 78 |     def mock_get(db_session, id):
 79 |         return test_data
 80 | 
 81 |     monkeypatch.setattr(crud, "get", mock_get)
 82 | 
 83 |     def mock_put(db_session, note, title, description):
 84 |         return test_update_data
 85 | 
 86 |     monkeypatch.setattr(crud, "put", mock_put)
 87 | 
 88 |     response = test_app.put("/notes/1/", content=json.dumps(test_update_data),)
 89 |     assert response.status_code == 200
 90 |     assert response.json() == test_update_data
 91 | 
 92 | 
 93 | @pytest.mark.parametrize(
 94 |     "id, payload, status_code",
 95 |     [
 96 |         [1, {}, 422],
 97 |         [1, {"description": "bar"}, 422],
 98 |         [999, {"title": "foo", "description": "bar"}, 404],
 99 |         [1, {"title": "1", "description": "bar"}, 422],
100 |         [1, {"title": "foo", "description": "1"}, 422],
101 |         [0, {"title": "foo", "description": "bar"}, 422],
102 |     ],
103 | )
104 | def test_update_note_invalid(test_app, monkeypatch, id, payload, status_code):
105 |     def mock_get(db_session, id):
106 |         return None
107 | 
108 |     monkeypatch.setattr(crud, "get", mock_get)
109 | 
110 |     response = test_app.put(f"/notes/{id}/", content=json.dumps(payload),)
111 |     assert response.status_code == status_code
112 | 
113 | 
114 | def test_remove_note(test_app, monkeypatch):
115 |     test_data = {"title": "something", "description": "something else", "id": 1}
116 | 
117 |     def mock_get(db_session, id):
118 |         return test_data
119 | 
120 |     monkeypatch.setattr(crud, "get", mock_get)
121 | 
122 |     def mock_delete(db_session, id):
123 |         return test_data
124 | 
125 |     monkeypatch.setattr(crud, "delete", mock_delete)
126 | 
127 |     response = test_app.delete("/notes/1/")
128 |     assert response.status_code == 200
129 |     assert response.json() == test_data
130 | 
131 | 
132 | def test_remove_note_incorrect_id(test_app, monkeypatch):
133 |     def mock_get(db_session, id):
134 |         return None
135 | 
136 |     monkeypatch.setattr(crud, "get", mock_get)
137 | 
138 |     response = test_app.delete("/notes/999/")
139 |     assert response.status_code == 404
140 |     assert response.json()["detail"] == "Note not found"
141 | 
142 |     response = test_app.delete("/notes/0/")
143 |     assert response.status_code == 422
144 | 


--------------------------------------------------------------------------------