LLM-code testen · oefening
Gebruik de meegeleverde nep-client
Les 1 noemde vier soorten controles. Voor de eerste twee moet je code een antwoord krijgen zonder de modeldienst: een antwoord dat jij koos, zodat de test weet wat het juiste resultaat is, en een dat direct aankomt, elke keer, zonder netwerk. Daar is fakes.py voor.
De nep-client
De controles die je werk sinds hoofdstuk 5 nakeken, riepen llm-api nooit aan. Ze gaven je functies een FakeClient in plaats van de echte client, en fakes.py in je project is precies dat bestand. Je code ziet het verschil niet, want die roept alleen client.chat.completions.create(...) aan en leest attributen van wat er terugkomt.
Je gebruikt fakes.py; je hoeft niet te lezen hoe het gebouwd is. Dit is de interface:
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.
Een antwoord heeft alleen de attributen die de code van de cursus leest: choices[0].message.content, choices[0].message.tool_calls, choices[0].finish_reason en usage. Code die iets anders probeert te gebruiken, zoals response.id, faalt met een AttributeError in plaats van per ongeluk te slagen.
Als je code het model vaker aanroept dan de lijst antwoorden heeft, geeft de extra aanroep een gewone AssertionError die hem noemt: Your code called the model 2 times, but this check expected 1 call(s). Een test die één aanroep verwachtte, faalt dan, en dat is wat je wilt.
Een eerste test
ask(question, *, client) uit hoofdstuk 5, in client_calls.py, stuurt één vraag en geeft de tekst van het antwoord terug, of "" als het antwoord geen tekst heeft. Hier is een test ervan, in de vorm arrange, act, assert (voorbereiden, uitvoeren, controleren) uit Python in de praktijk:
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: een nep-client met één gescript antwoord.
Act: roep er
askmee aan, precies zoals het programma hem met de echte client zou aanroepen.Assert: controleer wat
askteruggaf, en controleer het request dat hij verstuurde, dat de nep-client vastlegde inclient.requests[0].
De verwachte tekst kun je veilig in de test schrijven, want de test schreef het antwoord. Dit is geen test van het model, dat nooit draaide; het is een test van wat ask met een antwoord doet. Hij raakt llm-api nooit aan, dus hij draait in een paar milliseconden en slaagt op dezelfde manier, of de dienst nu draait of niet.
De afbeelding volgt dezelfde test van boven naar beneden. De tekst in het gescripte antwoord komt uit ask terug en belandt in de assertion: de test schreef hem in de nep-client, dus hij kan hem verwachten, en niets onderweg bereikt llm-api.
![Een test van ask met een nep-client: de test script één antwoord, roept ask aan, krijgt de tekst van dat antwoord terug en controleert die en het request dat de nep-client vastlegde in client.requests[0].](/media/pythonland/assets/b48a5acb1cced5e4-960.webp)
Nu jij
Open tests/test_fake_client.py. Schrijf onder de imports tests die vier dingen over ask controleren:
Hij geeft de tekst van het antwoord terug.
Hij geeft
""terug als de content van het antwoordNoneis. Scriptfakes.reply(None).Het request dat hij verstuurt, heeft
modelgelijk aanMODEL, en demessageszijn precies[{"role": "user", "content": question}], met jouw vraag, en verder niets: geen systeembericht.Twee aanroepen op één nep-client met twee gescripte antwoorden krijgen de twee teksten op volgorde terug, en
client.requestsbevat daarna twee requests.
Geef elke test een naam die zegt wat hij controleert, beginnend met test_. Eén assertion per gedrag is genoeg; meerdere assertions in één test mag ook.
Voer je tests uit
python evals.py voert je tests niet uit. Voer ze uit in de Shell, vanuit de projectmap:
python -m pytest -q tests/test_fake_client.py
Met vier tests die slagen, drukt pytest één punt per test af en een samenvatting. De tijd aan het eind verschilt:
.... [100%]
4 passed in 0.23s
python -m pytest -q zonder bestand voert elke test in de map tests uit. Les 3 tot en met 5 voegen daar bestanden aan toe, dus dat commando groeit mee met het hoofdstuk.
Bouw in een test nooit de echte client. make_client() maakt verbinding met de dienst, en een test die het netwerk nodig heeft, is traag, faalt als de dienst niet draait en kost geld bij een live model. Wanneer je tests worden gecontroleerd, geeft make_client() de fout AssertionError: Tests must not call llm-api: pass a FakeClient., en elk ander request mislukt.
Hoe je tests worden gecontroleerd
Bij het controleren van je werk wordt tests/test_fake_client.py met pytest uitgevoerd, in een alleen-lezen kopie van het project met eigen kopieën van elk cursusbestand. Je tests moeten slagen, twee keer, tegen de correcte ask. Daarna draaien ze tegen drie kapotte versies van ask, een voor een, en moeten ze op elke versie falen:
askgeeftNoneterug voor een antwoord waarvan de contentNoneis;askstuurt een systeembericht vóór de vraag;askstuurt als model"pl-live"in plaats vanMODEL.
Een test vangt een kapotte versie alleen als hij ask aanroept en daarna faalt. Als er een doorheen glipt, noemt de feedback die versie, zodat je weet welke test je moet toevoegen.
Een test van een echt model kan het exacte antwoord niet asserten. Waarom mag test_ask_returns_the_reply_text dan asserten dat ask precies "A list keeps items in order." teruggeeft?
Eén kapotte ask stuurt een systeembericht vóór de vraag. Welke assertion vangt dat?
Opdracht
Schrijf in tests/test_fake_client.py tests voor ask uit client_calls.py die fakes.FakeClient gebruiken en controleren dat:
askde tekst van het antwoord teruggeeft;ask""teruggeeft als de content van het antwoordNoneis (scriptfakes.reply(None));de
modelvan het requestMODELis en demessagesprecies[{"role": "user", "content": question}]zijn;twee aanroepen op een nep-client met twee antwoorden de twee teksten op volgorde teruggeven, en
client.requeststwee requests bevat.
Voer ze uit met python -m pytest -q tests/test_fake_client.py in de ask en falen op kapotte versies.