Python Code Testing

 Let's look at how to test our Python code and follow the code coverage as much as possible.


  1. How to follow the MVC pattern in FastAPI

  2. How to write Pythonic code

  3. Types of testing with pytest

  4. Usage of patching, monkeypatching, fixture, and mocking

🚀 How to Follow the MVC Pattern in FastAPI

FastAPI doesn’t enforce a strict MVC structure, but you can follow an organized MVC-like structure:

🔹 MVC Directory Structure Example

app/
│
├── models/           # ORM models (e.g., SQLAlchemy)
│   └── user.py
│
├── schemas/          # Pydantic schemas (DTOs)
│   └── user.py
│
├── controllers/      # Business logic (aka services)
│   └── user_controller.py
│
├── routes/           # Route definitions
│   └── user_routes.py
│
├── main.py           # Entry point
└── database.py       # DB engine/session

🔹 MVC Mapping

  • Model → app/models/

  • View → app/routes/ (FastAPI endpoints)

  • Controller → app/controllers/ (business logic)

🐍 How to Write Pythonic Code

Follow these tips for clean, maintainable code:

✅ Do's

  • Use list comprehensions: squares = [x**2 for x in range(10)]

  • Use unpacking: a, b = b, a

  • Use f-strings: f"Hello, {name}!"

  • Follow PEP8: spacing, naming conventions

  • Write modular code using functions and classes

❌ Don'ts

  • Avoid deeply nested code

  • Avoid hardcoded values (use config files or env vars)

  • Avoid long functions (>40 lines ideally)

🧪 Code Coverage & Testing with pytest

🔹 Types of Tests

  • Unit Tests: Test isolated functions/methods

  • Integration Tests: Test multiple modules working together

  • Functional Tests: Test end-to-end use cases

  • Regression Tests: Ensure new code doesn't break existing functionality

🔹 Measuring Code Coverage

pip install pytest pytest-cov
pytest --cov=app tests/

🧰 Testing Utilities in pytest

1. Fixtures

  • Provide pre-loaded data or setup

import pytest

@pytest.fixture
def user_data():
    return {"username": "test", "email": "test@test.com"}

2. Mocking

  • Replace parts of the system to isolate the test

from unittest.mock import Mock

mock_service = Mock()
mock_service.get_user.return_value = {"name": "Mocked"}

3. Patching

  • Temporarily replace object/function for the test

from unittest.mock import patch

@patch("app.controllers.user_controller.get_user")
def test_get_user(mock_get_user):
    mock_get_user.return_value = {"name": "Patched"}

4. Monkeypatching

  • Provided by pytest to change attributes during test

def test_env(monkeypatch):
    monkeypatch.setenv("API_KEY", "test123")

📌 Summary

  • Use a clean MVC layout in FastAPI

  • Write Pythonic code using idioms and best practices

  • Use pytest with fixtures, mocking, patching, and monkeypatching for robust test coverage

  • Measure test coverage with pytest-cov


Here’s how you can quickly start with pytest, pytest-cov, mocking, and code coverage for your FastAPI MVC app:

🚀 Quick Setup Commands

# Step 1: Install required packages
pip install pytest pytest-cov pytest-mock

# Step 2: Run all tests
pytest

# Step 3: Run tests with coverage
pytest --cov=app --cov-report=term-missing

# Optional: For HTML coverage report
pytest --cov=app --cov-report=html

🔗 Official Docs for Reference

Some code example to understand in better way

🧭 FastAPI MVC Pattern and Testing Guide with pytest, Mocking, and Integration Tests (No Real DB)

📁 Folder Structure (MVC + Testing)

project/
├── app/
│   ├── controllers/
│   │   └── user_controller.py
│   ├── models/
│   │   └── user.py
│   ├── schemas/
│   │   └── user.py
│   ├── routes/
│   │   └── user_routes.py
│   ├── database.py
│   └── main.py
├── tests/
│   ├── controllers/
│   │   └── test_user_controller.py
│   ├── routes/
│   │   └── test_user_routes.py
│   ├── conftest.py
│   └── integration/
│       └── test_app.py

1️⃣ app/schemas/user.py

from pydantic import BaseModel

class UserCreate(BaseModel):
    name: str
    email: str

class UserOut(BaseModel):
    id: int
    name: str
    email: str

2️⃣ app/models/user.py

from pydantic import BaseModel

# Simulating a DB model with static data
class User(BaseModel):
    id: int
    name: str
    email: str

    @staticmethod
    def get_users():
        return [
            User(id=1, name="Alice", email="alice@test.com"),
            User(id=2, name="Bob", email="bob@test.com")
        ]

3️⃣ app/controllers/user_controller.py

from app.models.user import User

def list_users():
    return User.get_users()

4️⃣ app/routes/user_routes.py

from fastapi import APIRouter
from app.controllers.user_controller import list_users
from app.schemas.user import UserOut
from typing import List

router = APIRouter()

@router.get("/users", response_model=List[UserOut])
def get_users():
    return list_users()

5️⃣ app/main.py

from fastapi import FastAPI
from app.routes import user_routes

app = FastAPI()
app.include_router(user_routes.router)

✅ Unit Testing with pytest

📌 tests/controllers/test_user_controller.py

from app.controllers.user_controller import list_users

def test_list_users():
    users = list_users()
    assert len(users) == 2
    assert users[0].name == "Alice"

📌 tests/routes/test_user_routes.py

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

client = TestClient(app)

def test_get_users():
    response = client.get("/users")
    assert response.status_code == 200
    assert response.json()[0]["name"] == "Alice"

🧪 Mocking and Patching (without DB)

📌 Patch the Controller Function

from unittest.mock import patch
from fastapi.testclient import TestClient
from app.main import app

client = TestClient(app)

@patch("app.controllers.user_controller.list_users")
def test_get_users_mocked(mock_list_users):
    mock_list_users.return_value = [{"id": 1, "name": "Mock", "email": "mock@test.com"}]
    response = client.get("/users")
    assert response.status_code == 200
    assert response.json()[0]["name"] == "Mock"

🧪 Monkeypatching with pytest

📌 tests/controllers/test_user_controller.py

def fake_get_users():
    return [{"id": 99, "name": "Fake", "email": "fake@test.com"}]

def test_monkeypatch_user(monkeypatch):
    from app.models import user
    monkeypatch.setattr(user.User, "get_users", fake_get_users)
    from app.controllers.user_controller import list_users
    result = list_users()
    assert result[0]["name"] == "Fake"

🔌 Fixtures in pytest (shared test data)

📌 tests/conftest.py

import pytest

@pytest.fixture
def test_user():
    return {"id": 1, "name": "Test", "email": "test@test.com"}

📌 Use the Fixture

def test_with_fixture(test_user):
    assert test_user["email"] == "test@test.com"

🔁 Integration Test (without Real DB)

📌 tests/integration/test_app.py

from fastapi.testclient import TestClient
from unittest.mock import patch
from app.main import app

client = TestClient(app)

def fake_users():
    return [{"id": 101, "name": "IntTest", "email": "int@test.com"}]

@patch("app.controllers.user_controller.list_users", side_effect=fake_users)
def test_full_integration(mock_list_users):
    response = client.get("/users")
    assert response.status_code == 200
    assert response.json()[0]["name"] == "IntTest"

📊 Measure Code Coverage

pytest --cov=app tests/

✅ Summary Checklist

  • Follow MVC: models, schemas, controllers, routes

  • Use pytest for unit tests

  • Use mock, patch, monkeypatch to avoid real DB calls

  • Create integration tests using TestClient

  • Measure coverage with pytest-cov


Comments

Post a Comment

Popular posts from this blog

Self-contained Raspberry Pi surveillance System Without Continue Internet

Image
                                                                gemini generated A  self-contained Raspberry Pi surveillance system that: Runs autonomously (like EyeOS) — camera always active and streaming. Keeps searching for a known Wi-Fi hotspot (your phone) . Starts streaming automatically when the phone hotspot is available. Lets you view the camera feed on your phone (via browser or app). Here’s a detailed, production-ready setup: ⚙️ Step 1: Setup Raspberry Pi Camera & Software 1. Enable the camera sudo raspi-config Go to Interface Options → Camera → Enable Reboot: sudo reboot 2. Install dependencies sudo apt update sudo apt install python3-picamera2 python3-flask git -y 📸 Step 2: Create a Local Flask Streaming App Create file /home/pi/camera_stream.py : from flask import Flas...
Read more

COBOT with GenAI and Federated Learning

Image
                                                                                 generated by meta ai The integration of Generative AI (GenAI) and Large Language Models (LLMs) is poised to significantly enhance the intelligence and capabilities of cobots, taking them beyond basic automation. Here's how: 1. Enhanced Natural Language Interaction: Intuitive Communication: LLMs enable cobots to understand and respond to natural language commands, making human-robot interaction far more intuitive. Instead of complex programming, workers can simply use voice commands or text instructions. This simplifies task assignment and allows for real-time adjustments. Contextual Understanding: LLMs provide cobots with a deeper understanding of context, allowi...
Read more

AI in Education: Embracing Change for Future-Ready Learning

Image
  Executive Summary An adjunct professor advocates embracing AI in classrooms over prohibition, using historical examples of replaced skills (cursive, memorization) to argue for focusing on adaptability, creativity, and critical thinking. AI enables personalized tutoring, equity, and efficiency but demands literacy and ethics. Recommendations include shifting to debates over essays and principles over rote tasks to equip students for AI workplaces. Historical Context: Skills Evolved by Technology Education prioritizes future utility amid time constraints. Past emphases have faded: Cursive/penmanship : Graded courses in prior generations; now obsolete with keyboards—digital fluency matters more. Memorization (e.g., full periodic table) : Drills wasted time; databases provide facts—focus on conceptual understanding (e.g., element groups' properties). Manual arithmetic : Long division drills unnecessary post-fundamentals; calculators standard in higher education. Map reading : Seconda...
Read more