Natuurlijk! Een parametrische teststrategie in Python kan je helpen om meerdere invoerwaarden en verwachte uitkomsten efficiënt te testen, wat de testdekking verbetert en de onderhoudbaarheid vermindert. Een veelgebruikte aanpak is het gebruik van frameworks zoals `pytest` met de `@pytest.mark.parametrize` decorator. Hier is een voorbeeld van hoe je dit kunt aanpakken: ```python import pytest @pytest.mark.parametrize( "input_value, verwachte_uitkomst", [ (2, 4), (3, 9), (4, 16), (0, 0), (-1, 1), ] ) def test_square(input_value, verwachte_uitkomst): resultaat = input_value ** 2 assert resultaat == verwachte_uitkomst ``` **Uitleg:** - De decorator `@pytest.mark.parametrize` neemt twee parameters: de namen van de invoerwaarden (hier `input_value` en `verwachte_uitkomst`) en een lijst van tuples met de verschillende testcases. - Elke tuple vertegenwoordigt een set invoer en de verwachte output. - De testfunctie wordt voor elke tuple uitgevoerd, waardoor je met één stuk code meerdere scenario’s test. **Voordelen van deze aanpak:** 1. **Verbeterde testefficiëntie:** Je hoeft niet voor elke input een aparte testfunctie te schrijven. Eén parametrische test dekt meerdere scenarios. 2. **Betere testdekking:** Door verschillende invoerwaarden te testen, vang je meer randgevallen en potentiële bugs. 3. **Gemakkelijke uitbreiding:** Nieuwe testcases voeg je simpelweg toe aan de lijst zonder de bestaande teststructuur te wijzigen. 4. **Onderhoudbaarheid:** Minder code duplication, overzichtelijkere tests en eenvoudige updates. Wil je meer complexe voorbeelden zien of hulp bij het integreren in jouw project?

Zeker! Ik help je graag bij het ontwerpen van een parametrische teststrategie in Python. Hier is een complete uitleg met voorbeelden. ## Wat zijn parametrische tests? Parametrische tests laten je meerdere testgevallen uitvoeren met verschillende inputwaarden en verwachte outputs via één testfunctie. Dit elimineert codeherhaling en verbetert de testdekking. ## Basisvoorbeeld met `unittest` ```python import unittest def is_even(number): return number % 2 == 0 class TestEvenNumbers(unittest.TestCase): def test_even_numbers(self): test_cases = [ (2, True), (4, True), (6, True), (1, False), (3, False), (5, False), (0, True) ] for input_num, expected in test_cases: with self.subTest(input=input_num, expected=expected): self.assertEqual(is_even(input_num), expected) if __name__ == '__main__': unittest.main() ``` ## Geavanceerd voorbeeld met `pytest` en `@pytest.mark.parametrize` ```python import pytest def divide(a, b): if b == 0: raise ValueError("Cannot divide by zero") return a / b # Eenvoudige parametrische test @pytest.mark.parametrize("a, b, expected", [ (10, 2, 5), (15, 3, 5), (100, 10, 10), (7, 2, 3.5) ]) def test_divide_normal_cases(a, b, expected): assert divide(a, b) == expected # Test met exception handling @pytest.mark.parametrize("a, b, expected_exception", [ (10, 0, ValueError), (5, 0, ValueError) ]) def test_divide_edge_cases(a, b, expected_exception): with pytest.raises(expected_exception): divide(a, b) ``` ## Complex voorbeeld met meerdere parameters ```python import pytest def calculate_discount(price, customer_type, is_holiday): discount = 0 if customer_type == "regular": discount = 0.1 elif customer_type == "vip": discount = 0.2 elif customer_type == "employee": discount = 0.3 if is_holiday: discount += 0.05 return price * (1 - discount) @pytest.mark.parametrize("price, customer_type, is_holiday, expected", [ (100, "regular", False, 90), # 10% korting (100, "regular", True, 85), # 15% korting (feestdag) (100, "vip", False, 80), # 20% korting (100, "vip", True, 75), # 25% korting (100, "employee", False, 70), # 30% korting (100, "employee", True, 65), # 35% korting (200, "vip", False, 160), # Andere prijs ]) def test_calculate_discount(price, customer_type, is_holiday, expected): result = calculate_discount(price, customer_type, is_holiday) assert result == expected ``` ## Teststrategie en best practices ### 1. Testdata organisatie ```python # Externe testdata (bijv. in JSON) test_data = [ {"input": {"a": 1, "b": 2}, "expected": 3}, {"input": {"a": -1, "b": 1}, "expected": 0}, {"input": {"a": 0, "b": 0}, "expected": 0} ] @pytest.mark.parametrize("data", test_data) def test_with_external_data(data): result = add(data["input"]["a"], data["input"]["b"]) assert result == data["expected"] ``` ### 2. Edge cases en grenswaarden ```python @pytest.mark.parametrize("input_value, expected", [ (0, True), # Nul waarde (-1, False), # Negatieve waarde (1, True), # Kleine positieve waarde (999999, True), # Grote waarde ("text", False), # Verkeerd type (None, False) # None waarde ]) def test_edge_cases(input_value, expected): assert is_positive_number(input_value) == expected ``` ## Voordelen van parametrische tests 1. **Verbeterde testdekking**: Meer inputcombinaties met minder code 2. **Minder onderhoud**: Wijzigingen in één centrale plaats 3. **Betere leesbaarheid**: Duidelijke mapping tussen input en expected output 4. **Snellere ontwikkeling**: Minder tijd besteed aan boilerplate code 5. **Comprehensieve testing**: Eenvoudig edge cases en grenswaarden testen ## Aanbevolen packages - **pytest**: Meest populaire keuze voor parametrische tests - **unittest**: Standaard Python library - **hypothesis**: Voor property-based testing - **parameterized**: Voor unittest-style parametrisatie ```bash pip install pytest hypothesis ``` Deze strategie zal je testdekking aanzienlijk verbeteren en het onderhoud van je testsuite vereenvoudigen!