💻 computer science

MIRAGE: Online LLM Simulation for Microservice Dependency Testing

Dit paper introduceert MIRAGE, een online LLM-simulatiebenadering die microservice-afhankelijkheden tijdens runtime dynamisch simuleert op basis van broncode en traces, en hiermee aanzienlijk hogere nauwkeurigheid bereikt dan traditionele statische methoden zoals record-replay.

Oorspronkelijke auteurs: XinRan Zhang

Gepubliceerd 2026-04-08

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: XinRan Zhang

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een nieuw restaurant opent. Je wilt testen of je keuken perfect werkt, maar je hebt nog geen echte koks, geen verse groenten en geen gasten. Wat doe je dan?

In de softwarewereld is dit precies het probleem van microservices. Dit zijn kleine, losgekoppelde programmaatjes die samenwerken (zoals een bestelsysteem dat praat met een betaalsysteem en een verzendsysteem). Om te testen of alles werkt, moeten deze systemen vaak met elkaar praten. Maar vaak zijn de andere systemen nog niet klaar, te duur om op te zetten, of gewoon niet beschikbaar.

Tot nu toe losten ontwikkelaars dit op door "stilleven-simulaties" te maken. Ze namen een foto van hoe een systeem reageerde in het verleden en probeerden die foto later te herhalen. Het probleem? Als de situatie net anders is dan op de foto (een nieuwe klant, een andere prijs, een foutje), faalt de test. Het is alsof je probeert te koken met alleen een foto van een gerecht: je ziet eruit hoe het eruit moet zien, maar je weet niet hoe het smaakt of hoe je het moet bereiden.

MIRAGE is een nieuwe, slimme oplossing die dit probleem oplost. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De "Acteur" in plaats van de "Opname"

In plaats van een statische foto (een opname) te gebruiken, stelt MIRAGE een super-slimme acteur aan. Deze acteur is een Kunstmatige Intelligentie (een Large Language Model of LLM).

De oude manier (Record-Replay): Je neemt een video op van een acteur die een scène speelt. Als de regisseur vraagt: "Speel het nu met een andere stem," kijkt de acteur naar zijn video en zegt: "Dat kan niet, ik heb dat niet opgenomen."
De MIRAGE-methode (Online LLM): Je geeft de acteur het script, de achtergrondinformatie en de regels van de wereld. Als de regisseur vraagt: "Speel het nu met een andere stem," denkt de acteur na, past zijn stem aan en speelt de scène perfect, zelfs als die specifieke situatie nooit eerder is opgenomen.

2. Hoe MIRAGE het doet: De "Drie Ooggetuigen"

Om deze acteur zo slim mogelijk te maken, geeft MIRAGE hem drie soorten informatie:

Het Script (De Broncode): Als de acteur de code van het systeem ziet dat hij moet nabootsen, is hij een genie. Hij weet precies hoe het werkt.
De Dialogen (De Traces): Als hij de code niet heeft (bijvoorbeeld omdat het een systeem van een ander bedrijf is), kijkt hij naar eerdere gesprekken. Hij ziet: "Ah, als iemand een creditcard met 3 begint, wordt het afgekeurd."
De Context (De Caller): Hij kijkt ook naar wie er vraagt. "Oh, dit is de bestelmodule, die verwacht een bevestiging."

Het belangrijkste? De acteur onthoudt alles wat er eerder is gebeurd in de test. Als je in stap 1 een bestelling plaatst en in stap 2 vraagt om de status, weet de acteur nog steeds dat die bestelling bestaat. Oude methoden vergeten dit vaak.

3. De Resultaten: Een Droomtest

De onderzoekers hebben MIRAGE getest op 110 verschillende situaties in drie verschillende systemen (van Google, Weaveworks en een eigen systeem).

De oude methode (Record-Replay): Haalde slechts 62% van de juiste reacties. Het was alsof je probeerde te koken met een verouderde foto; het zag er goed uit, maar de smaak was verkeerd.
MIRAGE (met broncode): Haalde 99% perfectie. Het systeem reageerde bijna precies zoals het echte systeem zou doen, inclusief de juiste foutmeldingen en de juiste structuur van het antwoord.
MIRAGE (zonder broncode): Haalde nog steeds 94% aan de juiste foutcodes. Zelfs zonder het script te zien, kon de AI de logica van de gesprekken afleiden.

