Een leeftijdsveld dat 18 tot 60 jaar accepteert, heeft een enorm aantal mogelijke invoermogelijkheden, zodra je negatieven, grote getallen, tekst en spaties telt. Niemand kan ze allemaal proberen. Equivalentiepartitionering lost dit op door invoer te groeperen die de software op dezelfde manier moet behandelen, en vervolgens één waarde uit elke groep te testen.

Het is een van de eerste testontwerptechnieken die elke tester zou moeten leren. In deze handleiding werken we er stap voor stap doorheen en testen we één voorbeeld in Python. We hebben die code uitgevoerd op Python 3.13 en de uitvoer ervan is inbegrepen. De onderstaande wachtwoord- en couponregels zijn illustratieve voorbeelden en niet afkomstig van een echt systeem.

Wat is equivalentiepartitionering?

Equivalentiepartitionering, ook wel equivalentieklassepartitionering (ECP) genoemd, is een black box-testontwerptechniek. Het verdeelt de mogelijke invoer van een feature in partities of klassen. Er wordt verwacht dat elke waarde binnen een partitie hetzelfde soort gedrag produceert.

Omdat u de code niet hoeft te zien, kunt u deze vanuit een vereiste direct toepassen. Lees voor meer informatie over deze manier van testen black box- versus white box-testen.

Waarom het werkt

De techniek berust op één aanname: als één waarde in een partitie een bug vindt, zullen de anderen in die partitie deze waarschijnlijk ook vinden. En als één waarde slaagt, zullen de andere waarschijnlijk ook slagen. Het testen van 25, 26 en 27 op volwassen leeftijd zal u waarschijnlijk niets vertellen wat het testen van 25 alleen niet deed.

Het is echter een aanname en geen garantie. Software kan speciale gevallen verborgen hebben binnen een partitie, een beperking waar we later op terugkomen.

Zo doe je dat in vijf stappen

1. Lees de vereiste en identificeer de invoer en de bijbehorende regels.
2. Zoek de geldige partities, dit zijn de groepen waarden die moeten worden geaccepteerd, en kijk of verschillende bereiken zich verschillend gedragen.
3. Zoek de ongeldige partities, inclusief waarden die te laag, te hoog, het verkeerde type en blanco zijn.
4. Kies één representatieve waarde uit elke partitie, meestal ergens in het midden.
5. Schrijf voor elk het verwachte resultaat op, zoals bij elke goede testcase.

Uitgewerkt voorbeeld: een leeftijdsveld

Vereiste: Gebruikers van 18 tot 60 jaar kunnen zich registreren.

Vijf tests geven u dekking voor elk gedrag in de vereiste. Veel tutorials stoppen bij de eerste drie rijen, maar de laatste twee zijn degene die echte gebruikers per ongeluk activeren. U kunt ook rijen voor negatieve getallen of decimalen toevoegen, als deze redelijkerwijs anders kunnen worden verwerkt.

Het testen in code

Hier is die regel als een functie, met één eenheidstest per partitie, met behulp van de ingebouwde unittest van Python:

import unittest

def can_register(age):
    if not isinstance(age, int) or isinstance(age, bool):
        raise TypeError("age must be a whole number")
    return 18 <= age <= 60

class EquivalenceTests(unittest.TestCase):
    def test_valid_partition(self):
        self.assertTrue(can_register(35))

    def test_too_young_partition(self):
        self.assertFalse(can_register(10))

    def test_too_old_partition(self):
        self.assertFalse(can_register(75))

    def test_wrong_type_partition(self):
        with self.assertRaises(TypeError):
            can_register("abc")

Onze run ging voorbij:

test_too_old_partition ... ok
test_too_young_partition ... ok
test_valid_partition ... ok
test_wrong_type_partition ... ok

In een echt project is de parametrize-functie van pytest een handige manier om een tabel met partitiewaarden door één enkele test te laten lopen.

Uitgewerkt voorbeeld: een wachtwoord

Vereiste: Een wachtwoord moet 8 tot 20 tekens lang zijn en minimaal één cijfer bevatten.

Deze heeft twee regels, lengte en inhoud, dus we overwegen partities voor beide:

