Een reis-API testen in de sandbox: wat de sandbox niet laat zien

De integratie doorstond alles wat reis-API-tests in de sandbox erop konden afvuren. De zoekopdracht gaf vluchten terug, de beschikbaarheidscall voor hotels kwam terug met kamers, de boekingscall leverde elke keer een bevestigingsnummer op en QA tekende op een donderdag af. De dinsdag erna betaalde een klant een hotel tegen de ene prijs en bevestigde de leverancier het tegen een andere, liep een vluchtboeking in een timeout zonder dat iemand kon zeggen of er een stoel vastgehouden werd, en zat een supportmedewerker een middag lang twee records te verzoenen die dezelfde reis beschreven. Geen van die dingen was een bug die de testsuite miste. Het waren scenario's die de testsuite nooit kon zien. Een sandbox is nodig, maar bij lange na niet genoeg, en in het gat daartussen zitten de meeste dure incidenten van een reisintegratie.
Dit is een testplan voor de developer die eigenaar is van die integratie: wat een sandbox kan bewijzen, wat hij structureel niet kan, en hoe je het verschil dekt zonder echte stoelen te boeken op de bedrijfscreditcard.
Waarom code die in de sandbox slaagt in productie breekt
Een sandbox is een belofte over de vorm van antwoorden, niet over hun gedrag. Het schema klopt met productie. Het gedrag bijna nooit, om redenen waar niemand iets aan kan doen: een testomgeving kan zich geen live voorraad veroorloven, dus serveert hij een vaste set tarieven en kamers die nooit uitverkopen, nooit van prijs veranderen en nooit van dienstregeling wisselen. Hij antwoordt snel omdat niemand anders hem gebruikt. Hij faalt zelden halverwege.
Productie doet al die dingen dagelijks. Voorraad wordt gedeeld met elke andere verkoper; tarieven worden ergens stroomopwaarts gecachet en raken verouderd; het systeem van een leverancier onder last antwoordt traag of helemaal niet. Code die alleen een sandbox heeft gezien, is in feite alleen getest tegen een leverancier op een perfecte dag.
Behandel de sandbox dus als één laag van drie. Hij bewijst dat je requests goed gevormd zijn en dat je parser het schema begrijpt. Opgenomen fixtures bewijzen dat je code de antwoorden overleeft die productie echt stuurt. Een kleine, bewuste set live checks bewijst de bedrading nadat er iets veranderd is. Elke laag vangt wat de andere twee niet kunnen.
De scenario's die een sandbox meestal niet levert
Schrijf ze op voordat je één test schrijft. Een sandbox kan er één of twee simuleren met een magische testwaarde; de meeste heeft hij gewoon niet.
| Scenario | Wat productie doet | Hoe je het dekt |
|---|---|---|
| Prijs verandert tussen zoeken en boeken | De boeking slaagt tegen een ander totaal, of faalt met een prijswijzigingsfout die je moet tonen | Fixturepaar: een zoekantwoord en een boekingsantwoord met een ander totaal; controleer dat de reiziger opnieuw gevraagd wordt en nooit stilletjes belast |
| Uitverkocht tussen beschikbaarheid en boeking | De aangeboden kamer of tariefklasse is weg als je hem probeert vast te houden | Fixture van de echte uitverkocht-fout van de leverancier; controleer dat de reiziger teruggaat naar de resultaten, niet naar een foutpagina |
| Timeout op de boekingscall | De leverancier heeft de boeking misschien wel, misschien niet aangemaakt | Injecteer een timeout nadat de request verstuurd is; controleer dat je de boekingsstatus opvraagt voordat er iets opnieuw probeert |
| Dubbele verzending | Een dubbelklik of een client-retry maakt twee boekingen | Stuur dezelfde boeking twee keer met dezelfde idempotency key; controleer dat er precies één bestaat |
| Dienstregelingswijziging na ticketing | De verkochte vlucht vertrekt nu op een ander tijdstip of onder een ander vluchtnummer | Fixture van een gewijzigde reisroute; controleer dat de wijziging terechtkomt bij wie de klant beheert |
| Gedeeltelijk succes bij een boeking met meerdere onderdelen | De vlucht wordt bevestigd, het hotel niet | Gemengde fixture; controleer dat het systeem precies vastlegt wat bevestigd is en een mens alarmeert |
| Throttling onder last | Rate-limit-antwoorden, daarna trage antwoorden | Speel een opgenomen throttling-antwoord af; controleer backoff, en dat zoeken degradeert in plaats van foutmeldingen te geven |
Misschien ben je het voor je eigen stack niet eens met de laatste kolom. Prima. Waar het om gaat is dat elke rij een eigenaar en een assertie heeft, want elke rij overkomt je uiteindelijk.
Bouw fixtures uit echte antwoorden, niet uit verzonnen
De nuttigste gewoonte in een reisintegratie is de antwoorden bewaren die je verrasten. Handgeschreven mockdata weerspiegelt wat jij denkt dat een leverancier stuurt; een opgenomen antwoord weerspiegelt wat hij werkelijk stuurde, inclusief de velden die leeg zijn terwijl de documentatie zegt dat dat nooit gebeurt, de prijs in een valuta waar je niet om vroeg en de fout die binnenkomt met een successtatus.
Een routine die werkt:
- Neem op aan de grens. Log ruwe request- en responsebodies van leverancierscalls in een niet-productieomgeving, en in productie voor een steekproef van het verkeer als je privacyregels dat toestaan.
- Schoon op voordat je bewaart. Namen van passagiers, paspoortnummers, e-mailadressen, telefoonnummers en betaalreferenties gaan eruit voordat een fixture de repository in gaat. Vervang ze door overduidelijk nepwaarden, zodat niemand een fixture voor een echte boeking aanziet.
- Noem fixtures naar gedrag.
hotel-book-price-increased.jsonvertelt de volgende developer waarom hij bestaat;response-17.jsonniet. - Bewaar de lelijke voor altijd. Het misvormde antwoord dat op een zondag de zoekfunctie platlegde, is het waardevolste bestand dat je hebt. Het hoort in een test die bij elke commit draait.
Schrijf daarna contracttests tegen die fixtures: je parser, je mapping naar interne modellen, je foutclassificatie. Als een leverancier een veld hernoemt en een contracttest faalt, hoor je het in CI in plaats van van een klant. De classificatiekant wordt uitgebreider behandeld in ons stuk over foutafhandeling in de API van een boekingsmotor.
De geldstromen testen zonder geld uit te geven
Hier helpt de sandbox het minst, want de geldstromen zijn precies waar een testomgeving afwijkt van de echte. Echte ticketing, echte kaartafschrijving en echte facturatie door de leverancier zijn wat je het meest goed moet hebben en het minst live kunt oefenen.
Splits het probleem. Prijsberekening is pure logica en kan offline uitputtend getest worden: neem opgenomen tarieven, pas je markup-regels, valutaconversie en afronding toe, en controleer het totaal dat de reiziger ziet. Doe het voor de lastige gevallen — een tarief in de ene valuta verkocht in een andere, een markup die bij het ene product een percentage is en bij het andere een vast bedrag, een kindertarief, een afronding die verschilt tussen weergave en afschrijving. Een totaal dat een paar euro afwijkt, is nog steeds fout, en het is fout bij elke boeking.
De statusovergangen rond betaling zijn de tweede helft. Modelleer ze expliciet — geoffreerd, vastgehouden, betaald, bevestigd, geticket, geannuleerd, terugbetaald — en test dat elke overgang precies één oorzaak heeft. De test die de duurste bug vangt, is die welke vastlegt dat er geen betaling kan worden afgeschreven voor een boeking die de leverancier niet heeft bevestigd, en dat een bevestigde boeking niet kan bestaan zonder betaalrecord.
Maak het tot slot onmogelijk dat een testrun echte ticketing bereikt. Niet onwaarschijnlijk; onmogelijk. Een opstartcheck die weigert de suite te draaien als productiecredentials geladen zijn, kost één regel en voorkomt de slechtste ochtend die een integratieteam kan hebben.
Wat het kost als je het fout doet
Een gemist scenario in een reisintegratie verschijnt zelden als fout. Het verschijnt als een boeking die er prima uitziet. Een dubbel ticket waar niemand om vroeg en dat iemand vóór de deadline moet voiden. Een hotel bevestigd tegen een prijs die het reisbureau nu zelf moet slikken. Een getimede-out boeking die het systeem opnieuw probeerde, waardoor de leverancier twee kamers vasthoudt en beide factureert. Bij een vliegticket dat via een reisbureau verkocht is, kan een verschil tussen wat is uitgegeven en wat is verkocht later terugkomen als ADM, lang nadat de marge op die verkoop al is uitgegeven.
Die kosten komen terecht bij het bedrijf dat de reis verkocht, niet bij de developer die de retry-lus schreef. Dat is het hele argument om ze vóór de lancering te testen in plaats van ze één supportticket tegelijk te leren.
Wat je na elke leverancierswijziging moet smoke-testen
Leveranciers veranderen dingen: een nieuwe API-versie, een nieuw endpoint, een geroteerde credential, een andere contentmapping. Je eigen code is misschien helemaal niet veranderd. Draai deze lijst toch, in de omgeving die met de gewijzigde leverancier praat:
- Eén zoekopdracht per product dat je bij die leverancier verkoopt, op een route of stad waarvan je weet dat die resultaten geeft.
- Parse elk resultaat zonder er stilletjes een te laten vallen; vergelijk je aantal met wat het ruwe antwoord bevat.
- Prijs één resultaat van begin tot eind en vergelijk het getoonde totaal met je eigen berekening vanuit het ruwe tarief.
- Maak een boeking in de testomgeving, lees de status terug en vergelijk elk veld dat je opslaat.
- Annuleer haar en bevestig dat de annulering zichtbaar is in je eigen records én aan de kant van de leverancier.
- Haal je bewaarde lelijke fixtures door de nieuwe parser.
- Controleer dat timeouts en rate limits nog steeds leiden tot het gedrag dat je hebt gekozen, want een nieuwe versie kan ze anders beantwoorden. Zijn de responstijden verschoven, dan legt het stuk over latency uit welk deel daarvan jij kunt oplossen.
Kort genoeg om elke keer te draaien, en daar gaat het om. Een smoke test die niemand draait omdat hij een dag kost, is geen smoke test.
Waar de sandbox thuishoort
Niets hiervan maakt een sandbox minder nuttig. Het maakt hem eerlijk: de plek waar je het schema leert en bevestigt dat de requests kloppen, voordat fixtures en live checks de delen overnemen waar hij niet bij kan. Evalueer je de vlucht- en hotel-API's van het platform, dan begint toegang met een gesprek en niet met een self-service key — neem dit testplan mee naar dat gesprek en vraag hoe elke rij van de tabel hierboven gedekt zou worden. De antwoorden vertellen je meer over een API dan de documentatie.