4. Waarom is dit belangrijk?

Stel je voor dat je een grote stad wilt bouwen. Je wilt testen of het verkeer werkt, maar je kunt niet wachten tot alle bruggen en wegen er echt zijn.

Vroeger: Je bouwde een model van de stad op papier. Als je een nieuwe route bedacht, paste het papier niet.
Nu met MIRAGE: Je hebt een virtuele stad die in real-time reageert. Je kunt elke route proberen, elke verkeersdrukte simuleren, en de AI past zich direct aan.

De kosten: Het kost een beetje geld (ongeveer 16 cent tot 82 cent per test) en duurt een paar seconden langer dan een simpele opname, maar het bespaart enorm veel tijd op het opzetten van echte servers en databases. Het is alsof je een dure, echte auto niet hoeft te huren om te testen of je rijdt, maar een perfecte virtuele simulator gebruikt die je direct in je garage hebt staan.

Conclusie

MIRAGE is als het geven van een levend brein aan je tests, in plaats van een dode pop. Het systeem denkt mee, onthoudt de geschiedenis en reageert op situaties die nog nooit eerder zijn voorgekomen. Voor ontwikkelaars betekent dit dat ze sneller, goedkoper en betrouwbaarder software kunnen bouwen, zonder te hoeven wachten tot alle onderdelen van het systeem klaar zijn.

Probleemstelling

Bij het integratietesten van microservices is het vaak noodzakelijk om downstream-afhankelijkheden te simuleren wanneer deze niet beschikbaar zijn of te duur om te provisioneren. Bestaande benaderingen voor afhankelijkheidssimulatie (zoals record-replay, patroon-mining en specificatie-gedreven stubs) genereren statische artefacten vóór de uitvoering van tests.

De fundamentele beperking van deze methoden is dat het gegenereerde artefact alle relevante gedragingen moet bevatten op het moment van generatie. Scenario's die niet waren voorzien tijdens het bouwen van het artefact (zoals ongeziene request-parameters, foutcondities of cross-request state-afhankelijkheden) leiden tot onjuiste of ontbrekende antwoorden. In de evaluatie van de auteurs presteerden traditionele record-replay-tools slechts met 62% fideliteit voor statuscodes en 16% voor de vorm van de response-body op onbekende scenario's.

Methodologie: MIRAGE

De auteurs stellen een nieuwe aanpak voor: Online LLM-simulatie. In plaats van een statisch mock-object te genereren, blijft het Large Language Model (LLM) tijdens de testuitvoering actief in de "loop".

Kernprincipes:

Runtime Reactie: Het LLM beantwoordt elke HTTP-request direct zodra deze binnenkomt.
State Management: Het model onderhoudt de interactiestatus over meerdere requests heen binnen een testscenario (cross-request state).
Context: Het LLM leest de broncode van de afhankelijkheid (indien beschikbaar), de broncode van de caller, en productietraces om het gedrag op verzoek te simuleren. Er wordt geen vooraf gegenereerde mock-specificatie gebruikt.

Systeemarchitectuur (MIRAGE):

Context Builder: Stelt het systeemprompt samen uit broncode (afhankelijkheid en caller) en een samenvatting van traces.
Per-Request LLM Server: Een FastAPI-server die HTTP-requests onderschept. Het verstuurt de request-details (methode, path, body, headers) naar het LLM. Het LLM retourneert een JSON-object met statuscode, body en headers. De conversatiegeschiedenis wordt bewaard (beperkt tot de laatste 20 uitwisselingen) om state te tracken.
Scenario Context: Voordat een teststart, wordt de reeks van HTTP-methodes en paths (zonder de verwachte uitkomsten) aan het mock-eindpunt doorgegeven om het LLM voor te bereiden op multi-stap flows.

Experimentele Opzet:
De evaluatie omvatte 110 testscenario's over 14 caller-afhankelijkheidsparen in drie systemen:

