Help me bij het implementeren van unittests voor mijn API-eindpunten
description
Door deze unittests te implementeren, zorg je ervoor dat je API robuust, betrouwbaar is en voldoet aan de verwachte gedragingen, wat bugs aanzienlijk kan verminderen en de gebruikers tevredenheid kan verbeteren.
prompt
try_prompt
Ik werk aan een API en heb hulp nodig bij het maken van uitgebreide unittests voor mijn API-eindpunten. Geef voorbeelden van hoe verschille ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier zijn voorbeelden van hoe je uitgebreide unittests kunt maken voor jouw API-eindpunten in bijvoorbeeld Python met behulp van unittest en requests of een testclient zoals Flask's testclient. Ik ga ervan uit dat je een Flask-achtige setup hebt.
### Voorbeeld: Unittests voor GET /gebruikers
```python
import unittest
from jouw_app import app # import je Flask app
class GebruikersApiTestCase(unittest.TestCase):
def setUp(self):
self.client = app.test_client()
def test_get_gebruikers_status_code(self):
response = self.client.get('/gebruikers')
self.assertEqual(response.status_code, 200)
def test_get_gebruikers_response_format(self):
response = self.client.get('/gebruikers')
data = response.get_json()
self.assertIsInstance(data, list) # verwacht een lijst van gebruikers
# Optioneel: controleer de structuur van een gebruiker
if data:
gebruiker = data[0]
self.assertIn('id', gebruiker)
self.assertIn('naam', gebruiker)
self.assertIn('email', gebruiker)
def test_get_gebruikers_filters(self):
# Als je queryparameters hebt, test ze dan
response = self.client.get('/gebruikers?naam=Jan')
data = response.get_json()
for gebruiker in data:
self.assertIn('Jan', gebruiker['naam'])
```
### Voorbeeld: Unittests voor POST /gebruikers
```python
def test_post_gebruiker_success(self):
nieuwe_gebruiker = {
'naam': 'Jan Jansen',
'email': 'jan@example.com'
}
response = self.client.post('/gebruikers', json=nieuwe_gebruiker)
self.assertEqual(response.status_code, 201) # aangenomen dat 201 wordt teruggegeven bij creatie
data = response.get_json()
self.assertIn('id', data)
self.assertEqual(data['naam'], 'Jan Jansen')
self.assertEqual(data['email'], 'jan@example.com')
def test_post_gebruiker_missing_fields(self):
# Test met ontbrekende verplichte velden
response = self.client.post('/gebruikers', json={'naam': 'Jan'})
self.assertEqual(response.status_code, 400)
data = response.get_json()
self.assertIn('error', data)
def test_post_gebruiker_invalid_json(self):
response = self.client.post('/gebruikers', data='not a json', content_type='application/json')
self.assertEqual(response.status_code, 400)
data = response.get_json()
self.assertIn('error', data)
```
### Samenvatting:
- Test verschillende HTTP-methoden (GET, POST).
- Controleer response status codes.
- Valideer responseformaten en inhoud.
- Test verzoekparameters en body-inhoud.
- Test foutgevallen zoals ontbrekende velden of ongeldige JSON.
Wil je dat ik ook voorbeelden geef voor andere methoden of meer complexe scenario's?
provider: deepseek
model: deepseek-chat
Hier zijn uitgebreide unittest-voorbeelden voor je API-eindpunten met Python en de `unittest` bibliotheek:
## Basis Test Setup
```python
import unittest
import json
from mijn_api_app import app # Je Flask/FastAPI applicatie
class TestGebruikersAPI(unittest.TestCase):
def setUp(self):
self.app = app.test_client()
self.app.testing = True
def tearDown(self):
# Opruimen testdata indien nodig
pass
```
## GET /gebruikers Tests
```python
def test_get_gebruikers_success(self):
"""Test succesvol ophalen van gebruikerslijst"""
response = self.app.get('/gebruikers')
# Status code validatie
self.assertEqual(response.status_code, 200)
# Content type validatie
self.assertEqual(response.content_type, 'application/json')
# Response data validatie
data = json.loads(response.data)
# Controleren of data een lijst is
self.assertIsInstance(data, list)
# Als er gebruikers zijn, valideer de structuur
if len(data) > 0:
gebruiker = data[0]
self.assertIn('id', gebruiker)
self.assertIn('naam', gebruiker)
self.assertIn('email', gebruiker)
self.assertIsInstance(gebruiker['id'], int)
self.assertIsInstance(gebruiker['naam'], str)
def test_get_gebruikers_with_query_parameters(self):
"""Test GET met query parameters"""
response = self.app.get('/gebruikers?pagina=1&limiet=10')
self.assertEqual(response.status_code, 200)
data = json.loads(response.data)
self.assertIsInstance(data, list)
def test_get_gebruikers_empty(self):
"""Test GET wanneer er geen gebruikers zijn"""
# Mogelijk eerst alle testdata opruimen
response = self.app.get('/gebruikers')
self.assertEqual(response.status_code, 200)
data = json.loads(response.data)
self.assertEqual(data, [])
```
## POST /gebruikers Tests
```python
def test_post_gebruiker_success(self):
"""Test succesvol aanmaken van een gebruiker"""
nieuwe_gebruiker = {
'naam': 'Jan Jansen',
'email': 'jan@voorbeeld.nl',
'leeftijd': 30
}
response = self.app.post(
'/gebruikers',
data=json.dumps(nieuwe_gebruiker),
content_type='application/json'
)
# Status code validatie
self.assertEqual(response.status_code, 201) # 201 Created
# Response validatie
data = json.loads(response.data)
self.assertIn('id', data)
self.assertEqual(data['naam'], nieuwe_gebruiker['naam'])
self.assertEqual(data['email'], nieuwe_gebruiker['email'])
def test_post_gebruiker_missing_required_fields(self):
"""Test POST met ontbrekende verplichte velden"""
incomplete_gebruiker = {
'naam': 'Jan Jansen'
# email ontbreekt
}
response = self.app.post(
'/gebruikers',
data=json.dumps(incomplete_gebruiker),
content_type='application/json'
)
self.assertEqual(response.status_code, 400) # Bad Request
data = json.loads(response.data)
self.assertIn('fout', data)
self.assertIn('email', data['fout'])
def test_post_gebruiker_invalid_email(self):
"""Test POST met ongeldig email formaat"""
gebruiker_met_ongeldige_email = {
'naam': 'Jan Jansen',
'email': 'ongeldig-email'
}
response = self.app.post(
'/gebruikers',
data=json.dumps(gebruiker_met_ongeldige_email),
content_type='application/json'
)
self.assertEqual(response.status_code, 400)
data = json.loads(response.data)
self.assertIn('fout', data)
def test_post_gebruiker_duplicate_email(self):
"""Test POST met bestaand email adres"""
bestaande_gebruiker = {
'naam': 'Piet Pietersen',
'email': 'bestaat@voorbeeld.nl'
}
# Eerste keer zou moeten slagen
response1 = self.app.post(
'/gebruikers',
data=json.dumps(bestaande_gebruiker),
content_type='application/json'
)
self.assertEqual(response1.status_code, 201)
# Tweede keer zou moeten falen
response2 = self.app.post(
'/gebruikers',
data=json.dumps(bestaande_gebruiker),
content_type='application/json'
)
self.assertEqual(response2.status_code, 409) # Conflict
```
## Geavanceerde Tests
```python
def test_response_headers(self):
"""Test response headers"""
response = self.app.get('/gebruikers')
self.assertIn('Content-Type', response.headers)
self.assertEqual(response.headers['Content-Type'], 'application/json')
self.assertIn('X-Total-Count', response.headers) # Indien van toepassing
def test_error_handling(self):
"""Test foutafhandeling voor ongeldige routes"""
response = self.app.get('/ongeldige-route')
self.assertEqual(response.status_code, 404)
data = json.loads(response.data)
self.assertIn('fout', data)
def test_post_with_different_content_types(self):
"""Test POST met verschillende content types"""
gebruiker_data = {'naam': 'Test', 'email': 'test@voorbeeld.nl'}
# Test met application/json
response1 = self.app.post(
'/gebruikers',
data=json.dumps(gebruiker_data),
content_type='application/json'
)
self.assertEqual(response1.status_code, 201)
# Test met ongeldig content type
response2 = self.app.post(
'/gebruikers',
data=gebruiker_data,
content_type='text/plain'
)
self.assertEqual(response2.status_code, 415) # Unsupported Media Type
```
## Integration Test
```python
def test_full_gebruiker_lifecycle(self):
"""Volledige levenscyclus test van een gebruiker"""
# Maak gebruiker aan
nieuwe_gebruiker = {
'naam': 'Marie Janssen',
'email': 'marie@voorbeeld.nl'
}
post_response = self.app.post(
'/gebruikers',
data=json.dumps(nieuwe_gebruiker),
content_type='application/json'
)
self.assertEqual(post_response.status_code, 201)
# Verifieer dat gebruiker in de lijst staat
get_response = self.app.get('/gebruikers')
self.assertEqual(get_response.status_code, 200)
gebruikers = json.loads(get_response.data)
self.assertTrue(any(g['email'] == 'marie@voorbeeld.nl' for g in gebruikers))
```
## Test Uitvoering
```python
if __name__ == '__main__':
unittest.main()
```
## Belangrijke Test Principes:
1. **Isolatie**: Elke test moet onafhankelijk zijn
2. **Opruimen**: Verwijder testdata na elke test
3. **Edge Cases**: Test grenswaarden en foutsituaties
4. **Response Validatie**: Controleer status codes, headers en data structuur
5. **Performance**: Test response tijden voor kritieke endpoints
Pas deze voorbeelden aan naar je specifieke API-implementatie en voeg meer tests toe voor extra functionaliteit zoals authenticatie, autorisatie, en complexe query parameters.

