Ontwerp Geavanceerde Postman API Testdata Generators
description
Met deze prompt kan ik geavanceerde en dynamische testdata generators opzetten in Postman, waardoor ik mijn API tests realistischer en gevarieerder kan maken. Dit lost het probleem op van statische testdata en helpt bij het automatiseren van testdata beheer, wat tijd bespaart en testdekking verhoogt. Het is beter dan alternatieven doordat het specifiek focust op integratie met externe data en automatische updates, wat zelden in standaard prompts wordt behandeld.
prompt
Help me bij het ontwerpen van geavanceerde testdata generators in Postman om dynamische, realistische en gevarieerde API testdata te creëren. Testdata types: <voer de soorten testdata in, zoals gebruikersinfo, transacties, etc.> Variatie regels: <beschrijf regels voor data variatie zoals bereik, patronen of uitzonderingen> Automatisering van data updates: <leg uit hoe testd ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier is een uitgebreide gids met scripts en configuraties voor Postman om geavanceerde, dynamische en gevarieerde API-testgegevens te genereren, inclusief automatisering, externe gegevensintegratie en validatieregels.
---
### 1. **Gebruik van Pre-request Scripts voor dynamische data generatie**
#### a) **Gebruikersinformatie (naam, e-mail, leeftijd, postcode)**
```javascript
// Functie om willekeurige naam te genereren
function getRandomName() {
const firstNames = ['Jan', 'Piet', 'Klaas', 'Lisa', 'Sophie', 'Daan', 'Eva'];
const lastNames = ['de Vries', 'Jansen', 'van den Berg', 'Mulder', 'de Boer', 'Smit', 'van Leeuwen'];
const firstName = firstNames[Math.floor(Math.random() * firstNames.length)];
const lastName = lastNames[Math.floor(Math.random() * lastNames.length)];
return `${firstName} ${lastName}`;
}
// Willekeurige leeftijd tussen 18 en 65
const age = Math.floor(Math.random() * (65 - 18 + 1)) + 18;
// Postcode patroon NL-1234 AB
function getRandomPostcode() {
const numberPart = Math.floor(Math.random() * 9000) + 1000; // 1000-9999
const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
const letter1 = letters.charAt(Math.floor(Math.random() * letters.length));
const letter2 = letters.charAt(Math.floor(Math.random() * letters.length));
return `NL-${numberPart} ${letter1}${letter2}`;
}
// E-mail valid en uniek
function getRandomEmail() {
const domains = ['gmail.com', 'outlook.com', 'yahoo.com', 'test.nl'];
const user = Math.random().toString(36).substring(2, 10);
const domain = domains[Math.floor(Math.random() * domains.length)];
return `${user}@${domain}`;
}
// Data object voor gebruiker
const gebruikerData = {
naam: getRandomName(),
email: getRandomEmail(),
leeftijd: age,
postcode: getRandomPostcode()
};
// Sla data in environment variables voor gebruik in body
pm.environment.set('gebruikerData', JSON.stringify(gebruikerData));
```
---
#### b) **Bestellingen (productcode, transactiedatum)**
- **Gebruik CSV-bestand voor productcodes**
**In Postman:**
- Ga naar `Collection Runner`
- Laad je CSV-bestand met kolom `productcode`
**CSV voorbeeld:**
```csv
productcode
ABC123
XYZ789
LMN456
```
**Pre-request Script voor bestellingen:**
```javascript
// Haal productcode uit CSV
const productCode = pm.iterationData.get('productcode');
// Transactiedatum: vandaag, niet in de toekomst
const today = new Date();
const yyyy = today.getFullYear();
const mm = String(today.getMonth() + 1).padStart(2, '0');
const dd = String(today.getDate()).padStart(2, '0');
const transactiedatum = `${yyyy}-${mm}-${dd}`;
// Data object voor bestelling
const bestellingData = {
productcode: productCode,
transactiedatum: transactiedatum
};
// Opslaan in environment
pm.environment.set('bestellingData', JSON.stringify(bestellingData));
```
---
### 2. **Gebruik van de data in API-aanroepen**
**Voor gebruikersinformatie:**
```json
{
"naam": "{{gebruikerData.naam}}",
"email": "{{gebruikerData.email}}",
"leeftijd": {{gebruikerData.leeftijd}},
"postcode": "{{gebruikerData.postcode}}"
}
```
**Voor bestellingen:**
```json
{
"productcode": "{{bestellingData.productcode}}",
"transactiedatum": "{{bestellingData.transactiedatum}}"
}
```
---
### 3. **Automatisering en data-vernieuwing**
- Zet in je Pre-request Scripts dat elke keer dat je een request doet, de data wordt vernieuwd.
- Gebruik `pm.environment.set()` om data te resetten voor elke test run.
- Voor volledige automatisering kun je in je test collection een `Pre-request Script` plaatsen dat deze scripts uitvoert.
---
### 4. **Validatie regels**
**In Tests tab:**
```javascript
// E-mail geldig?
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
pm.test("E-mail is geldig", () => {
const data = JSON.parse(pm.environment.get('gebruikerData'));
pm.expect(data.email).to.match(emailRegex);
});
// Leeftijd tussen 18 en 65
pm.test("Leeftijd tussen 18 en 65", () => {
const data = JSON.parse(pm.environment.get('gebruikerData'));
pm.expect(data.leeftijd).to.be.within(18, 65);
});
// Transactiedatum niet in de toekomst
pm.test("Transactiedatum niet in de toekomst", () => {
const data = JSON.parse(pm.environment.get('bestellingData'));
const today = new Date();
const transactieDate = new Date(data.transactiedatum);
pm.expect(transactieDate.getTime()).to.be.below(today.getTime() + 86400000); // inclusief vandaag
});
```
---
### 5. **Samenvatting**
- Gebruik dynamische scripts voor gebruikersgegevens.
- Laad productcodes uit CSV en gebruik in bestellingen.
- Verifieer dat data correct en geldig is met tests.
- Automatiseer datavernieuwing per test run.
- Pas scripts aan afhankelijk van je API structuur.
---
Heeft u nog verdere wensen of vragen?
provider: deepseek
model: deepseek-chat
Hier is een complete implementatie voor geavanceerde testdata generators in Postman:
## 1. Pre-request Script voor Dynamische Data Generatie
```javascript
// Pre-request Script - Plaats dit in de Pre-request Script tab van je request
// Helper functies voor data generatie
function generateRandomNumber(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
function generateEmail() {
const domains = ['example.com', 'test.nl', 'mail.com', 'domain.nl'];
const randomString = Math.random().toString(36).substring(2, 10);
const domain = domains[generateRandomNumber(0, domains.length - 1)];
return `${randomString}@${domain}`;
}
function generatePostcode() {
const numbers = generateRandomNumber(1000, 9999);
const letters = String.fromCharCode(65 + generateRandomNumber(0, 25)) +
String.fromCharCode(65 + generateRandomNumber(0, 25));
return `NL-${numbers} ${letters}`;
}
function generateDate() {
const today = new Date();
const pastDate = new Date(today);
pastDate.setDate(today.getDate() - generateRandomNumber(1, 365));
return pastDate.toISOString().split('T')[0];
}
// CSV Productcodes inladen (vereist CSV-bestand in collection)
function getProductCodes() {
if (pm.collectionVariables.get("productCodes")) {
return pm.collectionVariables.get("productCodes").split(',');
}
return ['PROD001', 'PROD002', 'PROD003', 'PROD004']; // fallback
}
// Data generatie functies
function generateUserData() {
const firstNames = ['Jan', 'Maria', 'Peter', 'Anna', 'David', 'Lisa'];
const lastNames = ['Jansen', 'de Vries', 'Bakker', 'Visser', 'Smit', 'Meijer'];
return {
firstName: firstNames[generateRandomNumber(0, firstNames.length - 1)],
lastName: lastNames[generateRandomNumber(0, lastNames.length - 1)],
age: generateRandomNumber(18, 65),
email: generateEmail(),
postcode: generatePostcode(),
userId: `USER_${Date.now()}_${generateRandomNumber(1000, 9999)}`
};
}
function generateOrderData() {
const productCodes = getProductCodes();
const quantities = [1, 2, 3, 5, 10];
const orderItems = [];
const itemCount = generateRandomNumber(1, 5);
for (let i = 0; i < itemCount; i++) {
orderItems.push({
productCode: productCodes[generateRandomNumber(0, productCodes.length - 1)],
quantity: quantities[generateRandomNumber(0, quantities.length - 1)],
price: (generateRandomNumber(10, 500) + Math.random()).toFixed(2)
});
}
return {
orderId: `ORD_${Date.now()}_${generateRandomNumber(1000, 9999)}`,
transactionDate: generateDate(),
items: orderItems,
totalAmount: orderItems.reduce((sum, item) => sum + (parseFloat(item.price) * item.quantity), 0).toFixed(2),
status: ['pending', 'confirmed', 'shipped'][generateRandomNumber(0, 2)]
};
}
// Data opslaan in variables voor gebruik in request
const userData = generateUserData();
const orderData = generateOrderData();
pm.collectionVariables.set("currentUser", JSON.stringify(userData));
pm.collectionVariables.set("currentOrder", JSON.stringify(orderData));
pm.collectionVariables.set("timestamp", Date.now().toString());
```
## 2. Collection Variables Configuratie
Ga naar **Collection Settings** → **Variables** en voeg toe:
| Variable | Initial Value | Current Value |
|----------|---------------|---------------|
| productCodes | PROD001,PROD002,PROD003 | (laat leeg) |
| currentUser | {} | (laat leeg) |
| currentOrder | {} | (laat leeg) |
| timestamp | 0 | (laat leeg) |
## 3. Request Body Template
Gebruik deze JSON in je request body:
```json
{
"user": {{currentUser}},
"order": {{currentOrder}},
"metadata": {
"generatedAt": "{{timestamp}}",
"testRunId": "{{$guid}}"
}
}
```
## 4. Test Script voor Validatie
```javascript
// Test Script - Plaats dit in de Tests tab van je request
// Validatie functies
function isValidEmail(email) {
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
return emailRegex.test(email);
}
function isNotFutureDate(dateString) {
const inputDate = new Date(dateString);
const today = new Date();
return inputDate <= today;
}
function isValidPostcode(postcode) {
const postcodeRegex = /^NL-\d{4} [A-Z]{2}$/;
return postcodeRegex.test(postcode);
}
// Test validaties
pm.test("E-mail is geldig", function() {
const userData = JSON.parse(pm.collectionVariables.get("currentUser"));
pm.expect(isValidEmail(userData.email)).to.be.true;
});
pm.test("Leeftijd tussen 18 en 65", function() {
const userData = JSON.parse(pm.collectionVariables.get("currentUser"));
pm.expect(userData.age).to.be.within(18, 65);
});
pm.test("Postcode heeft correct formaat", function() {
const userData = JSON.parse(pm.collectionVariables.get("currentUser"));
pm.expect(isValidPostcode(userData.postcode)).to.be.true;
});
pm.test("Transactiedatum is niet in de toekomst", function() {
const orderData = JSON.parse(pm.collectionVariables.get("currentOrder"));
pm.expect(isNotFutureDate(orderData.transactionDate)).to.be.true;
});
pm.test("Order heeft items", function() {
const orderData = JSON.parse(pm.collectionVariables.get("currentOrder"));
pm.expect(orderData.items.length).to.be.above(0);
});
// Response validatie
pm.test("Status code is 200", function() {
pm.response.to.have.status(200);
});
// Data opslaan voor hergebruik
pm.test("Sla testdata op", function() {
const response = pm.response.json();
if (response.orderId) {
pm.collectionVariables.set("lastOrderId", response.orderId);
}
});
```
## 5. CSV Productcodes Inladen Script
Maak een aparte request om CSV data in te laden:
```javascript
// Pre-request Script voor CSV import request
const csvData = `productCode,productName,category
PROD001,Laptop,Electronics
PROD002,Boek,Education
PROD003,Fiets,Sports
PROD004,Stoel,Furniture
PROD005,Telefoon,Electronics`;
// Parse CSV en sla productcodes op
const lines = csvData.split('\n');
const productCodes = [];
for (let i = 1; i < lines.length; i++) {
const [code] = lines[i].split(',');
if (code) productCodes.push(code);
}
pm.collectionVariables.set("productCodes", productCodes.join(','));
console.log("Productcodes geladen:", productCodes);
```
## 6. Environment Setup
Maak een environment aan met de volgende variables:
| Variable | Value |
|----------|-------|
| baseUrl | je-api-url |
| apiKey | je-api-key |
| testEnvironment | staging |
## 7. Collection Runner Configuratie
Voor geautomatiseerde test runs:
1. Open **Collection Runner**
2. Selecteer je collection
3. Stel **Iterations** in op gewenst aantal
4. **Delay**: 1000ms (optioneel)
5. **Data**: Selecteer eventueel een CSV-bestand voor extra variatie
## Gebruik:
1. **Sla de scripts op** in de betreffende tabs
2. **Run de request** - data wordt automatisch gegenereerd en gevalideerd
3. **Bekijk de Console** voor debug informatie
4. **Exporteer de Collection** voor back-up
Deze setup garandeert unieke, realistische testdata bij elke run met volledige validatie volgens je specificaties.