0%

LLM-Code testen · Übung

Eigenschaften testen, nicht Formulierungen

Jeder Test bisher hat eine Antwort geskriptet und ein Ergebnis geprüft. Das ist die richtige Form für „Was macht ask mit None?“, aber es bleibt eine Lücke. Die Antwort, die du geskriptet hast, ist eine von unzähligen Antworten, die ein Live-Modell senden könnte, und die nächste wird anders formuliert sein. Diese Lektion dreht die Frage um: Statt „Was hat diese Antwort ergeben?“ fragst du „Was muss gelten, egal wie die Antwort lautete?“

Eine Eigenschaft

Eine Eigenschaft (property) ist etwas, das jedes akzeptable Ergebnis hat, unabhängig von seiner Formulierung. Zwei, die der Lernassistent verspricht:

  • answer_from_notes gibt nie eine Quellenangabe zurück, die es nicht bekommen hat. Es darf antworten oder die Antwort mit einem ValueError ablehnen, aber eine Antwort, die es zurückgibt, zitiert nur Labels der Passagen, die es gesendet hat.

  • run_agent bleibt innerhalb seiner Grenzen. Sein Trace hat nie mehr Schritte als max_steps, und das verbrauchte Budget entspricht den Tokens, die sein Trace festhält.

Ein Eigenschaftstest prüft so einen Satz über viele Eingaben. Der Decorator @pytest.mark.parametrize aus Python in der Praxis übernimmt die Wiederholung: Er führt eine Testfunktion einmal pro Zeile einer Tabelle aus und meldet jede Zeile als eigenen Test.

Das ist nicht das „Property-based Testing“ von Bibliotheken, die sich zufällige Eingaben für dich ausdenken. Hier wählst du die Eingaben, eine Tabelle von Antworten, darunter auch unangenehme, und die Zusicherung ist die Eigenschaft.

Quellenangaben stammen aus den Passagen

Die Passagen für die Kopierfrage sind das, was best_chunks(question, note_chunks(load_notes()), 3) zurückgibt, und ihre Labels kommen von chunk_label aus Kapitel 8. Der Test baut diese Liste von Labels und gibt answer_from_notes dann jede Antwort aus einer Tabelle:

@pytest.mark.parametrize(
    "reply_text",
    [
        '{"answer": "Use scores.copy().", "citations": ["03-lists#4"]}',
        '{"answer": "Use scores.copy().", "citations": ["03-lists#4", "99-nothing#1"]}',
        '{"answer": "Use scores.copy().", "citations": []}',
        "Use scores.copy().",
    ],
)
def test_an_answer_cites_only_passages_it_was_given(reply_text):
    ...

Die Zeilen sind eine gültige Antwort, eine, die eine nie gesendete Passage zitiert, eine ohne Quellenangaben und eine, die überhaupt kein JSON ist. Für jede ruft der Test answer_from_notes mit einem Fake auf, der diese Antwort enthält, und prüft dann, dass jede Quellenangabe der Antwort eines der Labels ist.

Eine Antwort abzulehnen ist auch akzeptabel. Bei der zweiten und der vierten Zeile löst answer_from_notes einen ValueError aus: die eigene Meldung aus Kapitel 8 für das unbekannte Label und Pydantics ValidationError für den Text, der kein JSON ist, und der ist eine Art von ValueError (Kapitel 4). Deshalb steht der Aufruf in try, und bei except ValueError: macht der Test return, womit diese Zeile als bestanden endet. Die Eigenschaft lautet nicht „die Antwort wird akzeptiert“, sondern „nichts ohne Quelle kommt durch“.

Die Grenzen halten bei jedem Schrittlimit

Die zweite Eigenschaft treibt run_agent mit einem Modell an, das nie aufhört zu fragen. Schreibe vier Tool-Aufruf-Antworten aus, jede fordert eine andere Notiz an, damit sich kein Aufruf wiederholt und die Schleife keinen Grund hat, als "stuck" anzuhalten:

