Ontwikkel een Postman Workflow voor Geautomatiseerde API Mocking en Contract Validatie
description
Met deze prompt kun je een geautomatiseerde workflow opzetten die het maken van API mocks en contractvalidatie combineert. Dit versnelt de API-ontwikkeling, verbetert de testbetrouwbaarheid en vermindert handmatige inspanning doordat mocks en validaties synchroon verlopen. Het helpt problemen vroegtijdig op te sporen en zorgt voor consistente API gedragstests.
prompt
Help me een workflow te ontwikkelen in Postman die geautomatiseerde API mocking combineert met contractvalidatie. API Naam: <voer de naam van je API in> Mock Endpoints: <lijst van API endpoints die je wilt mocken> Contract Specificaties: <beschrijf de API contract details of link naar JSON schema> Validatiecriteria: <geef aan welke regels of schema's je wilt valid ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een volledige workflow voor Postman die API mocking combineert met contractvalidatie voor jouw E-commerce API:
---
### 1. **Opzetten van Mock Endpoints in Postman**
- Maak mock servers aan voor `/users` en `/orders`.
- Importeer je JSON-schema's via de [schema.json](https://example.com/schema.json).
- Configuratie mock responses zodat ze variëren op basis van inactieve/actieve gebruikers en rollen (bijvoorbeeld door variabele parameters of verschillende mock responses).
---
### 2. **Automatisch Mock Data Bijwerken**
Omdat Postman geen directe automatische synchronisatie met schema's ondersteunt, kun je de volgende aanpak gebruiken:
- **Gebruik Newman (CLI) en scripts voor automatisering**:
- Schrijf een script dat het schema downloadt en mock data genereert.
- Gebruik bijvoorbeeld een tool zoals [json-schema-faker](https://github.com/json-schema-faker/json-schema-faker) om mock data te genereren op basis van je schema.
- Upload de gegenereerde mock responses naar je mock server via de Postman API (voor geavanceerde workflows).
---
### 3. **Contractvalidatie in Postman**
Maak een **testscript** in je request:
```javascript
// Voorbeeld voor /users endpoint
const schemaUrl = 'https://example.com/schema.json'; // Het JSON-schema URL
const responseBody = pm.response.json();
// Laad het schema
pm.sendRequest(schemaUrl, function (err, res) {
if (err) {
console.error('Fout bij ophalen schema:', err);
pm.test('Schema ophalen', () => {
throw err;
});
return;
}
const schema = res.json();
// Valideer response met ajv
const Ajv = require('ajv');
const ajv = new Ajv();
const validate = ajv.compile(schema);
const valid = validate(responseBody);
pm.test('Respons voldoet aan schema', () => {
if (!valid) {
console.log(validate.errors);
}
pm.expect(valid).to.be.true;
});
});
```
**Opmerking:**
- Voeg `ajv` toe in je Postman environment via de **Pre-request Scripts** of via de **Postman Sandbox**.
- Alternatief: Gebruik de [Postman schema validation](https://learning.postman.com/docs/writing-scripts/script-references/validation-references/) of externe tools.
---
### 4. **Validatierapporten Genereren**
- Gebruik **Postman Monitors** om tests automatisch uit te voeren en rapporten te ontvangen.
- Converteer testresultaten naar een overzicht via de monitorrapporten.
- Voor uitgebreide rapportage, exporteer de resultaten en verwerk ze met een CI/CD pipeline of rapportagetool.
---
### 5. **Automatisering en Integratie**
- **Gebruik Newman** om tests en validaties automatisch uit te voeren:
```bash
newman run jouw_collection.json -r cli,junit --reporters-junit-export report.xml
```
- **Workflow automatisering:**
- Maak een CI/CD pipeline (bijvoorbeeld met GitHub Actions, Jenkins) die:
- Het schema bijwerkt,
- Mock data genereert en uploadt,
- Tests uitvoert met Newman,
- Rapporten genereert en verstuurt.
---
### 6. **Voorbeeld Postman Collection met Scripts**
Hier is een voorbeeld van een **testscript** dat je in je Postman request kunt plaatsen:
```javascript
// Contract validatie script
const schemaUrl = 'https://example.com/schema.json';
pm.sendRequest(schemaUrl, function (err, res) {
if (err) {
pm.test('Schema ophalen mislukt', () => {
throw new Error('Fout bij ophalen schema');
});
return;
}
const schema = res.json();
const Ajv = require('ajv');
const ajv = new Ajv();
const validate = ajv.compile(schema);
const responseBody = pm.response.json();
const valid = validate(responseBody);
pm.test('Respons voldoet aan schema', () => {
if (!valid) {
console.log(validate.errors);
}
pm.expect(valid).to.be.true;
});
});
```
---
### **Samenvatting**
- Gebruik Postman mock servers voor API mocking.
- Genereer mock data automatisch bij schemawijzigingen met json-schema-faker en upload deze via API.
- Plaats validatiescripts in je Postman requests om contract te controleren.
- Automatiseer het proces met Newman en CI/CD pipelines.
- Genereer rapporten via Postman Monitors en exporteer resultaten voor analyse.
---
### **Extra Tips**
- Bewaar schema's en mock data centraal, bijvoorbeeld in een Git repository.
- Automatiseer schema- en mock data updates met scripts en API calls.
- Overweeg het gebruik van tools zoals Prism voor meer geavanceerde contract testing en mocking.
---
Als je verdere hulp nodig hebt bij het schrijven van specifieke scripts of het opzetten van je CI/CD pipeline, laat het gerust weten!
provider: deepseek
model: deepseek-chat
Hier is een complete Postman-workflow voor geautomatiseerde API mocking met contractvalidatie:
## 1. Postman Environment Setup
Maak eerst een nieuwe environment aan met deze variabelen:
```json
{
"base_url": "https://your-workspace-id.mock.pstmn.io",
"schema_url": "https://example.com/schema.json",
"api_name": "E-commerce API"
}
```
## 2. Mock Server Setup Script
**Pre-request Script voor Mock Server:**
```javascript
// Controleer en update mock data bij schema wijzigingen
const schemaUrl = pm.environment.get("schema_url");
const currentSchema = pm.collectionVariables.get("current_schema_hash");
pm.sendRequest(schemaUrl, function (err, response) {
if (!err) {
const newSchema = response.text();
const newHash = btoa(newSchema).substring(0, 16);
if (currentSchema !== newHash) {
console.log("Schema gewijzigd - mock data wordt bijgewerkt");
pm.collectionVariables.set("current_schema_hash", newHash);
pm.collectionVariables.set("schema_updated", true);
}
}
});
```
## 3. Mock Endpoint Examples
**Voor /users endpoint:**
```javascript
// Mock data voor gebruikers
const mockUsers = [
{
"id": 1,
"name": "Jan Jansen",
"email": "jan@voorbeeld.nl",
"role": "admin",
"status": "active",
"createdAt": "2024-01-15T10:30:00Z"
},
{
"id": 2,
"name": "Marie Pieters",
"email": "marie@voorbeeld.nl",
"role": "customer",
"status": "inactive",
"createdAt": "2024-01-20T14:45:00Z"
},
{
"id": 3,
"name": "Peter de Vries",
"email": "peter@voorbeeld.nl",
"role": "moderator",
"status": "active",
"createdAt": "2024-01-25T09:15:00Z"
}
];
// Response volgens schema
const response = {
"status": "success",
"data": mockUsers,
"pagination": {
"page": 1,
"limit": 10,
"total": mockUsers.length
}
};
pm.response.json(response);
```
**Voor /orders endpoint:**
```javascript
// Mock data voor orders
const mockOrders = [
{
"id": "ORD-001",
"userId": 1,
"status": "delivered",
"total": 99.99,
"items": [
{
"productId": "PROD-123",
"quantity": 2,
"price": 49.99
}
],
"createdAt": "2024-01-28T11:20:00Z"
},
{
"id": "ORD-002",
"userId": 2,
"status": "pending",
"total": 149.50,
"items": [
{
"productId": "PROD-456",
"quantity": 1,
"price": 149.50
}
],
"createdAt": "2024-01-29T16:45:00Z"
}
];
const response = {
"status": "success",
"data": mockOrders
};
pm.response.json(response);
```
## 4. Contract Validatie Tests
**Test Script voor alle endpoints:**
```javascript
// Contract validatie tests
pm.test("Status code is 200", function () {
pm.response.to.have.status(200);
});
pm.test("Response heeft correct content-type", function () {
pm.response.to.have.header("Content-Type", "application/json");
});
pm.test("Response voldoet aan basis structuur", function () {
const response = pm.response.json();
pm.expect(response).to.have.property("status");
pm.expect(response).to.have.property("data");
pm.expect(response.status).to.be.oneOf(["success", "error"]);
});
// Schema validatie functie
function validateAgainstSchema(data, schemaRules) {
try {
// Valideer gebruikers response
if (pm.request.url.toString().includes("/users")) {
pm.expect(data.data).to.be.an("array");
data.data.forEach(user => {
pm.expect(user).to.have.keys(["id", "name", "email", "role", "status", "createdAt"]);
pm.expect(user.role).to.be.oneOf(["admin", "customer", "moderator"]);
pm.expect(user.status).to.be.oneOf(["active", "inactive"]);
pm.expect(user.email).to.match(/^[^\s@]+@[^\s@]+\.[^\s@]+$/);
});
}
// Valideer orders response
if (pm.request.url.toString().includes("/orders")) {
pm.expect(data.data).to.be.an("array");
data.data.forEach(order => {
pm.expect(order).to.have.keys(["id", "userId", "status", "total", "items", "createdAt"]);
pm.expect(order.status).to.be.oneOf(["pending", "processing", "shipped", "delivered", "cancelled"]);
pm.expect(order.total).to.be.a("number");
pm.expect(order.items).to.be.an("array");
});
}
return true;
} catch (error) {
console.error("Validatiefout:", error.message);
return false;
}
}
// Voer validatie uit
pm.test("Response voldoet aan contract schema", function () {
const responseData = pm.response.json();
const isValid = validateAgainstSchema(responseData);
pm.expect(isValid).to.be.true;
});
```
## 5. Automatisering Script
**Collection-level Script:**
```javascript
// Pre-request: Schema monitoring
function checkSchemaUpdates() {
const schemaUrl = pm.collectionVariables.get("schema_url");
const lastCheck = pm.collectionVariables.get("last_schema_check");
const now = new Date().toISOString();
// Controleer elke 24 uur op updates
if (!lastCheck || (new Date(now) - new Date(lastCheck)) > 24 * 60 * 60 * 1000) {
pm.sendRequest({
url: schemaUrl,
method: 'GET'
}, function (err, response) {
if (!err && response.code === 200) {
pm.collectionVariables.set("last_schema_check", now);
console.log("Schema check voltooid");
}
});
}
}
// Post-response: Rapportage
function generateValidationReport() {
const testResults = pm.response.json();
const validationReport = {
timestamp: new Date().toISOString(),
endpoint: pm.request.url.toString(),
statusCode: pm.response.code,
testsPassed: pm.info.requestName + " tests voltooid",
schemaCompliant: true // Zou worden bepaald door validatie resultaten
};
console.log("Validatierapport:", JSON.stringify(validationReport, null, 2));
// Log naar Postman console
pm.collectionVariables.set("last_validation_report", JSON.stringify(validationReport));
}
```
## 6. Workflow Stappen
1. **Importeer** dit script in je Postman collection
2. **Stel environment variabelen** in
3. **Maak mock server** aan in Postman
4. **Configureer endpoints** met bovenstaande examples
5. **Voer collection tests** uit via Postman runner of monitors
## 7. Monitoring Setup
**Postman Monitor configuratie:**
- Frequency: Elke 30 minuten
- Environment: Je gekozen environment
- Notifications: Bij test failures
Deze workflow zorgt voor:
- ✅ Automatische mock data bij schema wijzigingen
- ✅ Contract validatie tegen gedefinieerde criteria
- ✅ Status code en response structuur checks
- ✅ Gedetailleerde validatierapporten
- ✅ Ondersteuning voor verschillende gebruikersrollen en statussen
Je kunt deze scripts direct in je Postman collection implementeren en aanpassen naar je specifieke schema requirements.