Pybites Platform

Back

Fastapi exception handling

Pybites

Level: Intermediate (score: 3)

In this Bite we'll take the API we built in the last exercise and add some more exception handling to it.

We wrote a bunch of test scenarios that should return 4xx status codes (The 400 range is reseved for scenarios in which the server cannot or will not process the request due to something that is perceived to be a client error) and in this Bite you'll update the API to have those tests pass.

For simplicity’s sake:

- We only have you add error checking to the create (POST) food entry action / endpoint. The other endpoints are hidden in this Bite.

- We only have you use FastAPI's HTTPException with status code 400.

We already handled the food entry not found scenario when updating / deleting in previous Bites using status code 404.

Note that FastAPI also handles using the wrong HTTP verb / method (405) and incomplete (Pydantic) payload issues (422) for you, nice!

Here are the two use cases we want you to implement:

1. If you call POST with an existing entry.id it effectively overwrites the entry in the food_log dictionary.

In this case, return a 400 response warning the user they should use a PUT (update) request instead with this message: Food entry already logged, use an update request

2. For this exercise we added a max_daily_calories attribute to the User model.

If you try to add foods beyond this limit (aka "overeat") the API doesn't let you. Return a 400 with this message: Cannot add more food than daily caloric allowance = {user.max_daily_calories} kcal / day. For this scenario you can assume all foods are added / evaluated the same day to not overcomplicate things.

Maybe this second scenario should not be the API's responsability, but the point is that you as the developer can impose limits to your API. Another well known and real world scenario of this is rate limiting to keep your API from being used incorrectly or unrealisticaly.

Good luck and in the next Bite we'll render some logged foods in an HTML template.

FastAPI

Code
Tests

from datetime import datetime
from typing import Any, Dict

from fastapi import FastAPI
from passlib.context import CryptContext
from pydantic import BaseModel

# https://fastapi.tiangolo.com/tutorial/security/oauth2-jwt/
# We'll explore further in a later Bite
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

AVG_HUMAN_CALORIES_PER_DAY = 2250

def get_password_hash(password):
    return pwd_context.hash(password)

class Food(BaseModel):
    id: int
    name: str
    serving_size: str
    kcal_per_serving: int
    protein_grams: float
    fibre_grams: float = 0

class User(BaseModel):
    id: int
    username: str
    password: str
    max_daily_calories: int = AVG_HUMAN_CALORIES_PER_DAY

def __init__(self, **data: Any):
        data["password"] = get_password_hash(data["password"])
        super().__init__(**data)

class FoodEntry(BaseModel):
    id: int
    user: User
    food: Food
    date_added: datetime = datetime.now()
    number_servings: float

@property
    def total_calories(self):
        return self.food.kcal_per_serving * self.number_servings

app = FastAPI()
food_log: Dict[int, FoodEntry] = {}

# To focus on exception handling we only work on Create
# in this Bite hiding read-update-delete endpoints.

@app.post("/", status_code=201)
async def create_food_entry(entry: FoodEntry):

# TODO: add exception handling code here

food_log[entry.id] = entry
    return entry

import pytest
from fastapi.testclient import TestClient

from app import app, food_log, pwd_context

LAME_PASSWORD = "1234"  # noqa S105

# also from https://fastapi.tiangolo.com/tutorial/security/oauth2-jwt/
def _verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

@pytest.fixture
def client():
    client = TestClient(app)
    return client

@pytest.fixture
def user():
    user = dict(id=1, username="user", password=LAME_PASSWORD)
    return user

@pytest.fixture
def food():
    food = dict(
        id=1,
        name="egg",
        serving_size="piece",
        kcal_per_serving=78,
        protein_grams=6.2,
        fibre_grams=0,
    )
    return food

@pytest.fixture
def food_entry1(user, food):
    payload = dict(id=1, user=user, food=food, number_servings=1.5)
    yield payload
    del food_log[1]

@pytest.fixture
def food_entry2(user, food):
    payload = dict(id=2, user=user, food=food, number_servings=26.5)
    yield payload
    try:
        del food_log[2]
    except KeyError:
        pass

@pytest.fixture(autouse=True)
def create_food_entries(client, food_entry1):
    client.post("/", json=food_entry1)

def test_cannot_insert_same_food_entry_id_twice(client, food_entry1):
    resp = client.post("/", json=food_entry1)
    assert resp.status_code == 400
    error = "Food entry already logged, use an update request"
    expected = {"detail": error}
    assert resp.json() == expected

def test_cannot_overeat(client, food_entry1, food_entry2):
    # food entry 1 is posted in the autouse fixture = 1.5 eggs
    # posting food entry 2 would lead of a consumption of:
    # 28 (1.5 + 26.5) x 78 kcal == 2.184 which is still < 2.250 = ok
    resp = client.post("/", json=food_entry2)
    assert resp.status_code == 201
    # however posting one more egg on top of that we go over max
    # daily kcal allowance = 29 x 78 kcal = 2.262 > 2.250 -> not ok
    food_entry3 = food_entry1.copy()
    food_entry3["id"] = 3
    food_entry3["number_servings"] = 1
    resp = client.post("/", json=food_entry3)
    assert resp.status_code == 400
    error = ("Cannot add more food than daily caloric "
             "allowance = 2250 kcal / day")
    expected = {"detail": error}
    assert resp.json() == expected