FOUR_CALLS = [
    fakes.tool_call_reply([("c1", "read_note", '{"note_id": "n1"}')]),
    fakes.tool_call_reply([("c2", "read_note", '{"note_id": "n2"}')]),
    fakes.tool_call_reply([("c3", "read_note", '{"note_id": "n3"}')]),
    fakes.tool_call_reply([("c4", "read_note", '{"note_id": "n4"}')]),
]

Parametrisiere dann über eine Tabelle mit drei Zeilen, jede mit einem max_steps-Wert und den Antworten:

@pytest.mark.parametrize(("max_steps", "replies"), [(1, FOUR_CALLS), (2, FOUR_CALLS), (3, FOUR_CALLS)])
def test_the_agent_stays_within_its_limits(max_steps, replies):
    ...

Bei zwei Namen ist das erste Argument von parametrize ein Tupel von Namen, und jede Zeile ist ein Tupel von Werten. Führe in jeder Zeile den Agenten mit einem FakeClient(replies) aus, deinem eigenen read_note-Tool wie in Lektion 3, einem frischen Budget und sleep=waits.append, und prüfe dann zwei Dinge: len(result["trace"]) <= max_steps und dass budget["used"] der Summe der tokens aller Schritte im Trace entspricht, aufaddiert mit einer Schleife.

Eine Schleife, die max_steps ignoriert, würde nach einer fünften Antwort fragen, und der Fake würde den Test mit Your code called the model 5 times scheitern lassen. Eine Schleife, die manche Tokens doppelt zählt, hätte ein Budget, das nicht zu ihrem Trace passt.

Jetzt du

Schreibe in tests/test_properties.py beide Tests: die Quelleneigenschaft über die vier Antworten und die Grenzeigenschaft über max_steps 1, 2 und 3. Führe sie dann aus:

python -m pytest -q tests/test_properties.py
.......                                                                  [100%]
7 passed in 0.23s

Zwei Testfunktionen, sieben Tests: pytest zählt jede Zeile als einen.

Wie deine Tests geprüft werden

tests/test_properties.py läuft gegen den korrekten Code und drei kaputte Funktionen und muss bei jeder fehlschlagen:

  • answer_from_notes überspringt die Quellenprüfung und validiert die Antwort nur als CitedAnswer;

  • run_agent ignoriert max_steps;

  • call_model addiert die Usage jeder Antwort zweimal zum Budget.

Keiner dieser Fehler würde in einem Test mit einer einzelnen gültigen Antwort auffallen. Jeder verletzt eine Eigenschaft.

Im Test der Quelleneigenschaft löst answer_from_notes für die Antwort, die kein JSON ist, einen ValueError aus, und der Test macht return. Warum zählt diese Zeile als bestanden?

Der Grenztest skriptet vier Tool-Aufruf-Antworten, jede fordert eine andere Notiz an. Warum verschiedene Notizen?

Aufgabe

Schreibe in tests/test_properties.py zwei parametrisierte Tests:

  1. Über vier Antworttexte für die Kopierfrage (einer gültig, einer zitiert 03-lists#4 und 99-nothing#1, einer ohne Quellenangaben, einer, der kein JSON ist): Baue mit chunk_label die Labels von best_chunks(question, note_chunks(load_notes()), 3), rufe answer_from_notes mit einem Fake auf, der die Antwort enthält, und prüfe, dass jede Quellenangabe eines dieser Labels ist. Innerhalb von try lässt ein ValueError den Test return ausführen.

  2. Über drei Zeilen, max_steps 1, 2 und 3, jede mit denselben vier ausgeschriebenen Tool-Aufruf-Antworten (n1 bis n4): Führe run_agent mit deinem eigenen read_note-Tool und einem frischen Budget aus und prüfe len(result["trace"]) <= max_steps sowie dass budget["used"] der Summe der tokens im Trace entspricht.

Führe python -m pytest -q tests/test_properties.py aus und prüfe dann deine Arbeit.