LLM-Code testen · Übung
Den mitgelieferten Fake-Client verwenden
Lektion 1 hat vier Arten von Prüfungen genannt. Die ersten beiden brauchen eine Antwort für deinen Code ohne den Modelldienst: eine Antwort, die du ausgewählt hast, damit der Test weiß, was das richtige Ergebnis ist, und eine, die sofort ankommt, jedes Mal, ohne Netzwerk. Dafür gibt es fakes.py.
Der Fake-Client
Die Prüfungen, die deine Arbeit seit Kapitel 5 kontrolliert haben, haben nie llm-api aufgerufen. Sie haben deinen Funktionen statt des echten Clients einen FakeClient übergeben, und fakes.py in deinem Projekt ist genau diese Datei. Dein Code merkt den Unterschied nicht, weil er immer nur client.chat.completions.create(...) aufruft und Attribute dessen liest, was zurückkommt.
Du verwendest fakes.py; wie es gebaut ist, musst du nicht lesen. Das ist seine Schnittstelle:
fakes.FakeClient(replies)
A client. Each call to client.chat.completions.create(...) returns the next
item of replies, in order, one per call. If the item is an error, that
call raises it.
client.requests
A list with one dictionary per call so far: "method" ("create"), then
every argument the call passed, such as "model", "messages" and "tools".
fakes.reply(content, *, finish_reason="stop", usage=(10, 5))
A text reply. content may be None. usage is (prompt_tokens,
completion_tokens), so this reply's total_tokens is 15.
fakes.tool_call_reply(calls, *, usage=(10, 5))
A reply that asks for tools. calls is a list of (id, name, arguments_text)
tuples, such as ("call_1", "read_note", '{"note_id": "03-lists"}').
fakes.stream(pieces)
A streamed reply, for code that passes stream=True.
fakes.from_recorded(path)
A reply rebuilt from a saved response. Lesson 4 uses it.
fakes.rate_limit_error(retry_after=1), fakes.server_error(status=500),
fakes.connection_error(), fakes.timeout_error(), fakes.bad_request_error()
Real openai errors. Put one in replies, and the call that takes it raises it.
Eine Antwort hat nur die Attribute, die der Code des Kurses liest: choices[0].message.content, choices[0].message.tool_calls, choices[0].finish_reason und usage. Code, der auf etwas anderes zugreift, etwa response.id, scheitert mit einem AttributeError, statt zufällig zu bestehen.
Ruft dein Code das Modell öfter auf, als die Liste Antworten hat, löst der zusätzliche Aufruf einen einfachen AssertionError aus, der ihn benennt: Your code called the model 2 times, but this check expected 1 call(s). Ein Test, der einen Aufruf erwartet hat, schlägt dann fehl, und genau das willst du.
Ein erster Test
ask(question, *, client) aus Kapitel 5 in client_calls.py sendet eine Frage und gibt den Text der Antwort zurück, oder "", wenn die Antwort keinen Text hat. Hier ist ein Test dafür, im Aufbau Arrange, Act, Assert aus Python in der Praxis:
import fakes
from client_calls import MODEL, ask
def test_ask_returns_the_reply_text():
client = fakes.FakeClient([fakes.reply("A list keeps items in order.")])
assert ask("What is a list?", client=client) == "A list keeps items in order."
assert client.requests[0]["model"] == MODEL
Arrange: ein Fake-Client mit einer geskripteten Antwort.
Act:
askdamit aufrufen, genau so, wie das Programm es mit dem echten Client aufrufen würde.Assert: prüfen, was
askzurückgegeben hat, und die gesendete Anfrage prüfen, die der Fake inclient.requests[0]aufgezeichnet hat.
Den erwarteten Text kannst du gefahrlos in den Test schreiben, weil der Test die Antwort geschrieben hat. Das ist kein Test des Modells, das nie gelaufen ist; es ist ein Test dessen, was ask mit einer Antwort macht. Er berührt llm-api nie, deshalb läuft er in ein paar Millisekunden und besteht gleich, ob der Dienst läuft oder nicht.
Das Bild verfolgt denselben Test von oben nach unten. Der Text in der geskripteten Antwort kommt aus ask wieder heraus und landet in der Zusicherung: Der Test hat ihn in den Fake geschrieben, also kann er ihn erwarten, und nichts auf dem Weg erreicht llm-api.
![Ein Test von ask mit einem Fake-Client: Der Test skriptet eine Antwort, ruft ask auf, bekommt den Text dieser Antwort zurück und prüft ihn sowie die Anfrage, die der Fake in client.requests[0] aufgezeichnet hat.](/media/pythonland/assets/b48a5acb1cced5e4-960.webp)
Jetzt du
Öffne tests/test_fake_client.py. Schreibe unter den Imports Tests, die vier Dinge an ask prüfen:
Es gibt den Text der Antwort zurück.
Es gibt
""zurück, wenn der Inhalt der AntwortNoneist. Skriptefakes.reply(None).Die gesendete Anfrage hat
modelgleichMODEL, und ihremessagessind genau[{"role": "user", "content": question}], mit deiner Frage und sonst nichts: keine Systemnachricht.Zwei Aufrufe auf einem Fake mit zwei geskripteten Antworten bekommen die beiden Texte in der richtigen Reihenfolge zurück, und
client.requestsenthält danach zwei Anfragen.
Gib jedem Test einen Namen, der sagt, was er prüft, beginnend mit test_. Eine Zusicherung pro Verhalten reicht; mehrere Zusicherungen in einem Test sind auch in Ordnung.
Deine Tests ausführen
python evals.py führt deine Tests nicht aus. Führe sie in der Shell aus dem Projektordner aus:
python -m pytest -q tests/test_fake_client.py
Bei vier bestandenen Tests gibt pytest einen Punkt pro Test und eine Zusammenfassung aus. Die Zeit am Ende variiert:
.... [100%]
4 passed in 0.23s
python -m pytest -q ohne Datei führt jeden Test im Ordner tests aus. Die Lektionen 3 bis 5 fügen dort Dateien hinzu, sodass dieser Befehl mit dem Kapitel wächst.
Baue in einem Test nie den echten Client. make_client() greift auf den Dienst zu, und ein Test, der das Netzwerk braucht, ist langsam, schlägt fehl, wenn der Dienst nicht läuft, und kostet bei einem Live-Modell Geld. Wenn deine Tests geprüft werden, löst make_client() AssertionError: Tests must not call llm-api: pass a FakeClient. aus, und jede andere Anfrage schlägt fehl.
Wie deine Tests geprüft werden
Die Prüfung deiner Arbeit führt tests/test_fake_client.py mit pytest aus, in einer schreibgeschützten Kopie des Projekts, die eigene Kopien aller Kursdateien enthält. Deine Tests müssen bestehen, zweimal, gegen das korrekte ask. Danach laufen sie gegen drei kaputte Versionen von ask, eine nach der anderen, und müssen bei jeder fehlschlagen:
askgibtNonezurück, wenn der Inhalt einer AntwortNoneist;asksendet eine Systemnachricht vor der Frage;asksendet das Modell"pl-live"stattMODEL.
Ein Test erwischt eine kaputte Version nur, wenn er ask aufruft und dann fehlschlägt. Kommt eine durch, nennt die Rückmeldung sie, damit du weißt, welchen Test du ergänzen musst.
Ein Test eines echten Modells kann dessen exakte Antwort nicht prüfen. Warum darf test_ask_returns_the_reply_text prüfen, dass ask genau "A list keeps items in order." zurückgibt?
Eine kaputte Version von ask sendet eine Systemnachricht vor der Frage. Welche Zusicherung erwischt sie?
Aufgabe
Schreibe in tests/test_fake_client.py Tests für ask aus client_calls.py, die fakes.FakeClient verwenden und prüfen, dass:
askden Text der Antwort zurückgibt;ask""zurückgibt, wenn der Inhalt der AntwortNoneist (skriptefakes.reply(None));das
modelder AnfrageMODEList und ihremessagesgenau[{"role": "user", "content": question}]sind;zwei Aufrufe auf einem Fake mit zwei Antworten die beiden Texte in der richtigen Reihenfolge zurückgeben und
client.requestszwei Anfragen enthält.
Führe sie mit python -m pytest -q tests/test_fake_client.py im ask bestehen und bei kaputten Versionen fehlschlagen.