Houd er rekening mee dat elke ongeldige test slechts één regel overtreedt. Als een waarde zowel te kort was als een cijfer miste, kon een geslaagde test u niet vertellen welke controle werkte. De ene cheque kan worden verbroken, terwijl de andere het feit verbergt.

Uitgewerkt voorbeeld: niet-numerieke invoer

De techniek is niet beperkt tot nummerreeksen. Discrete opties, categorieën en statussen vormen ook partities. Stel dat een winkel deze regel heeft:

Vereiste: De bezorging is gratis voor Gold-leden, 50 voor Silver en 100 voor alle anderen. Onbekende niveauwaarden zijn fouten.

Hier is elke optie zijn eigen partitie, omdat elke optie zich anders zou moeten gedragen. Andere veel voorkomende partities zijn bestandstypen, zoals geldige en ongeldige uploads, en op uitvoer gebaseerde groepen, zoals een lening die wordt goedgekeurd of geweigerd.

Meerdere ingangen tegelijk

Met meerdere velden groeit het aantal combinaties snel. Drie velden met elk vier partities geven 64 combinaties. Twee strategieën helpen:

• Zwakke dekking: zorg ervoor dat elke partitie in ten minste één test voorkomt, waarbij verschillende geldige waarden per test worden gecombineerd. Voor ongeldige waarden test u één voor één, zodat fouten elkaar niet maskeren.
• Op regels gebaseerde dekking: wanneer combinaties het resultaat daadwerkelijk veranderen, zoals de ledenstatus met de bestelwaarde, gebruik dan testen van de beslissingstabel om ze correct weer te geven.

Koppeling met grenswaardeanalyse

Partitioneren vertelt u welke groepen u moet testen. Het zegt weinig over waar in een groep insecten zich graag verstoppen, en velen verstoppen zich aan de randen. Om dit te laten zien, hebben we een versie met fouten geschreven met de klassieke ‘off-by-one’-fout:

def buggy(age):
    return 18 < age <= 60     # should be 18 <= age

[buggy(a) for a in (35, 10, 75)]   # [True, False, False]
buggy(18)                          # False

Onze partitiewaarden, 35, 10 en 75, gaven allemaal de juiste antwoorden, dus die tests zouden slagen. Toch wordt een 18-jarige ten onrechte afgewezen. Dit is de reden waarom de twee technieken bij elkaar horen:

Gebruik partities om de groepen te vinden, en vervolgens grenzen om te testen waar groepen samenkomen. In onze code gaf een aparte test voor 17, 18, 60 en 61 de juiste functie door en zou die bug onderscheppen. Onze gids voor grenswaardeanalyse behandelt dit volledig.

Voordelen en beperkingen

Het grootste risico is een onjuiste aanname. Als de code een verborgen regel voor één specifieke waarde bevat, kan de door u gekozen test deze eenvoudigweg niet bereiken. Verkennende tests en codedekking helpen je te ontdekken wat de partities hebben gemist.

Veel voorkomende fouten

• Ongeldige partities vergeten. Als u alleen gelukkige paden test, wordt de foutafhandeling uitgeschakeld.
• Verschillende waarden testen vanaf één partitie. Dit brengt kosten met zich mee zonder nieuwe informatie.
• Het combineren van meerdere ongeldige waarden in één test. De ene fout kan de andere verbergen.
• Grenzen overslaan. Partitietests alleen al missen vaak off-by-one-bugs.
• De regels raden. Als een vereiste onduidelijk is, vraag het dan. Moeten 60 ook mensen omvatten die 60 en een half jaar oud zijn?

Tot slot

Equivalentiepartitionering vervangt “hoeveel tests moet ik schrijven?” met een veel betere vraag: “welke gedragingen bestaan ​​er, en heb ik ze allemaal besproken?” Om het te proberen, neemt u een formulier dat u vandaag aan het testen bent en vermeldt u de partities ervan op papier, inclusief de ongeldige partities. Voeg vervolgens grenzen toe. Je zult vaak eindigen met minder tests die meer bugs vinden.

Veelgestelde vragen

Blijf leren