FastAPI Testing with pytest and TestClient

from fastapi import FastAPI, status
from fastapi.testclient import TestClient
import pytest

app = FastAPI()

@app.get("/forge/health", status_code=status.HTTP_200_OK)
async def health_check():
    return {"status": "operational", "version": "1.0.4"}

# Best practice: Initialize the client as a fixture
@pytest.fixture
def client():
    with TestClient(app) as c:
        yield c

def test_health_check(client):
    response = client.get("/forge/health")
    assert response.status_code == 200
    assert response.json() == {"status": "operational", "version": "1.0.4"}

def test_404_error(client):
    response = client.get("/forge/non-existent")
    assert response.status_code == 404

from fastapi.testclient import TestClient
from io.thecodeforge.main import app, get_db
import pytest

# 1. Create a Fake/Mock dependency
def override_get_db():
    try:
        # Imagine returning an in-memory SQLite session here
        yield "MockSessionObject"
    finally:
        pass

def test_user_creation():
    # 2. Inject the override before creating the client
    app.dependency_overrides[get_db] = override_get_db
    
    with TestClient(app) as client:
        response = client.post(
            "/forge/users", 
            json={"username": "test_user", "email": "test@thecodeforge.io"}
        )
        assert response.status_code == 201
        
    # 3. CRITICAL: Clean up to avoid affecting other tests
    app.dependency_overrides.clear()

from fastapi.testclient import TestClient
from io.thecodeforge.main import app, get_current_user
from io.thecodeforge.models import User
import pytest

@pytest.fixture
def client():
    with TestClient(app) as c:
        yield c

def test_admin_only_endpoint(client):
    # Override with an admin user
    app.dependency_overrides[get_current_user] = lambda: User(
        id=1, username="admin", role="admin"
    )
    
    response = client.get("/forge/admin/dashboard")
    assert response.status_code == 200

def test_regular_user_gets_forbidden(client):
    # Override with a regular user
    app.dependency_overrides[get_current_user] = lambda: User(
        id=2, username="user", role="user"
    )
    
    response = client.get("/forge/admin/dashboard")
    assert response.status_code == 403
    
    
# Cleanup in conftest.py is assumed

from fastapi.testclient import TestClient
from io.thecodeforge.main import app
from io.thecodeforge.database import Base, SessionLocal, engine, get_db
from io.thecodeforge.models import User
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

@pytest.fixture
def db_session():
    # Use in-memory SQLite for tests
    test_engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(bind=test_engine)
    TestSession = sessionmaker(bind=test_engine, autoflush=False)
    session = TestSession()
    try:
        yield session
    finally:
        session.close()
        Base.metadata.drop_all(bind=test_engine)

@pytest.fixture
def client(db_session):
    def override_get_db():
        try:
            yield db_session
        finally:
            pass
    app.dependency_overrides[get_db] = override_get_db
    with TestClient(app) as c:
        yield c
    app.dependency_overrides.clear()

def test_create_user(client):
    response = client.post(
        "/forge/users",
        json={"username": "alice", "email": "alice@test.io"}
    )
    assert response.status_code == 201
    data = response.json()
    assert data["username"] == "alice"

def test_duplicate_user(client):
    # First create
    client.post("/forge/users", json={"username": "alice", "email": "a@test.io"})
    # Duplicate should fail
    response = client.post("/forge/users", json={"username": "alice", "email": "another@test.io"})
    assert response.status_code == 409

from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import JSONResponse
from fastapi.testclient import TestClient
import pytest

app = FastAPI()

class NotFoundError(Exception):
    pass

@app.exception_handler(NotFoundError)
async def not_found_handler(request: Request, exc: NotFoundError):
    return JSONResponse(
        status_code=404,
        content={"error": "not_found", "detail": str(exc)}
    )

@app.get("/forge/items/{item_id}")
async def get_item(item_id: int):
    if item_id <= 0:
        raise NotFoundError(f"Item {item_id} not found")
    return {"id": item_id, "name": "widget"}

def test_custom_exception_handler():
    with TestClient(app) as client:
        response = client.get("/forge/items/-1")
        assert response.status_code == 404
        assert response.json() == {
            "error": "not_found",
            "detail": "Item -1 not found"
        }

def test_unhandled_exception_fallback():
    # Simulate an unexpected error
    @app.get("/crash")
    async def crash():
        raise RuntimeError("Unexpected!")
    
    with TestClient(app) as client:
        response = client.get("/crash")
        # In production, FastAPI returns 500 with generic message by default
        assert response.status_code == 500
        # Ensure no stack trace leakage
        assert "traceback" not in response.text.lower()