Natuurlijk! Hier is een voorbeeld van hoe je een eenvoudige mock API kunt opzetten in Node.js met Express, die de basisfuncties simuleert en geschikt is voor belastbaarheidstests. Daarnaast geef ik suggesties voor het simuleren van piekbelasting en het genereren van rapporten. ### 1. Basis Mock API in Node.js (Express) ```javascript const express = require('express'); const app = express(); const port = 3000; app.use(express.json()); // Simulatie van gebruikerssessies const sessions = new Map(); // /login endpoint app.post('/login', (req, res) => { const { username, password } = req.body; // Simuleer authenticatievertraging setTimeout(() => { if (username && password) { const sessionId = Math.random().toString(36).substring(2); sessions.set(sessionId, { username }); res.json({ sessionId }); } else { res.status(400).json({ error: 'Ongeldige gegevens' }); } }, Math.random() * 200); // Reactietijd tussen 0-200ms }); // /userdata endpoint app.get('/userdata', (req, res) => { const sessionId = req.headers['authorization']; // Simuleer dataverwerking setTimeout(() => { if (sessions.has(sessionId)) { res.json({ user: sessions.get(sessionId).username, data: "Voorbeeldgegevens" }); } else { res.status(401).json({ error: 'Niet geautoriseerd' }); } }, Math.random() * 150); // Reactietijd tussen 0-150ms }); // /logout endpoint app.post('/logout', (req, res) => { const sessionId = req.headers['authorization']; setTimeout(() => { if (sessions.delete(sessionId)) { res.json({ message: 'Uitgelogd' }); } else { res.status(400).json({ error: 'Geen actieve sessie' }); } }, Math.random() * 100); // Reactietijd tussen 0-100ms }); app.listen(port, () => { console.log(`Mock API draait op http://localhost:${port}`); }); ``` ### 2. Belastbaarheidstest instellen Gebruik tools zoals **Apache JMeter**, **Gatling** of **k6** om 100 gelijktijdige gebruikers te simuleren en 500 verzoeken per minuut te genereren. Bijvoorbeeld, met **k6**: ```javascript import http from 'k6/http'; import { check, sleep } from 'k6'; export let options = { vus: 100, duration: '1m', rps: 500, }; export default function () { // Login let loginRes = http.post('http://localhost:3000/login', { username: 'user', password: 'pass' }); check(loginRes, { 'logged in': (r) => r.status === 200 }); let sessionId = loginRes.json('sessionId'); // Fetch userdata let headers = { 'Authorization': sessionId }; let userRes = http.get('http://localhost:3000/userdata', { headers: headers }); check(userRes, { 'userdata received': (r) => r.status === 200 }); // Logout let logoutRes = http.post('http://localhost:3000/logout', null, { headers: headers }); check(logoutRes, { 'logged out': (r) => r.status === 200 }); sleep(1); } ``` ### 3. Suggesties voor piekbelasting simuleren - **Graduele stijging**: Begin met een lagere belasting en verhoog langzaam het aantal gebruikers of verzoeken om de prestaties onder verschillende belastingniveaus te testen. - **Burst tests**: Voer korte, intensieve pieken uit waarbij je plotseling het aantal gebruikers of verzoeken verhoogt, bijvoorbeeld door in korte tijd 200-300 gebruikers te simuleren. - **Randomisatie**: Voeg willekeur toe aan de frequentie en het aantal verzoeken om realistischere belastingspiegels te krijgen. ### 4. Rapportage en prestatieanalyse - **Verzamel statistieken**: Log reactietijden, foutpercentages en doorlooptijden per verzoek. - **Gebruik analysetools**: Exporteer gegevens naar CSV of JSON en gebruik tools zoals Excel, Grafana of Kibana voor visualisaties. - **Automatisch rapport genereren**: - Scripts (bijv. in Python of Bash) die logs parseren en samenvattingen maken. - Integratie met CI/CD pipelines om automatische rapporten te genereren na elke test. ### 5. Aanvullende tips - Voeg realistische vertragingen toe om netwerkvertragingen te simuleren. - Gebruik een mock data generator voor variatie in gebruikersgegevens. - Overweeg het gebruik van een mock API-framework zoals **json-server** of **Mockoon** voor snellere setup. --- Heeft u verdere hulp nodig bij het implementeren of configureren van de tests?

