Hier is een voorbeeld van aangepaste Postman-testscripts die de API-ratelimieten en throttling-scenario's simuleren en controleren. Deze scripts sturen meerdere aanvragen binnen een minuut, controleren op de juiste HTTP-status bij overschrijding en letten op de Retry-After-header. **1. Pre-request Script:** Om de authenticatie en request-headers in te stellen, en om het aantal aanvragen te tellen: ```javascript // Voeg je Bearer token toe pm.request.headers.add({ key: 'Authorization', value: 'Bearer ABCDEF123456' }); // Initialiseer variabelen voor request telling en tijd if (!pm.variables.get('requestCount')) { pm.variables.set('requestCount', 0); pm.variables.set('startTime', new Date().getTime()); } // Verhoog request count bij elke request let count = pm.variables.get('requestCount'); count++; pm.variables.set('requestCount', count); ``` **2. Test Script:** Na elke response, controleer of de API zich aan de ratelimietregels houdt: ```javascript // Controleer de status code en headers if (pm.response.code === 429) { // Bij overschrijding: verwacht status 429 en Retry-After header pm.test("Ontvangen 429 Too Many Requests bij overschrijding limiet", function () { pm.response.to.have.status(429); pm.response.to.have.header('Retry-After'); // Optioneel: controleer of Retry-After waarde een getal is let retryAfter = pm.response.headers.get('Retry-After'); pm.expect(retryAfter).to.match(/^\d+$/); }); } else { // Bij normale responses pm.test("API geeft geen 429, binnen limiet", function () { pm.response.to.not.have.status(429); }); } // Controleer dat het aantal requests binnen een minuut de limiet niet overschrijdt let startTime = pm.variables.get('startTime'); let currentTime = new Date().getTime(); let elapsedSeconds = (currentTime - startTime) / 1000; if (elapsedSeconds >= 60) { // Na 60 seconden reset je teller en starttijd pm.variables.set('requestCount', 1); pm.variables.set('startTime', currentTime); } else { // Bij minder dan 60 seconden, als requestCount > limiet, test falen let requestCount = pm.variables.get('requestCount'); pm.test("Aantal requests binnen limiet", function () { pm.expect(requestCount).to.be.at.most(100); }); } ``` **3. Automatisering en herhaling:** Deze scripts kunnen in Postman worden ingesteld op de eerste request. Gebruik de "Collection Runner" met een vertraging van 200 ms (5 aanvragen per seconde) en stel de looptijd in op 1 minuut. **4. Extra tips:** - Gebruik de "Set Next Request" functie indien nodig om automatisch door te gaan. - Controleer regelmatig de headers op 429-status en de Retry-After waarde. - Pas indien nodig de request frequentie aan om dicht bij de limiet te blijven en overschrijding te testen. Met deze scripts simuleer je het gedrag van API-verzoeken binnen de limiet en kun je controleren of de API correct reageert op overschrijdingen.