Demo: Een aangepast systeem met complexe patronen (optimistic locking, token lifecycle, saga-orchestration).
Online Boutique: Google's demo-applicatie.
Sock Shop: Weaveworks' benchmark.

Er werden drie operationele modi getest:

White-box: Volledige zichtbaarheid (afhankelijkheidsbroncode + caller + traces).
Black-box: Alleen caller-code + traces (geen broncode van de afhankelijkheid).
Ablatie: Isolatie van individuele signalen (alleen traces, alleen caller, etc.).

Belangrijkste Bijdragen

Online LLM-simulatie als primitief: Dit is de eerste empirische studie die LLM's gebruikt voor runtime-simulatie van microservice-afhankelijkheden met state-tracking.
Empirische validatie: Uitgebreide vergelijking met bestaande methoden (record-replay, pattern-mining, contract-IR) over meerdere benchmarks.
Karakterisering van de werking: Analyse van welke input-signalen (broncode vs. traces) het meest bijdragen aan de kwaliteit en de impact van gestructureerde tussenliggende representaties (IR).

Resultaten

1. Fideliteit (Nauwkeurigheid):

White-box (MIRAGE): Bereikte 99% fideliteit voor zowel statuscodes als response-shape (109/110 scenario's).
Black-box (MIRAGE): Bereikte 94% voor statuscodes en 75% voor response-shape. Zonder broncode kan het model foutcodes goed afleiden, maar mist het de precieze structuur van de response-body.
Vergelijking met Baselines:
- Record-replay: Slechts 62% status-fideliteit en 16% body-shape fideliteit.
- Pattern-mining: 61% (alleen op Demo getest).
- Contract IR (gestructureerde generatie): 55% op complexe stateful services (Demo), maar 86% op simpele API's. Dit toont aan dat gestructureerde IR's falen bij complexe, impliciete state-tracking.

2. Signal Contribution (Ablatie):

Broncode is cruciaal: Alleen de broncode van de afhankelijkheid leverde 100% fideliteit op.
Zonder broncode daalt de response-shape fideliteit drastisch, terwijl de statuscode fideliteit redelijk hoog blijft (92-94%). Dit suggereert dat het LLM beslissingen (foutcodes) kan afleiden uit traces, maar de exacte response-structuur niet kan reconstrueren zonder de implementatie.

3. Kosten en Latentie:

Kosten: $0,16 –$ 0,82 per afhankelijkheid (afhankelijk van het model, bijv. Claude Sonnet vs. Opus).
Latentie: ~~3 seconden per LLM-call. Hoewel dit trager is dan een echte service (~~50ms), is het netto-effect op CI-pipelines vaak gunstiger omdat er geen tijd verloren gaat aan het provisioneren van Docker-containers en databases (2-5 minuten besparing).
Eind-tot-eind validatie: In 8 end-to-end integratietests gaven MIRAGE-mocks exact dezelfde pass/fail-uitkomsten als echte afhankelijkheden.

Betekenis en Conclusie

MIRAGE demonstreert dat online LLM-simulatie een superieure methode is voor microservice-integratietesten, vooral voor scenario's met complexe state en onvoorspelbare foutpaden waar statische mocks falen.

Praktische Implicatie: Voor teams zonder vooraf geprovisioneerde staging-omgevingen biedt MIRAGE een haalbaar alternatief dat sneller is dan het opzetten van volledige infrastructuur.
Aanbeveling: Gebruik White-box mode (met broncode) voor de hoogste kwaliteit. Gebruik Black-box mode voor snelle mock-generatie wanneer broncode niet beschikbaar is, maar wees je bewust van beperkingen in de response-structuur.
Toekomst: Gestructureerde generatie (Intermediate Representations) werkt goed voor simpele, stateless API's, maar online simulatie is essentieel voor complexe, stateful diensten.

Het paper concludeert dat deze aanpak de kloof overbrugt tussen de beperkingen van statische mocks en de complexiteit van moderne microservice-architecturen, met een hoge mate van betrouwbaarheid en een praktisch kostenniveau.