Natuurlijk! Hier is een stapsgewijze aanpak voor het toepassen van Test-Driven Development (TDD) bij jouw Python-webapplicatie: Stap 1: Stel je testomgeving in - Kies een testing framework zoals unittest, pytest of nose. - Zorg dat deze geïnstalleerd is (`pip install pytest` bijvoorbeeld). - Maak een map voor je tests, bijvoorbeeld `tests/`. Stap 2: Identificeer een functionaliteit - Kies een klein onderdeel van je webapp, bijvoorbeeld een functie die gebruikersgegevens valideert. Stap 3: Schrijf een eerste, simpele test - Schrijf een test die faalt omdat de functionaliteit nog niet bestaat. Voorbeeld met pytest: ```python # tests/test_validatie.py def test_gebruikersnaam_validatie(): assert validate_username("jan") == True ``` Deze test faalt nu omdat `validate_username` nog niet bestaat. Stap 4: Implementeer minimale code om de test te laten slagen ```python # main.py def validate_username(username): return len(username) >= 3 ``` Stap 5: Voer de test uit en refactor indien nodig ```bash pytest tests/test_validatie.py ``` Stap 6: Herhaal voor nieuwe functionaliteiten - Schrijf eerst een test voor de volgende functionaliteit. - Maak de test failend, implementeer code, en refactor indien nodig. Voorbeeld van een test voor ongeldige input: ```python def test_gebruikersnaam_te_kort(): assert validate_username("jo") == False ``` Stap 7: Voorkom regressies - Zorg dat je alle tests automatisch laat draaien bij elke verandering. - Gebruik Continuous Integration (CI) tools zoals GitHub Actions of Travis CI. - Voeg tests toe voor edge-cases en foutscenario's. - Houd je tests klein en overzichtelijk. - Gebruik mocks/stubs voor externe afhankelijkheden. Stap 8: Documentatie en onderhoud - Documenteer je tests en waarom ze bestaan. - Voeg nieuwe tests toe bij elke nieuwe feature of bugfix. - Verwijder oude of overbodige tests niet zonder goede reden. Door deze cyclus van "Red-Green-Refactor" consistent toe te passen, ontwikkel je stabiele code die je regressietests beschermen. Veel succes!

Zeker! Hier is een stapsgewijze handleiding voor het opzetten van een TDD-workflow voor je Python-webapplicatie: ## Stap 1: Setup Testomgeving ```bash # Installeer pytest (aanbevolen voor Python TDD) pip install pytest pytest-cov # Projectstructuur my_webapp/ ├── src/ │ └── my_webapp/ │ ├── __init__.py │ └── app.py ├── tests/ │ ├── __init__.py │ └── test_app.py └── requirements.txt ``` ## Stap 2: TDD Cyclus - Rood, Groen, Refactor ### Voorbeeld 1: User Model **Test eerst (Rood):** ```python # tests/test_user.py import pytest from src.my_webapp.models import User def test_user_creation(): """Test dat een gebruiker correct wordt aangemaakt""" user = User("test@example.com", "wachtwoord123") assert user.email == "test@example.com" assert user.check_password("wachtwoord123") is True def test_invalid_email(): """Test ongeldig email formaat""" with pytest.raises(ValueError): User("invalid-email", "wachtwoord123") ``` **Implementeer daarna (Groen):** ```python # src/my_webapp/models.py import re class User: def __init__(self, email, password): if not self._is_valid_email(email): raise ValueError("Ongeldig email formaat") self.email = email self._password = password def _is_valid_email(self, email): pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' return re.match(pattern, email) is not None def check_password(self, password): return self._password == password ``` ### Voorbeeld 2: API Endpoint **Test eerst:** ```python # tests/test_api.py def test_get_users_empty_db(client): """Test GET /users met lege database""" response = client.get('/users') assert response.status_code == 200 assert response.json == [] def test_create_user(client): """Test POST /users""" user_data = {"email": "test@example.com", "password": "secret"} response = client.post('/users', json=user_data) assert response.status_code == 201 assert "id" in response.json ``` ## Stap 3: Test Runner Setup ```bash # Voer tests uit pytest -v --cov=src # Met coverage report pytest --cov=src --cov-report=html # Voor continuous testing pytest-watch # of gebruik ptpython ``` ## Stap 4: Regressiepreventie Strategie ### 1. CI/CD Integratie ```yaml # .github/workflows/test.yml name: Python Tests on: [push, pull_request] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Setup Python uses: actions/setup-python@v2 - name: Install dependencies run: pip install -r requirements.txt - name: Run tests run: pytest --cov=src --cov-fail-under=80 ``` ### 2. Git Hooks voor Pre-commit ```bash # .git/hooks/pre-commit #!/bin/bash pytest tests/ && \ python -m pylint src/ && \ echo "All checks passed!" ``` ### 3. Boundary Testing Voorbeelden ```python def test_user_password_hashing(): """Test edge cases voor wachtwoordvalidatie""" # Leeg wachtwoord with pytest.raises(ValueError): User("test@example.com", "") # Heel lang wachtwoord long_pw = "a" * 1000 user = User("test@example.com", long_pw) assert user.check_password(long_pw) ``` ## Stap 5: Test Organisatie ```python # tests/conftest.py (shared fixtures) import pytest from src.my_webapp import create_app @pytest.fixture def client(): app = create_app(testing=True) with app.test_client() as client: yield client @pytest.fixture def db_session(): # Database setup/teardown session = create_test_session() yield session session.rollback() ``` ## Best Practices: 1. **Eén assert per test** (meestal) 2. **Descriptieve testnamen** 3. **Test isolation** (gebruik fixtures voor setup/teardown) 4. **Run tests voor elke commit** 5. **Coverage minimum van 80%** ```bash # Dagelijkse workflow: pytest -x # stop bij eerste failure pytest --lf # run alleen failed tests pytest -k "test_user" # run specifieke tests ``` Start met kleine units (models, utils) en bouw langzaam naar complexere integratietests. Succes met je TDD-reis! 🚀