Ontwikkel een Postman API Error Handling Strategie
description
Met deze prompt kan de gebruiker een gestructureerde aanpak ontwikkelen voor foutafhandeling in Postman, waardoor API-tests betrouwbaarder en onderhoudbaarder worden. Dit voorkomt onopgemerkte fouten, verbetert de testkwaliteit en automatiseert foutdetectie en -reactie, wat beter is dan ad-hoc of handmatige foutafhandeling.
prompt
Help me een robuuste foutafhandelingsstrategie te ontwikkelen voor mijn Postman API-tests. Mijn API-naam is: <voer de naam van je API in> Specifieke foutscenario's die ik wil afdekken: <beschrijf de foutscenario's zoals time-outs, 4xx/5xx fouten, ongeldige data> Hoe i ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier zijn enkele aanbevelingen en best practices om een robuuste foutafhandelingsstrategie voor je Postman API-tests te ontwikkelen, gericht op time-outs, 401 Unauthorized en meer geavanceerde foutdetectie:
1. **Detectie van verschillende foutstatuscodes en fouttypes**
- **Gebruik uitgebreide testasserties:** Controleer niet alleen op statuscode 200, maar ook op andere codes en fouten.
```javascript
pm.test("Statuscode is succesvol of fout", function () {
pm.expect(pm.response.code).to.be.oneOf([200, 401, 408, 500]);
});
// Specifieke tests voor foutcodes
if(pm.response.code !== 200){
console.warn(`Foutstatus: ${pm.response.code} - ${pm.response.reason()}`);
}
```
2. **Detectie en afhandeling van time-outs**
- **Timeouts worden meestal niet door de API zelf geretourneerd, maar door Postman of je netwerkconfiguratie.** Controleer in je Postman instellingen of je time-outs hebt ingesteld en maak gebruik van 'test scripts' om te detecteren of er geen respons is ontvangen.
```javascript
if(pm.response.code === 0){
console.error("Geen respons ontvangen - mogelijk time-out");
// Log of reageer automatisch
}
```
3. **Automatisch reageren op veelvoorkomende fouten**
- **Retry-logica:** Voor bijvoorbeeld time-outs en 500-fouten kun je herhaal- of retry-mechanismen implementeren via Postman’s scripting of via Newman (CLI).
- **Foutafhandelingsscript voorbeeld:**
```javascript
if(pm.response.code === 408 || pm.response.code === 500){
// Log fout en eventueel trigger een herhaalactie
console.log("Herhaal request door foutcode:", pm.response.code);
// Mogelijkheid: gebruik environment variables om retry-teller bij te houden
}
```
4. **Logging en rapportage**
- **Gebruik console.log, console.error voor debugging.**
- **Stuur foutgegevens naar een externe loggingservice** via HTTP requests binnen je test scripts.
```javascript
if(pm.response.code !== 200){
pm.sendRequest({
url: 'https://mijn-logservice/api/logs',
method: 'POST',
header: 'Content-Type: application/json',
body: {
mode: 'raw',
raw: JSON.stringify({
endpoint: pm.request.url.toString(),
status: pm.response.code,
responseTime: pm.response.responseTime,
message: pm.response.body
})
}
});
}
```
5. **Herstel en automatische acties**
- **Gebruik environment variables** om aan te geven dat een test is mislukt en dat er een volgende actie moet worden ondernomen.
```javascript
if(pm.response.code === 401){
pm.environment.set("authExpired", "true");
// Mogelijkheid: automatisch een nieuw token ophalen
}
```
6. **Gebruik van test assertions om fouten te voorkomen**
- Bijvoorbeeld, controleer op de aanwezigheid van verwachte velden:
```javascript
pm.test("Response bevat verwachte gegevens", function() {
var jsonData = pm.response.json();
pm.expect(jsonData).to.have.property('orderId');
pm.expect(jsonData.orderId).to.not.be.empty;
});
```
7. **Automatisering en integratie met CI/CD**
- Gebruik Newman om je tests uit te voeren en fouten automatisch te rapporteren, tijdig te reageren op fouten en retries te automatiseren.
8. **Aanbevelingen voor verbeterde robuustheid**
- Stel uitgebreide testscripts op die verschillende foutscenario's afdekken.
- Implementeer retries voor tijdelijke fouten.
- Log alle fouten en responsegegevens naar een externe service voor analyse.
- Automatiseer herstelacties waar mogelijk (bijv. opnieuw authenticeren bij 401).
- Documenteer je foutafhandelingsstrategie en update deze op basis van nieuwe incidenten.
**Kort samengevat:** breid je test scripts uit met uitgebreide statuscode checks, log alle fouten, automatiseer retries en herstelacties, en integreer met externe logging en CI/CD pipelines voor maximale robuustheid.
provider: deepseek
model: deepseek-chat
Hier is een robuuste foutafhandelingsstrategie voor je BestellingenAPI Postman-tests:
## 1. Test Asserties voor Specifieke Foutscenario's
### Voor Time-outs:
```javascript
// In Tests tab
pm.test("Response time is acceptable", function () {
pm.expect(pm.response.responseTime).to.be.below(5000); // 5 seconden timeout
});
pm.test("API reageert binnen timeout periode", function () {
if (pm.response.code === 0) {
pm.expect.fail("API timeout - geen response ontvangen");
}
});
```
### Voor 401 Unauthorized:
```javascript
pm.test("Status code is niet 401 Unauthorized", function () {
pm.expect(pm.response.code).to.not.be.oneOf([401]);
});
pm.test("Geen autorisatiefout", function () {
if (pm.response.code === 401) {
const errorMessage = pm.response.json().message || "Unauthorized access";
pm.expect.fail(`Autorisatiefout: ${errorMessage}`);
}
});
```
## 2. Uitgebreide Statuscode Controle
```javascript
// Algemene statuscode validatie
pm.test("Successful HTTP response", function () {
pm.expect(pm.response.code).to.be.oneOf([200, 201, 202, 204]);
});
// Gedetailleerde foutafhandeling
pm.test("Geen server errors", function () {
pm.expect(pm.response.code).to.not.be.oneOf([500, 502, 503, 504]);
});
pm.test("Geen client errors", function () {
pm.expect(pm.response.code).to.not.be.oneOf([400, 401, 403, 404, 429]);
});
```
## 3. Fout Logging en Reporting
### Pre-request Script (voor logging):
```javascript
console.log(`Test gestart: ${pm.request.name} - ${new Date().toISOString()}`);
```
### Test Script voor Uitgebreide Logging:
```javascript
// Response logging
console.log("Response status:", pm.response.code);
console.log("Response time:", pm.response.responseTime + "ms");
console.log("Response headers:", JSON.stringify(pm.response.headers));
// Fout logging
if (pm.response.code >= 400) {
console.error("Fout gedetecteerd:", {
status: pm.response.code,
statusText: pm.response.status,
body: pm.response.text(),
timestamp: new Date().toISOString(),
requestUrl: pm.request.url.toString()
});
// Opslaan in environment variable voor latere analyse
const errorCount = parseInt(pm.environment.get("errorCount") || "0") + 1;
pm.environment.set("errorCount", errorCount.toString());
}
```
## 4. Automatische Herstelstrategieën
### Collection-level Pre-request Script:
```javascript
// Token refresh bij 401
if (pm.collectionVariables.get("autoRefreshToken") === "true") {
const tokenTimestamp = pm.collectionVariables.get("tokenTimestamp");
const currentTime = new Date().getTime();
if (!tokenTimestamp || (currentTime - parseInt(tokenTimestamp)) > 3600000) {
// Token ophalen en opslaan
pm.sendRequest({
url: 'https://your-auth-server.com/token',
method: 'POST',
header: {
'Content-Type': 'application/json'
},
body: {
mode: 'raw',
raw: JSON.stringify({
grant_type: 'client_credentials',
client_id: pm.collectionVariables.get("clientId"),
client_secret: pm.collectionVariables.get("clientSecret")
})
}
}, function (err, res) {
if (!err && res.code === 200) {
const newToken = res.json().access_token;
pm.collectionVariables.set("authToken", newToken);
pm.collectionVariables.set("tokenTimestamp", currentTime.toString());
}
});
}
}
```
## 5. Retry Mechanisme voor Time-outs
```javascript
// In Tests tab
const maxRetries = 3;
const retryDelay = 1000; // 1 seconde
if (pm.response.code === 0 || pm.response.code >= 500) {
const retryCount = parseInt(pm.environment.get("retryCount") || "0");
if (retryCount < maxRetries) {
pm.environment.set("retryCount", (retryCount + 1).toString());
console.log(`Retry poging ${retryCount + 1} van ${maxRetries}`);
setTimeout(() => {
postman.setNextRequest(pm.info.requestName);
}, retryDelay);
} else {
pm.environment.set("retryCount", "0");
pm.expect.fail(`Max retries bereikt (${maxRetries})`);
}
} else {
pm.environment.set("retryCount", "0");
}
```
## 6. Environment Variabelen Setup
```javascript
// Initialiseer monitoring variabelen
pm.collectionVariables.set("errorCount", "0");
pm.collectionVariables.set("totalRequests", "0");
pm.collectionVariables.set("successfulRequests", "0");
```
## 7. Test Rapportage
```javascript
// Eindtest voor statistieken
pm.test("Test samenvatting", function () {
const totalRequests = parseInt(pm.collectionVariables.get("totalRequests") || "0");
const successfulRequests = parseInt(pm.collectionVariables.get("successfulRequests") || "0");
const errorCount = parseInt(pm.collectionVariables.get("errorCount") || "0");
console.log(`Test Samenvatting:
- Totaal requests: ${totalRequests}
- Succesvolle requests: ${successfulRequests}
- Fouten: ${errorCount}
- Succespercentage: ${((successfulRequests / totalRequests) * 100).toFixed(2)}%`);
pm.expect(errorCount).to.be.below(totalRequests * 0.1); // Max 10% fouten
});
```
## 8. Best Practices voor Implementatie
1. **Gebruik Collection Variables** voor gedeelde configuratie
2. **Implementeer in Pre-request Scripts** voor consistente setup
3. **Maak gebruik van Postman Monitors** voor scheduled testing
4. **Exporteer logs** naar externe systemen voor analyse
5. **Stel alerts in** voor kritieke fouten (401, time-outs)
Deze strategie zorgt voor een complete foutafhandeling die specifiek is afgestemd op je BestellingenAPI en de genoemde foutscenario's effectief detecteert en afhandelt.