Integration Testing: Testen of je bot echt praat met de broker sandbox
Je hebt een bot gebouwd die prachtige signalen geeft. Je hebt een broker gekozen met een sandbox-omgeving.
Je start de bot, en er gebeurt... niets. Of erger: je krijgt een foutmelding die niets zegt. Hoe weet je nu zeker of je bot echt verbinding maakt, orders verstuurt en posities ziet in die testomgeving?
Integration testing is het antwoord. Je test hierbij de brug tussen je Python-code en de broker-API.
Het is de eerste stap voordat je ook maar één echte euro riskeert.
Wat is integration testing voor trading bots?
Stel je voor dat je bot een auto is. Je hebt de motor (je strategie) gebouwd en getest op een testbank (backtesting).
Nu moet je weten of de motor daadwerkelijk met de versnellingsbak en de wielen praat.
Integration testing controleert of de verschillende onderdelen samenwerken. In ons geval: praat je Python-script echt met de API van je broker? Het gaat verder dan een simpele 'ping'.
Je test niet alleen of de server reageert, maar ook of de juiste data binnenkomt en of je orders correct worden geaccepteerd. Je controleert of je bot fouten van de broker begrijpt en verwerkt.
Dit doe je allemaal in de sandbox, de veilige testomgeving van je broker. Veel traders springen hier overheen. Ze draaien hun bot direct live na een succesvolle backtest. Dat is riskant. Een verkeerde endpoint of een verkeerde JSON-structuur kan leiden tot verkeerde orders of een crash op het moment dat de markt open gaat. Integration testing vangt deze bugs op voordat ze geld kosten.
Waarom dit cruciaal is voor je bot
Stel je voor dat je bot een shortpositie wil openen op de DAX (GER40) omdat je backtest een winstgevend signaal laat zien.
Je script draait, maar er gebeurt niets. Waarom? Misschien gebruik je de verkeerde API-call voor een short-order.
Misschien staat je API-sleutel op de verkeerde broker-omgeving (live vs. demo). Integration testing geeft je zekerheid. Je weet dat je bot niet alleen slim is, maar ook robuust. Je weet dat als de markt beweegt, je bot de juiste data krijgt en kan handelen.
Dit bespaart je slapeloze nachten. Je hoeft niet constant je scherm te refreshen of te gissen naar wat er misgaat.
Een ander groot voordeel is het begrijpen van de API-limieten. Brokers zoals Interactive Brokers (IBKR) of degiro hebben limieten op het aantal requests per minuut. Tijdens integration testing kun je deze limieten simuleren.
Je kunt testen wat er gebeurt als je te snel te veel orders verstuurt. Dit voorkomt dat je account wordt geblokkeerd tijdens een hete marktsessie.
Denk ook aan foutafhandeling. Een API retourneert soms een foutcode in plaats van een orderbevestiging.
Je bot moet hierop kunnen reageren. Integration testing zorgt ervoor dat je code niet crasht bij een foutieve JSON-respons, maar logt wat er misgaat en een nieuwe poging waagt.
De kern van de test: Hoe het werkt in de praktijk
Je begint met een testscript in Python, vaak met behulp van een library als requests of een wrapper voor je broker (bijvoorbeeld ib_insync voor IBKR of alpaca-trade-api voor Alpaca). Het doel is om een volledige cyclus te testen: verbinden, data ophalen, een order plaatsen, de orderstatus checken en de order annuleren.
Een basis-testflow ziet er zo uit: Gebruik hiervoor een aparte account-ID voor de sandbox. Bij de meeste brokers krijg je bij het aanmaken van een account direct toegang tot een demo-omgeving.
- Verbind met de sandbox-API van je broker.
- Vraag de huidige koers aan voor een specifiek symbool (bijv. BTC/USD).
- Plaats een test-order (bijv. een limietorder net onder de huidige marktprijs).
- Check of de order verschijnt in je openstaande posities.
- Annuleer de order direct weer.
Bij Interactive Brokers moet je expliciet de TWS (Trader Workstation) instellen op de demo-modus of de PaperTrader API gebruiken.
Specifieke details zijn belangrijk. Let op de payload van je API-call. Een JSON-structuur voor een order moet er precies zo uitzien als de broker eist. Bijvoorbeeld voor een marktorder op Binance Futures:
{ "symbol": "BTCUSDT", "side": "BUY", "type": "MARKET", "quantity": 0.001 }
Een spatie verkeerd of een verkeerde hoofdletter kan de call mislukken. Integration testing controleert dit.
Varianten en modellen: Van simpel naar complex
Je hoeft niet meteen alles te testen. Je kunt opschalen in complexiteit.
Laten we kijken naar drie niveaus, inclusief indicatieve kosten voor tools of data (hoewel de API-toegang meestal gratis is voor demo's).
Niveau 1: Basisconnectiviteit (Kosten: €0)
Dit is de meest simpele test. Je script maakt een verbinding met de API-endpoint en haalt een simpel 'ping' op of de serverstatus op. Je checkt of je API-sleutel geldig is.
Dit test de authentication en de netwerkverbinding. Gebruik hiervoor een simpele Python-functie die een GET-request doet naar de 'account' endpoint. Niveau 2: Orderplaatsing en -bevestiging (Kosten: €0)
Hier test je de daadwerkelijke interactie. Je probeert een order te plaatsen en deze direct weer te annuleren.
Dit is de 'round-trip' test. Je controleert of de broker een 'order ID' teruggeeft.
Dit ID is cruciaal voor het bijhouden van je positie. Bij brokers zoals Plus500 of eToro (via hun API's) is deze test essentieel omdat de API-structuur complex kan zijn.
Niveau 3: Datastroom en foutafhandeling (Kosten: €0 - €50/maand voor data-abonnementen)
Dit is geavanceerder. Je test of je bot realtime data binnenkrijgt en of het reageert op market events. Simuleer een scenario: je bot krijgt een tick-prijs binnen die een stop-loss zou triggeren. Vergeet niet om je trading bots grondig te debuggen voordat ze live gaan.
Je test of de bot de stop-order correct verstuurt. Voor historische data tijdens testing kun je een goedkoop abonnement nemen op een data-provider zoals Polygon.io (vanaf ca. €20/maand) om te testen of je bot de data correct verwerkt voordat je live gaat. Loop je vast bij het plaatsen van orders?
Een ander model is het testen van 'mocking'. Je gebruikt een library als unittest.mock om de broker-API te simuleren. Dit is handig als je geen tijd hebt om constant een live-verbinding te testen.
Je 'faked' de broker en test of je bot de juiste beslissingen neemt op basis van de fake-data. Dit is sneller, maar test de echte connectie niet. Combineer beide voor de beste resultaten.
Praktische tips voor soepele integratie
Begin klein. Test eerst één enkele order voordat je een hele portfolio-strategie test. Gebruik een apart Python-venster (virtual environment) voor je testomgeving.
Dit voorkomt dat je productie-code per ongeluk wordt beïnvloed door test-libraries. Zorg ook voor een beheersbare dependency-structuur. Log alles.
logging.info(f"Order geplaatst: {response.status_code} - {response.text}")
Gebruik de Python logging module. Schrijf elke API-call, elke response en elke fout naar een bestand.
Als er iets misgaat, hoef je niet te raden; je kunt het teruglezen. Bijvoorbeeld: Test met kleine bedragen. Zelfs in de sandbox.
Gebruik eenhoeveelheden die realistisch zijn voor je live-account. Test bijvoorbeeld met 0.01 lot op Forex in plaats van 1 lot.
Dit simuleert de echte impact van spreads en kosten. Automatiseer je tests. Gebruik een framework als pytest. Schrijf een test die elke nacht draait en controleert of de sandbox-API nog steeds reageert zoals verwacht.
Dit is vooral handig als je broker API-updates doorvoert. Je wilt niet ontdekken dat een endpoint is veranderd tijdens een handelssessie.
Controleer de tijd. Trading bots zijn gevoelig voor tijdzones.
Zorg dat je servertijd (UTC) en de tijd van de broker synchroon lopen. Een verkeerde timestamp kan leiden tot afgewezen orders. Test dit door een order met een exacte tijdslimiet te plaatsen en te kijken of deze correct wordt geaccepteerd.
Als je klaar bent met deze tests, weet je zeker dat je bot niet alleen slim is, maar ook betrouwbaar praat met je broker. Je kunt met een gerust hart de live-modus inschakelen, wetende dat de brug tussen code en markt stevig is gebouwd.