Pourquoi devriez-vous utiliser une seule application FastAPI et une seule instance TestClient

Dans le développement FastAPI, en particulier pour les projets plus importants, l'utilisation d'une seule instance d'application FastAPI et d'une seule instance TestClient tout au long de votre projet est cruciale pour maintenir la cohérence, optimiser les performances et garantir la fiabilité. Examinons les raisons de cette bonne pratique et explorons des exemples pratiques.

1. Cohérence à l’échelle de l’application

La création de plusieurs instances d'application FastAPI peut introduire des incohérences. Chaque instance possède son propre état interne, sa propre configuration middleware et sa propre gestion des dépendances. Le partage de données avec état, telles que le stockage en mémoire ou les connexions à une base de données, entre plusieurs instances peut entraîner des comportements et des erreurs imprévisibles.

2. Performances améliorées

Chaque instance TestClient établit sa propre connexion HTTP et initialise les dépendances. L'utilisation d'un seul TestClient minimise les frais généraux, ce qui accélère l'exécution des tests.

3. Prévenir les problèmes d'initialisation

Les applications FastAPI initialisent souvent les ressources, y compris les connexions à la base de données ou les tâches en arrière-plan, lors du démarrage. Plusieurs instances peuvent provoquer des initialisations redondantes ou des conflits de ressources.

Exemple de code pratique

Approche correcte : application unique et TestClient

<code class="language-python">from fastapi import FastAPI, Depends
from fastapi.testclient import TestClient

# Single FastAPI app instance
app = FastAPI()

# Simple in-memory database
database = {"items": []}

# Dependency function
def get_database():
    return database

@app.post("/items/")
def create_item(item: str, db: dict = Depends(get_database)):
    db["items"].append(item)
    return {"message": f"Item '{item}' added."}

@app.get("/items/")
def list_items(db: dict = Depends(get_database)):
    return {"items": db["items"]}

# Single TestClient instance
client = TestClient(app)

# Test functions
def test_create_item():
    response = client.post("/items/", json={"item": "foo"})
    assert response.status_code == 200
    assert response.json() == {"message": "Item 'foo' added."}

def test_list_items():
    response = client.get("/items/")
    assert response.status_code == 200
    assert response.json() == {"items": ["foo"]}</code>

Approche incorrecte : instances multiples

<code class="language-python"># Incorrect: Multiple app instances
app1 = FastAPI()
app2 = FastAPI()

# Incorrect: Multiple TestClient instances
client1 = TestClient(app1)
client2 = TestClient(app2)

# Problem: State changes in client1 won't affect client2</code>

Problèmes courants avec plusieurs instances

1. État incohérent : L'état partagé (comme une base de données) se comporte indépendamment dans différentes instances d'application.
2. Initialisation des dépendances redondantes : Les dépendances telles que les connexions à la base de données peuvent être initialisées plusieurs fois, entraînant potentiellement un épuisement des ressources.
3. Événements de démarrage/arrêt qui se chevauchent : Plusieurs instances d'application déclenchent indépendamment des événements de démarrage et d'arrêt, provoquant un comportement inutile ou conflictuel.

Bonnes pratiques

Structure du projet pour la réutilisabilité

Créez votre application FastAPI dans un fichier séparé (par exemple, app.py) et importez-la si nécessaire.

<code class="language-python"># app.py
from fastapi import FastAPI

app = FastAPI()
# Add your routes here</code>

<code class="language-python"># main.py
from fastapi.testclient import TestClient
from app import app

client = TestClient(app)</code>

Exploiter les appareils pytest pour les instances partagées

Les appareils pytest gèrent efficacement les ressources partagées, telles que TestClient :

<code class="language-python">import pytest
from fastapi.testclient import TestClient
from app import app

@pytest.fixture(scope="module")
def test_client():
    client = TestClient(app)
    yield client  # Ensures proper cleanup</code>

<code class="language-python">def test_example(test_client):
    response = test_client.get("/items/")
    assert response.status_code == 200</code>

Documentation pertinente

• Starlette TestClient
• Test avec FastAPI
• Pytest des luminaires

En respectant ces directives, votre projet FastAPI sera plus cohérent, efficace et plus facile à maintenir.

---

Photo de Shawon Dutta : https://www.php.cn/link/e2d083a5fd066b082d93042169313e21

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!