Zeker! Een goede loggingstrategie voor eenheidstests verbetert de traceerbaarheid, debugging en onderhoudbaarheid aanzienlijk. Hier zijn uitgebreide richtlijnen en best practices, inclusief aanbevelingen voor Python en integratie in je testsuite: ### 1. Doel van logging tijdens eenheidstests - **Traceerbaarheid**: Bied inzicht in testuitvoering en waarom bepaalde paden worden gevolgd. - **Debugging**: Verschaft details over testfouten en onverwacht gedrag. - **Audit en rapportage**: Documenteer specifieke gebeurtenissen of condities. --- ### 2. Welke informatie vastleggen? - **Test identificatie**: - Naam van de testfunctie (`__name__` of testnaam) - Test case of scenario details - **Tijdstempels**: - Exacte datum en tijd van logbericht - **Logniveau**: - INFO, DEBUG, WARNING, ERROR, CRITICAL - **Contextinformatie**: - Invoerparameters - Verwachte versus werkelijke uitkomst - Staat van belangrijke variabelen - Eventuele uitzonderingen met stack traces - **Pre- en postcondities**: - Setup en teardown stappen - **Eventuele foutmeldingen of uitzonderingen** --- ### 3. Structuur van logberichten Gebruik een consistente, gestructureerde opmaak: - **Voorbeeld**: ``` [2024-04-27 14:22:35.123] [DEBUG] [test_login] Invoer: gebruikersnaam='admin', wachtwoord='***' [2024-04-27 14:22:35.124] [INFO] [test_login] Stap 1 voltooid: authenticatie poging gestart [2024-04-27 14:22:35.125] [ERROR] [test_login] Fout bij authenticatie: Onbekende gebruikersnaam ``` - Overweeg gebruik van JSON- of gestructureerde logging voor automatische parsing en analyse. --- ### 4. Beste praktijken voor logbeheer - **Logniveau instellen**: - Gebruik DEBUG tijdens ontwikkeling - Verlaag naar INFO of WARNING voor productie - **Logbestanden**: - Sla logs op in aparte bestanden - Gebruik rotatie om grote bestanden te voorkomen (`RotatingFileHandler`) - **Logformattering**: - Voeg tijdstempel, niveau, testnaam, en bericht toe - **Filtering**: - Filter on relevante niveaus of testonderdelen - **Automatisering**: - Automatiseer het verzamelen en analyseren van logs - Gebruik testframeworks voor integratie (bijv. pytest) met logplugins --- ### 5. Python logging-frameworks en bibliotheken - ** standaard `logging` module**: - Krachtige, flexibel en ingebouwd - Ondersteunt handlers, formattering, filters - **Aanbeveling**: - Configureer `logging` in je setup (bijvoorbeeld in `conftest.py` of test setup) - Voorbeeld: ```python import logging logger = logging.getLogger('mijn_tests') logger.setLevel(logging.DEBUG) handler = logging.FileHandler('test_log.log') formatter = logging.Formatter('%(asctime)s [%(levelname)s] [%(name)s] %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) ``` - **Alternatieven of uitbreidingen**: - **Loguru**: eenvoudiger en meer gebruiksvriendelijk - **structlog**: voor gestructureerde logging in JSON - **pytest-log** of **pytest-logger**: integratie met pytest --- ### 6. Integratie met je testsuite - **In pytest**: - Gebruik fixtures om logconfiguratie te centraliseren - Log tijdens setup, testuitvoering en teardown - Bijvoorbeeld: ```python import pytest import logging @pytest.fixture(autouse=True) def configure_logging(): logging.basicConfig(level=logging.DEBUG, format='%(asctime)s [%(levelname)s] %(name)s %(message)s', filename='pytest.log') ``` - **In unittest**: - Configureer log in `setUp` of `setUpClass` - **In testcode**: - Voeg `logger.debug()`, `logger.info()`, etc. toe waar relevant - Log belangrijke parameters en resultaten --- ### 7. Extra tips - **Vermijd te veel logging in snelle tests**; gebruik DEBUG alleen tijdens ontwikkeling. - **Gebruik assertions** voor validaties, maar log ook uitzonderingen en afwijkingen. - **Test specifieke logberichten** met tools als `caplog` in pytest om te controleren of juiste logs worden gegenereerd. --- ### Samenvatting - Gebruik `logging` voor flexibele logmanagement. - Log relevante details zoals testnaam, tijd, parameters, en resultaten. - Structureer logberichten consistent, bij voorkeur met tijdstempels en niveaus. - Configureer logbestanden met rotatie en filtering. - Integreer logging in je testframework via fixtures of setup-methodes. Met deze aanpak verbeter je de traceerbaarheid, vergemakkelijk je debugging en houd je je tests overzichtelijk en onderhoudbaar.

