Kurs Python · Moduł 12: Projekt końcowy
Strategia Testowania AI
W tej lekcji5
Ranger, który sprawdza tylko, czy land rover odpala na parkingu, nie wie jeszcze, czy przejedzie przez rzekę. Testowanie aplikacji AI ma ten sam problem w podwójnej dawce. Zwykły kod zachowuje się deterministycznie: ta sama funkcja z tym samym wejściem daje ten sam wynik. Model językowy potrafi odpowiedzieć na to samo pytanie na dwa różne sposoby. Dlatego musimy weryfikować nie tylko kod, ale także jakość odpowiedzi.
Piramida testów dla AI
Klasyczna piramida testów mówi: najwięcej szybkich testów jednostkowych u podstawy, mniej integracyjnych w środku, najmniej wolnych testów end-to-end na szczycie. W projekcie AI dokładamy warstwę ewaluacji odpowiedzi modelu. Proporcje poniżej to orientacyjny cel, a nie norma:
╱╲
╱ ╲
╱ E2E╲ ← 10% - Testy end-to-end
╱──────╲
╱ ╲
╱Integration╲ ← 20% - Testy integracyjne
╱────────────╲
╱ ╲
╱ AI Evaluation ╲ ← 30% - Ewaluacja AI
╱──────────────────╲
╱ ╲
╱ Unit ╲ ← 40% - Testy jednostkowe
╱────────────────────────╲Podstawa jest najszersza, bo testy jednostkowe są najszybsze i najtańsze. Ewaluacja AI leży nad nimi: jest wolniejsza i często kosztuje (każde pytanie to wywołanie modelu). Od najmniej do najbardziej kosztownych: unit, integration, E2E, a na końcu testy wydajnościowe pod obciążeniem.
Unit Tests
Testy jednostkowe piszemy w pytest. Fixture to funkcja oznaczona @pytest.fixture, która przygotowuje dane lub zasoby dla testu, a pytest wstrzykuje ją po nazwie parametru. Mock z unittest.mock tworzy atrapę obiektu, a spec= pilnuje, by atrapa miała tylko metody prawdziwej klasy.
import pytest
from unittest.mock import Mock, AsyncMock
class TestDocumentService:
@pytest.fixture
def mock_repo(self):
return Mock(spec=DocumentRepository)
@pytest.fixture
def mock_embedder(self):
embedder = Mock()
embedder.embed.return_value = [0.1] * 1536
return embedder
@pytest.fixture
def service(self, mock_repo, mock_embedder):
return DocumentService(mock_repo, mock_embedder)Fixture service sama korzysta z dwóch innych fixture, więc pytest buduje całe drzewo zależności za Ciebie. Embedder zwraca stały wektor 1536 liczb, bez żadnego wywołania API. Dalszy ciąg tej samej klasy to właściwe testy:
def test_chunk_document(self, service):
doc = Document(content="A" * 1000)
chunks = service.chunk_document(doc, chunk_size=200)
assert len(chunks) == 5
assert all(len(c.content) <= 200 for c in chunks)
@pytest.mark.asyncio
async def test_save_document(self, service, mock_repo):
doc = Document(title="Test", content="Content")
mock_repo.save = AsyncMock(return_value=doc)
result = await service.save(doc)
mock_repo.save.assert_called_once()
assert result.title == "Test"Test chunkowania sprawdza czystą logikę: 1000 znaków w kawałkach po 200 to 5 fragmentów. Test zapisu jest asynchroniczny, dlatego ma znacznik @pytest.mark.asyncio z wtyczki pytest-asyncio i używa AsyncMock, który zwraca wartość po await. Asercja to po prostu assert result == expected albo, jak tutaj, assert result.title == "Test". Do podmiany funkcji w module (na przykład wywołania zewnętrznego API) służy unittest.mock.patch, używane jako dekorator lub with patch("modul.funkcja") as fake:.
Integration Tests
Test integracyjny uruchamia kilka części razem. Testcontainers startuje prawdziwego Qdranta w kontenerze Dockera na czas testów, a httpx.AsyncClient wysyła żądania prosto do aplikacji ASGI, bez sieci.
import pytest
import pytest_asyncio
from httpx import ASGITransport, AsyncClient
from testcontainers.community.qdrant import QdrantContainer
@pytest.fixture(scope="module")
def qdrant_container():
with QdrantContainer() as qdrant:
yield qdrant
@pytest_asyncio.fixture
async def app_client(qdrant_container):
app = create_app(qdrant_url=f"http://{qdrant_container.rest_host_address}")
transport = ASGITransport(app=app)
async with AsyncClient(transport=transport, base_url="http://test") as client:
yield clientDwie rzeczy zmieniły się w bibliotekach i warto je znać. W httpx od wersji 0.28 nie ma już parametru app=, aplikację przekazujesz przez ASGITransport. W pytest-asyncio asynchroniczną fixture oznacza się @pytest_asyncio.fixture. Kontener Qdranta instalujesz jako testcontainers[qdrant], a starsze wersje importowały go z testcontainers.qdrant. Teraz sam test:
@pytest.mark.asyncio
async def test_upload_and_query(app_client):
# Upload document
response = await app_client.post(
"/documents",
json={"title": "Test", "content": "Python is great"}
)
assert response.status_code == 201
# Query
response = await app_client.post(
"/query",
json={"question": "What is Python?"}
)
assert response.status_code == 200
assert "Python" in response.json()["answer"]Test przechodzi przez cały przepływ: upload, potem zapytanie. Zauważ, że ostatnia asercja zależy od odpowiedzi modelu, więc może być niestabilna. Takie sprawdzenia lepiej przenieść do ewaluacji.
AI Evaluation
Ewaluacja mierzy jakość odpowiedzi na przygotowanym zbiorze pytań. Każdy przypadek zawiera pytanie i słowa kluczowe, których spodziewamy się w odpowiedzi:
from dataclasses import dataclass
@dataclass
class EvalCase:
question: str
expected_keywords: list[str]
context_required: bool = True
eval_dataset = [
EvalCase(
question="Co to jest RAG?",
expected_keywords=["retrieval", "generation", "augmented"],
context_required=True
),
EvalCase(
question="Jak działa embedding?",
expected_keywords=["wektor", "semantyczny", "reprezentacja"],
context_required=True
)
]Sam zbiór to zwykłe dane. Funkcja oceniająca liczy, jaki odsetek słów kluczowych pojawił się w odpowiedzi, i sprawdza, czy system podał źródła:
async def evaluate_rag_system(query_fn, dataset: list[EvalCase]) -> dict:
results = {"total": len(dataset), "passed": 0, "failed": []}
for case in dataset:
response = await query_fn(case.question)
# Check keywords
answer_lower = response.answer.lower()
keywords_found = sum(1 for k in case.expected_keywords if k in answer_lower)
keyword_score = keywords_found / len(case.expected_keywords)
# Check sources
has_sources = len(response.sources) > 0 if case.context_required else True
if keyword_score >= 0.5 and has_sources:
results["passed"] += 1
else:
results["failed"].append({
"question": case.question,
"keyword_score": keyword_score,
"has_sources": has_sources
})
results["accuracy"] = results["passed"] / results["total"]
return resultsWynik to accuracy plus lista porażek do przejrzenia. Słowa kluczowe to prosta, zgrubna metoda. Poważniejsze projekty oceniają też wierność odpowiedzi względem źródeł, ale zasada zostaje: stały zbiór pytań, powtarzalny pomiar.
CI/CD Pipeline
Testy mają sens, gdy uruchamiają się same przy każdym pushu. GitHub Actions odpala kolejne kroki na czystej maszynie, a Qdrant działa obok jako usługa:
# .github/workflows/test.yml
name: Test Suite
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
services:
qdrant:
image: qdrant/qdrant
ports:
- 6333:6333
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- name: Install dependencies
run: pip install -r requirements.txt
- name: Run unit tests
run: pytest tests/unit -v
- name: Run integration tests
run: pytest tests/integration -v
env:
QDRANT_URL: http://localhost:6333
- name: Run AI evaluation
run: python scripts/evaluate.py
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}Klucz API trafia z secrets, nigdy z repozytorium. Pokrycie kodu mierzy wtyczka pytest-cov: pytest --cov=app wypisze, które linie nie zostały przetestowane. Pojedynczy plik uruchomisz przez pytest tests/unit/test_service.py, a wiele pipeline'ów po testach buduje jeszcze obraz poleceniem docker build -t myapp:latest ., do którego wrócimy przy deploymencie. Moja rada: odpalaj ewaluację AI osobno od testów jednostkowych, bo jest wolniejsza i płatna. W następnej lekcji zajmiemy się dokumentacją.
Pamiętaj: testy to próbne przejazdy przez rzekę, zanim poprowadzisz nimi całą ekspedycję.
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Jaki typ testów powinien stanowić największą część piramidy testów?
2. Do czego służą fixtures w pytest?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj kroki:
- Edytor kodu
Zaimplementuj test z fixtures i mock
- Klikanie w kolejności
Kliknij w kolejności:
- Układanie w poziomie
Ułóż elementy:
- Edytor kodu
Użyj unittest.mock.patch do mockowania API call.
- Układanie w pionie
Posortuj typy testów od największej do najmniejszej liczby: