We’ll start by learning FastAPI’s key features and core use cases. Then we will run our first application and test it out! Finally, we will learn the details of supporting GET and POST operations that include request parameters and build and test those endpoints.

Why FastAPI?

First application

FastAPI vs. Django

GET operations

Hello world

Hello who?

POST operations

Pydantic model

POST operation in action

FastAPI Basics

We’ll start by learning how to support PUT and DELETE operations using FastAPI. Then we will learn how to handle different kinds of errors and always return an appropriate status code in the response. Lastly we'll learn how to use async to enable concurrent requests that can handle higher workloads.

PUT and DELETE operations

PUT operation in action

DELETE operation in action

Handling errors

Status code classification

Handling a client error

Using async for concurrent work

When should we use async?

Asynchronous DELETE operation

FastAPI Advanced topics

We'll start by learning how to write system tests to validate individual FastAPI endpoints. Next we'll build a full JSON CRUD API to manage object lifecycles over HTTP. Finally, we'll learn how to test different application endpoints working together with manual functional tests.

FastAPI automated testing

Options

Unit Tests

System Tests

Unit tests vs. system tests

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {"scissors": Item(name="scissors", quantity=100)}


@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]

# Import TestClient
from fastapi.testclient import ____
from main import app

# Create test client with application context
client = TestClient(____)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": ____}

# Import TestClient
from fastapi.testclient import TestClient
from main import app

# Create test client with application context
client = TestClient(app)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": 100}

System test

Building a JSON CRUD API

Create

Read

Update

HTTP operations & CRUD steps

DELETE operation response

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.____("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.____("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    return items[name]  
  
@app.____("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.post("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]  
  
@app.put("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

Complete JSON CRUD API

Writing a manual functional test

Functional Tests

System tests vs. functional tests

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == ____
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?____=____")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == ____

# Delete item "rock"
r = requests.delete(ENDPOINT, json={____: ____})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == ____

print("Test complete.")

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 100

# Delete item "rock"
r = requests.delete(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 404

print("Test complete.")

Functional test

Wrap up

Building and testing a JSON CRUD API

This course teaches you to build production-grade web applications using FastAPI, a popular Python framework for creating APIs. You'll learn to handle all four HTTP operations, define request and response schemas, validate API requests, and return appropriate HTTP status codes. You'll also cover asynchronous code execution to boost performance, and by the end, you’ll develop a CRUD API and test workflows with Python's requests module. Tailored for experienced Python programmers, this course equips you with the skills to manage data with FastAPI, preparing you to build robust data management and ML model-serving pipelines.

<h2>Introduction to FastAPI and Its Applications</h2> APIs are commonly used to manage data on the web, and FastAPI is a popular new web framework for building APIs with Python. Data and Machine Learning Engineers leverage FastAPI to build applications that serve as context-aware data transactions and pipelines on the web.<br><br> <h2>Building Production-Grade Web Applications with FastAPI</h2> In this course, you will learn how to build production-grade web applications leveraging your Python skills with the FastAPI framework. By the end, you’ll understand core use cases for FastAPI in relation to other Python web frameworks. You’ll learn to build APIs using all four types of HTTP operations and define request and response schemas. In addition, you’ll validate API requests, respond with appropriate HTTP status codes and messages, and execute code asynchronously to improve application performance. A hands-on project will guide you through building a classical CRUD (Create, Read, Update, Delete) API, testing workflows using Python's requests module.<br><br> <h2>Course Goals and Target Audience</h2> This course is designed for experienced Python programmers who want to build web applications that manage data using FastAPI. Upon completing this course, you will have the foundation necessary to create FastAPI projects suited for high-throughput data management and ML model-serving pipelines.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Build robust, production-grade APIs with FastAPI, mastering HTTP operations, validation, and async execution to create efficient data and ML pipelines.


Unit tests vs. system tests

Introduction to FastAPI

Ejercicio interactivo práctico