Zeker, hier is een gedetailleerde richtlijn voor het opzetten van een effectieve loggingstrategie voor je Python eenheidstests: ### 1. **Wat te loggen in eenheidstests** Log strategisch om de testflow te volgen zonder overmatige ruis: - **Teststart/einde**: Testnaam, timestamp, teststatus (geslaagd/mislukt) - **Setup/fixtures**: Configuraties, mock-objecten, testdata - **Kernacties**: Aanroepen naar de te testen code met inputparameters - **Verificaties**: Assertions en verwachte vs. actuele resultaten - **Foutscenario's**: Exceptions, stacktraces bij mislukkingen - **Performance metrics**: Uitvoeringstijd voor trage tests (>100ms) ### 2. **Logberichtstructuur** Gebruik een consistente, machineleesbare structuur: ```python # Gestructureerd voorbeeld { "timestamp": "2023-10-05T14:30:00Z", "level": "INFO", "test_name": "test_user_creation", "module": "tests.user_test", "message": "User created successfully", "data": {"user_id": 123, "username": "testuser"}, "duration_ms": 45 } ``` ### 3. **Aanbevolen logging frameworks** **Standaard logging (Python built-in)** ```python import logging import unittest class TestUser(unittest.TestCase): def setUp(self): logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler("test_results.log"), logging.StreamHandler() ] ) self.logger = logging.getLogger(self.__class__.__name__) def test_user_creation(self): self.logger.info("Starting user creation test") # Test logica self.logger.debug("Mock database called with user_data: %s", user_data) self.assertEqual(result, expected) self.logger.info("Test completed successfully") ``` **Pytest met rich logging** ```python # pytest.ini [pytest] log_cli = true log_cli_level = INFO log_cli_format = %(asctime)s [%(levelname)8s] %(name)s: %(message)s # In tests def test_with_fixture(logger): logger.info("Using fixture-based logging") ``` **Structlog voor gestructureerde logging** ```python import structlog structlog.configure( processors=[ structlog.processors.JSONRenderer() ] ) logger = structlog.get_logger() def test_complex_operation(): logger.info("test_started", operation="complex_calculation", input_data={"values": [1, 2, 3]}) ``` ### 4. **Beste praktijken** **Loglevels strategisch gebruiken:** - `DEBUG`: Gedetailleerde teststappen, mock-interacties - `INFO`: Teststart/einde, belangrijke verificaties - `WARNING**: Onverwachte maar herstelbare situaties - `ERROR**: Testmislukkingen, kritieke fouten **Contextrijke logging:** ```python def test_api_call(self): context = {"test_id": self.id(), "endpoint": "/api/users", "method": "POST"} self.logger.info("API test started", extra=context) try: response = api_client.post("/api/users", data=test_data) self.logger.debug("API response received", extra={"status_code": response.status_code}) except Exception as e: self.logger.error("API call failed", extra={"error": str(e)}, exc_info=True) ``` ### 5. **Geavanceerde integratie** **Pytest plugins:** ```bash pip install pytest-html pytest-json-report ``` ```python # conftest.py import pytest @pytest.fixture(autouse=True) def log_test_execution(request): logger.info(f"Test started: {request.node.name}") yield logger.info(f"Test finished: {request.node.name}") ``` **Aangepaste test runner:** ```python import unittest import logging class LoggedTestRunner(unittest.TextTestRunner): def run(self, test): logger.info(f"Running test suite: {test}") result = super().run(test) logger.info(f"Tests run: {result.testsRun}, Failures: {len(result.failures)}") return result ``` ### 6. **Logbeheer en analyse** **Log routing:** ```python handlers = { "file": logging.FileHandler("tests.log"), "console": logging.StreamHandler(), "json_file": logging.FileHandler("tests.json", mode='w') } # Different formats for different handlers formatters = { "detailed": logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'), "json": JSONFormatter() # Aangepaste JSON formatter } ``` **Log rotation:** ```python from logging.handlers import RotatingFileHandler handler = RotatingFileHandler("test.log", maxBytes=5*1024*1024, backupCount=3) ``` ### 7. **CI/CD integratie** ```yaml # GitHub Actions voorbeeld - name: Run tests with logging run: | pytest --log-level=INFO --log-file=test_results.log - name: Upload test logs uses: actions/upload-artifact@v3 with: name: test-logs path: test_results.log ``` ### **Aanbevelingen:** 1. **Begin eenvoudig** met Python's standaard logging 2. **Voeg structlog toe** voor complexe projecten met JSON logging 3. **Gebruek loglevels** om ruis te filteren 4. **Log consistent** across alle tests 5. **Integreer met CI/CD** voor automatische loganalyse Deze aanpak geeft je uitgebreide traceerbaarheid zonder de testperformance significant te beïnvloeden. Pas het logniveau aan op basis van je debugbehoeften - meer detail tijdens ontwikkeling, minder in productie-achtige omgevingen.