Hoofdstuk 10
LLM-code testen
Waarom je het exacte antwoord niet kunt asserten
De studieassistent kan antwoorden vanuit de notities, een agent draaien, een quiz maken en chatten, en sinds hoofdstuk 9 faalt elke aanroep op een nette manier. Hoe weet je dat hij blijft werken als je hem verandert? In Python in de praktijk schreef je tests: roep een functie aan, vergelijk het resultaat met de waarde die je verwachtte en laat pytest je vertellen wanneer die twee verschillen. Dat werkt voor trim_history. Voor een antwoord dat een model schreef, werkt het niet op dezelfde manier.
Je project voor dit hoofdstuk
Open evals.py in de projecteditor. Het is het startbestand van dit hoofdstuk: in de Shell voert python evals.py de demonstratie uit. Je bouwt vier van de functies erin: save_response in les 4, en retrieval_hit, citation_hit en run_eval in les 6. De rest is afgeronde code die de demonstratie gebruikt.
Het meeste wat je in dit hoofdstuk schrijft, zijn tests. Ze komen in de map tests, één bestand per les: test_fake_client.py, test_agent.py, test_recorded.py, test_properties.py en, voor het project, test_study_assistant.py. Elk bestand begint met een docstring en de imports die de les nodig heeft, nog zonder tests. tests/recordings bevat twee opgeslagen antwoorden van een live model, die je hieronder tegenkomt.
reliable.py is nu het afgeronde bestand van hoofdstuk 9, en de bestanden die het importeert staan er net als eerder naast. Je tests importeren ze en controleren ze. Je hoeft geen van die bestanden te veranderen. De controle van je werk gebruikt eigen kopieën, dus een wijziging daarin kan geen beoordeling veranderen, maar wel de demonstratie of je tests laten vastlopen.
Er zijn nog twee nieuwe bestanden. fakes.py is de nep-client (fake client) die je werk sinds hoofdstuk 5 controleert; les 2 laat zien hoe je hem gebruikt. requirements-dev.txt noemt wat een ontwikkelaar van dit project nodig heeft: alles in requirements.txt, plus pytest==9.1.1, dezelfde splitsing als in Python in de praktijk. De sandbox heeft pytest al.
Eén vraag, twee live antwoorden
Voer nu in de Shell python evals.py uit. De demonstratie begint met show_variability(), die de twee opnames leest en afdrukt. Die roept geen model aan. Beide zijn antwoorden van het model van pl-live, openai/gpt-oss-20b, opgenomen op 2026-11-08, op dezelfde vraag zonder bijgevoegde notities. Het zijn de twee andere voorbeelden die hoofdstuk 8 noemde, deze keer volledig getoond.
Two live answers to: What example list does the Python Land lists note use, and what values are in it?
--- live-lists-note.json (openai/gpt-oss-20b, recorded on 2026-11-08)
In the “Lists” section on the Python Language reference (the “Python Land” page for the list type), the example that is repeatedly referenced is the list
```python
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```
The note states that this list contains nine integer values, numbered consecutively from 1 to 9.
--- live-lists-note-2.json (openai/gpt-oss-20b, recorded on 2026-11-08)
In the “lists” chapter of the *Python Land* notes, the canonical example that is used whenever a list is introduced is the list
```python
['spam', 'ham', 'eggs']
```
That list contains three string elements:
| Index | Value |
|------|-------|
| 0 | `'spam'` |
| 1 | `'ham'` |
| 2 | `'eggs'` |
The chapter uses this list repeatedly to illustrate list creation, indexing, mutating, slicing, and other list operations. No other values are in that example list – it’s just those three strings.
--- What notes/03-lists.md says:
A list is an ordered collection of values. You write one with square brackets, such as `scores = [90, 72, 85]`. A list can hold values of any type, including a mix of types and other lists.
Your tests do not run here. Run them in the terminal: python -m pytest -q
Recording the copy question's reply:
Run stopped at the next function to build: save_response is built in Lesson 4.
Lees de twee antwoorden naast de laatste alinea, die de notitie zelf is. Het eerste zegt dat de notitie over lijsten [1, 2, 3, 4, 5, 6, 7, 8, 9] gebruikt. Het tweede, een paar seconden later, zegt ['spam', 'ham', 'eggs'] en voegt een tabel toe. De lijst in de notitie is scores = [90, 72, 85]. Twee keer hetzelfde request gaf twee verschillende lijsten, en allebei fout.
Een live model kiest elk woord met enige willekeur, dus hetzelfde request kan anders verwoord terugkomen, langer of korter, of met andere feiten. Zonder de notities in het request had het model hier niets om op te bouwen en verzon het iets, elke keer iets anders. De onderbouwde antwoorden van hoofdstuk 8 zijn veel beter, maar ook die zijn bij elke run anders verwoord.
Waarom assert answer == expected faalt
Stel dat je deze test schreef:
def test_the_lists_answer():
answer = ask("What example list does the Python Land lists note use, and what values are in it?", client=make_client())
assert answer == "The note uses scores = [90, 72, 85]."
Tegen een live model faalt hij bij bijna elke run, zelfs op een dag dat het antwoord klopt, omdat de formulering verschilt. Tegen pl-scripted slaagt hij misschien elke keer, maar alleen omdat iemand precies die zin in de tabel van het gescripte model heeft gezet. Een geslaagde run bewijst dan dat de tabel die rij heeft. Het zegt niets over wat een live model zou antwoorden, of over de vraag of je code een antwoord aankan dat hij nog nooit heeft gezien. De test heeft ook nodig dat de dienst draait, en met een live model kost elke run geld.
Wat een test in plaats daarvan kan controleren
Een test van code die een model aanroept, controleert je programma, niet het model. Vier soorten controles houden stand:
Het request. Je code bepaalt de modelnaam, de berichten, de tools en het formaat. Een test kan precies controleren wat er werd verstuurd.
Wat je code met elk soort antwoord doet. Tekst, geen tekst, een toolaanroep, een afgekapt antwoord, een 429, een 500: een nep-client kan je code elk daarvan geven, in elke volgorde, zonder de dienst. Les 2 tot en met 4 doen dit, les 4 met een echt antwoord dat in een bestand is opgeslagen.
Eigenschappen die elk acceptabel antwoord deelt. Je kunt niet zeggen welke woorden een goed antwoord gebruikt, maar wel wat elk acceptabel resultaat heeft: het valideert als
CitedAnswer, het verwijst alleen naar passages die het kreeg, en de agent stopt binnen zijn stappenlimiet en zijn budget. Les 5 controleert zulke eigenschappen over veel antwoorden.Kwaliteit, als slagingspercentage. Of antwoorden goed zijn, is geen ja of nee over één antwoord. Les 6 bouwt een eval: een vaste set vragen, elk met wat een goed resultaat moet bevatten, gescoord als een aantal van de tien. Les 7 gebruikt die om twee systeemberichten te vergelijken.
De eerste drie draaien in een fractie van een seconde zonder netwerk en geven elke keer hetzelfde resultaat, dus ze horen in python -m pytest -q. De vierde roept het model aan en is een meting, geen geslaagd of mislukt.
Het plan voor dit hoofdstuk
Les 2 test ask met de meegeleverde nep-client, en les 3 test de hele agentlus door een toolaanroep en een antwoord te scripten. Les 4 slaat een echte response op in een bestand en speelt die af in een test. Les 5 schrijft tests die gelden voor elk acceptabel antwoord. Les 6 en 7 bouwen de eval en vergelijken er twee prompts mee. Het project, les 8, is een testsuite voor trim_history, search_notes en run_agent die elf manieren moet opmerken waarop de code stuk kan gaan.
Waarom faalt assert answer == "The note uses scores = [90, 72, 85]." tegen een live model, zelfs bij een run waarin het antwoord klopt?
Welke van deze controles geldt voor elk acceptabel antwoord dat answer_from_notes teruggeeft op de kopieervraag?
Een test stuurt de kopieervraag via make_client() naar pl-scripted en slaagt. Wat bewijst dat?