Absoluut! Hier is een complete handleiding in het Nederlands voor het opzetten van een mock API met geautomatiseerde belastingstests. ### 1. Keuze van Tools & Technologieën Voor een robuuste en realistische mock API raad ik de volgende stack aan: * **Mock API Framework:** **Node.js met Express.js**. Lichtgewicht, perfect voor API's en een enorme ecosystem. * **Belastingstest Tool:** **k6 van Grafana Labs**. Specifiek ontworpen voor performance testing, scriptbaar in JavaScript, en meet rechtstreeks de gewenste metrics (reactietijd, foutpercentage). * **Test Data Generatie:** **Faker.js** bibliotheek om realistische mock gebruikersdata te genereren. * **Rapportage:** k6 genereert uitgebreide tekstrapporten, maar voor visuele dashboards kun je de resultaten naar **Grafana Cloud** of een lokale **Grafana** instance sturen. --- ### 2. Opzet van de Mock API (server.js) Eerst installeren: `npm init -y` en dan `npm install express faker` ```javascript // server.js const express = require('express'); const faker = require('faker'); const app = express(); app.use(express.json()); // Simpele "database" voor sessies en gebruikers let sessions = new Map(); // Slaat sessietokens op gekoppeld aan userID let users = new Map(); // Slaat gebruikersdata op // Genereer initieel 500 testgebruikers for (let i = 0; i < 500; i++) { let userId = faker.datatype.uuid(); users.set(userId, { id: userId, username: faker.internet.userName(), email: faker.internet.email(), profile: { name: faker.name.findName(), address: faker.address.streetAddress() } }); } // LOGIN Eindpunt app.post('/login', (req, res) => { // Simuleer verwerkingstijd (50ms - 150ms) const delay = Math.floor(Math.random() * 100) + 50; setTimeout(() => { // Simuleer een 5% kans op een authenticatiefout if (Math.random() < 0.05) { return res.status(401).json({ error: 'Ongeldige inloggegevens' }); } // Pak een willekeurige gebruiker uit onze "database" const userArray = Array.from(users.values()); const randomUser = userArray[Math.floor(Math.random() * userArray.length)]; // Genereer een sessietoken const authToken = faker.datatype.uuid(); // Sla de sessie op sessions.set(authToken, randomUser.id); // Stuur succes response res.status(200).json({ message: 'Login succesvol', token: authToken, user: { id: randomUser.id, username: randomUser.username } }); }, delay); }); // USERDATA Eindpunt (Beveiligd) app.get('/userdata', (req, res) => { const token = req.headers.authorization; if (!token || !sessions.has(token)) { return res.status(403).json({ error: 'Ongeldige of ontbrekende token' }); } const userId = sessions.get(token); const userData = users.get(userId); // Simuleer verwerkingstijd voor data ophalen (20ms - 100ms) const delay = Math.floor(Math.random() * 80) + 20; setTimeout(() => { res.status(200).json(userData); }, delay); }); // LOGOUT Eindpunt app.post('/logout', (req, res) => { const token = req.headers.authorization; if (token && sessions.has(token)) { sessions.delete(token); } res.status(200).json({ message: 'Uitloggen succesvol' }); }); const PORT = process.env.PORT || 3000; app.listen(PORT, () => console.log(`Mock API server draait op poort ${PORT}`)); ``` Start de server met: `node server.js` --- ### 3. Belastingstest Script (k6_test.js) Installeer k6: [Volg de officiële installatiehandleiding](https://grafana.com/docs/k6/latest/get-started/installation/). ```javascript // k6_test.js import http from 'k6/http'; import { check, sleep } from 'k6'; import { Trend, Rate } from 'k6/metrics'; // Definieer aangepaste metrics let loginResponseTime = new Trend('login_response_time'); let userDataResponseTime = new Trend('userdata_response_time'); let errorRate = new Rate('errors'); // Testopties - HIER STEL JE JE PARAMETERS IN export let options = { scenarios: { constant_request_rate: { executor: 'constant-arrival-rate', rate: 500, // 500 verzoeken per minuut (RPS) timeUnit: '1m', duration: '5m', // Duur van de test: 5 minuten preAllocatedVUs: 50, // Aantal VUs om vooraf klaar te zetten maxVUs: 100, // Maximaal 100 gelijktijdige gebruikers (VUs) }, }, thresholds: { 'errors': ['rate<0.1'], // Drempel: Foutpercentage moet onder de 10% blijven 'http_req_duration': ['p(95)<500'], // 95% van de verzoeken moet onder 500ms zijn }, }; // Globale variabele om tokens tussen iteraties op te slaan let authToken = null; export default function () { const BASE_URL = 'http://localhost:3000'; // 1. LOGIN let loginPayload = JSON.stringify({ // Faker data wordt gegenereerd door de server, dus payload is simpel username: 'testuser', password: 'testpass' }); let loginParams = { headers: { 'Content-Type': 'application/json' }, }; let loginRes = http.post(`${BASE_URL}/login`, loginPayload, loginParams); // Check of login succesvol was en sla token op let loginCheck = check(loginRes, { 'login successful': (r) => r.status === 200, }); if (loginCheck) { authToken = loginRes.json('token'); loginResponseTime.add(loginRes.timings.duration); // Log response time } else { errorRate.add(1); // Log een fout } // Korte pauze tussen requests sleep(0.1); // 2. USERDATA - Alleen uitvoeren als login succesvol was if (authToken) { let dataParams = { headers: { 'Authorization': authToken }, }; let dataRes = http.get(`${BASE_URL}/userdata`, dataParams); let dataCheck = check(dataRes, { 'userdata successful': (r) => r.status === 200, }); if (dataCheck) { userDataResponseTime.add(dataRes.timings.duration); } else { errorRate.add(1); } } // 3. LOGOUT - Uitloggen in een subset van de iteraties (bijv. 20%) if (authToken && Math.random() < 0.2) { let logoutParams = { headers: { 'Authorization': authToken }, }; http.post(`${BASE_URL}/logout`, null, logoutParams); authToken = null; // Reset token voor de volgende iteratie } } ``` Voer de test uit met: `k6 run k6_test.js` --- ### 4. Simuleren van Piekbelasting Het `constant-arrival-rate` scenario in het script hierboven houdt een *constante* belasting aan. Voor **piekbelasting** zijn andere k6 executors perfect: 1. **`ramping-arrival-rate` executor:** Laat je de belasting geleidelijk op- en afbouwen om een piek na te bootsen. ```javascript scenarios: { spike_test: { executor: 'ramping-arrival-rate', stages: [ { duration: '2m', target: 500 }, // Normale belasting (500 RPM) { duration: '1m', target: 2000 }, // PIEK (2000 RPM) { duration: '2m', target: 500 }, // Terug naar normaal ], preAllocatedVUs: 50, maxVUs: 200, // Zorg voor meer VUs voor de piek }, } ``` 2. **`ramping-vus` executor:** Hiermee simuleer je een geleidelijk toenemend aantal gelijktijdige gebruikers tot een piek. --- ### 5. Genereren van Rapportages k6 heeft uitstekende rapportagemogelijkheden: 1. **Standaard Terminal Output:** Na afloop van de test krijg je een duidelijk overzicht in de terminal met alle metrics (avg, min, max, p95, etc.) en of de thresholds zijn gehaald. 2. **JSON Export:** Sla de ruwe data op voor verdere analyse. ```bash k6 run --out json=test_results.json k6_test.js ``` 3. **Grafana Dashboards (Aanbevolen):** Integreer k6 met Grafana voor visueel rijke, historische rapporten. * **Makkelijk:** Stuur resultaten naar **Grafana Cloud** (gratis tier beschikbaar). Voeg `--out cloud` toe aan je commando en volg de setup instructies. * **Lokaal:** Draai InfluxDB + Grafana lokaal via Docker en stuur data daarheen met `--out influxdb=http://localhost:8086/k6`. 4. **HTML Rapport:** Gebruik community tools zoals `k6-reporter` om een mooi HTML-rapport te genereren vanuit de JSON data. ### Samenvatting van volgende stappen: 1. Installeer Node.js en k6. 2. Sla de `server.js` code op en start hem (`node server.js`). 3. Sla het `k6_test.js` script op en pas de parameters aan (bv. `rate`, `duration`). 4. Voer het testscript uit vanaf een **andere terminal** (`k6 run k6_test.js`). 5. Analyseer de output in de terminal. 6. Experimenteer met verschillende `scenarios` voor piekbelasting en exportopties voor rapportage. Deze setup geeft je een zeer realistisch en controleerbaar testplatform voor je authenticatie-API. Succes!