Kurs Python · Moduł 12: Projekt końcowy

Strategia Testowania AI

5 min czytania ·
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 client

Dwie 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 results

Wynik 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. 1. Jaki typ testów powinien stanowić największą część piramidy testów?

  2. 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:

  1. PytaniePiramida testów
  2. PytaniePytest fixtures
  3. Ułóż w kolejnościTypy testów
  4. Zadanie z kodemUnit Test z pytest
  5. PytaniePytest run
  6. Kliknij w kolejnościPytest assert
  7. Ułóż w kolejnościDocker build
  8. Zadanie z kodemMock w pytest
  9. Ułóż w kolejnościPiramida testów AI

Przydatne artykuły