Hier zijn aangepaste Postman-testscripts om de API-ratelimieten en throttling-scenario's te testen: ## Pre-request Script ```javascript // Configureer testparameters const requestsPerSecond = 5; const testDuration = 60000; // 1 minuut in milliseconden const rateLimit = 100; // 100 aanvragen per minuut // Bereken totaal aantal aanvragen const totalRequests = requestsPerSecond * (testDuration / 1000); // Sla testconfiguratie op in environment pm.environment.set("requestsPerSecond", requestsPerSecond); pm.environment.set("testDuration", testDuration); pm.environment.set("totalRequests", totalRequests); pm.environment.set("rateLimit", rateLimit); pm.environment.set("requestCount", 0); pm.environment.set("successCount", 0); pm.environment.set("rateLimitCount", 0); pm.environment.set("startTime", Date.now()); ``` ## Test Script ```javascript // Test voor ratelimiet compliance const currentTime = Date.now(); const startTime = pm.environment.get("startTime"); const elapsedTime = currentTime - startTime; // Update tellers let requestCount = pm.environment.get("requestCount") + 1; let successCount = pm.environment.get("successCount"); let rateLimitCount = pm.environment.get("rateLimitCount"); pm.environment.set("requestCount", requestCount); // Test response status if (pm.response.code === 200) { successCount++; pm.environment.set("successCount", successCount); // Controleer of we onder de ratelimiet blijven const expectedMaxRequests = Math.floor((elapsedTime / 60000) * pm.environment.get("rateLimit")); pm.test(`Aantal requests (${requestCount}) blijft binnen ratelimiet (max ${expectedMaxRequests})`, function() { pm.expect(requestCount).to.be.at.most(expectedMaxRequests + 5); // Kleine marge voor timing }); } // Test voor rate limit overschrijding if (pm.response.code === 429) { rateLimitCount++; pm.environment.set("rateLimitCount", rateLimitCount); // Controleer Retry-After header pm.test("Retry-After header aanwezig bij 429 response", function() { pm.expect(pm.response.headers.get("Retry-After")).to.not.be.undefined; }); pm.test("Retry-After header bevat geldige waarde", function() { const retryAfter = parseInt(pm.response.headers.get("Retry-After")); pm.expect(retryAfter).to.be.a('number'); pm.expect(retryAfter).to.be.at.least(1); }); } // Algemene response tests pm.test("Status code is 200 of 429", function() { pm.expect(pm.response.code).to.be.oneOf([200, 429]); }); pm.test("Response tijd is acceptabel", function() { pm.expect(pm.response.responseTime).to.be.below(5000); // Max 5 seconden }); // Eindtest wanneer testduur verstreken is if (elapsedTime >= pm.environment.get("testDuration")) { const totalRequests = pm.environment.get("requestCount"); const successRate = (successCount / totalRequests) * 100; const rateLimitHitRate = (rateLimitCount / totalRequests) * 100; console.log(`Test samenvatting: - Totaal requests: ${totalRequests} - Succesvolle requests: ${successCount} - Rate limit hits: ${rateLimitCount} - Succesratio: ${successRate.toFixed(2)}% - Rate limit ratio: ${rateLimitHitRate.toFixed(2)}%`); pm.test(`Rate limit wordt correct gehandhaafd (${rateLimitHitRate.toFixed(2)}% 429 responses)`, function() { pm.expect(rateLimitHitRate).to.be.above(0); // Moet minstens enkele 429 responses hebben }); } ``` ## Collection Runner Script ```javascript // Script voor Collection Runner om burst-aanvragen te simuleren const request = { url: 'https://api.example.com/v1/users', method: 'GET', header: { 'Authorization': 'Bearer ABCDEF123456', 'Content-Type': 'application/json' } }; // Simuleer 5 requests per seconde gedurende 1 minuut const startTime = Date.now(); const testDuration = 60000; const requestsPerSecond = 5; let requestCount = 0; let successCount = 0; let rateLimitCount = 0; async function sendRequests() { while (Date.now() - startTime < testDuration) { const batchStart = Date.now(); // Stuur 5 parallelle requests const promises = []; for (let i = 0; i < requestsPerSecond; i++) { promises.push(pm.sendRequest(request)); } const responses = await Promise.all(promises); requestCount += responses.length; responses.forEach(response => { if (response.code === 200) { successCount++; } else if (response.code === 429) { rateLimitCount++; console.log(`Rate limit hit! Retry-After: ${response.headers.get('Retry-After')}`); } }); // Wacht tot volgende seconde const elapsed = Date.now() - batchStart; if (elapsed < 1000) { await new Promise(resolve => setTimeout(resolve, 1000 - elapsed)); } } console.log(`Test voltooid: Totaal requests: ${requestCount} Succesvol: ${successCount} Rate limited: ${rateLimitCount} Succesratio: ${((successCount / requestCount) * 100).toFixed(2)}%`); } sendRequests(); ``` ## Environment Variabelen ```json { "base_url": "https://api.example.com/v1", "auth_token": "Bearer ABCDEF123456", "requestsPerSecond": 5, "testDuration": 60000, "rateLimit": 100 } ``` ## Gebruiksaanwijzing: 1. **Importeer in Postman**: - Maak een nieuwe collection aan - Plak de scripts in de respectievelijke tabbladen - Stel de environment variabelen in 2. **Voer tests uit**: - Gebruik de Collection Runner voor grootschalige tests - Of voer individuele requests uit met de test scripts 3. **Monitor resultaten**: - Check de console voor gedetailleerde logs - Analyseer de response ratios - Verifieer dat de API consistent 429 responses geeft na 100 requests/minuut Deze scripts simuleren realistische load en controleren of de API correct omgaat met ratelimieten volgens de gespecificeerde voorwaarden.