Enhedstest med Python unittest-modul

Ingen god udvikler implementerer kode uden grundig test. Enhedstest er processen med at teste de enkelte moduler i et stort program.

Denne artikel vil diskutere, hvordan du kan udføre enhedstest af din kode ved hjælp af Python unittest-modulet. Lad os først forstå, hvilke typer test der er.

Når det kommer til test, er der manuel test og automatisk test. Manuel test er en testteknik, hvor mennesker udfører testen manuelt efter færdiggørelsen af udviklingen. Automationstest er en testteknik, hvor programmer udfører testen automatisk og giver os resultaterne.

Du ville have forstået, at manuel test er tidskrævende og svært at udføre. Så udviklerne skriver kode til udførelse af test (automatisk test). Der er forskellige former for test i automatiseret test. Nogle af dem er enhedstest, integrerende test, ende til ende test, stresstest osv..,

Lad os se standardforløbet af test.

Skriv eller opdater koden.
Skriv eller opdater tests for forskellige tilfælde for din kode.
Kør testene (enten manuelt eller ved hjælp af en testløber).
Se testresultaterne. Hvis der er fejl, skal du rette dem og gentage trinene.

Her skal vi diskutere den mest essentielle og grundlæggende testtype kaldet enhedstestning. Lad os uden videre dykke ned i selve selvstudiet.

Indholdsfortegnelse

Hvad er enhedstestning?

Enhedstest er en teknik til at teste en lille blok af uafhængig kode. Den lille blokkode vil være en funktion i de fleste tilfælde. Ordet uafhængig betyder, at det ikke afhænger af andre stykker kode i projektet.

Lad os sige, at vi skal kontrollere, om en streng er lig med “toadmin.dk” eller ej. Til det har vi skrevet en funktion, der tager et argument og returnerer, om det er lig med “toadmin.dk” eller ej.

def is_equal_to_geekflare(string):
	return string == "toadmin.dk"

Ovenstående funktion er ikke afhængig af nogen anden kode. Så vi kan teste det uafhængigt ved at give forskellige input. Det uafhængige stykke kode kan bruges på tværs af projektet.

Vigtigheden af enhedstestning

Generelt kan den uafhængige blokkode bruges på tværs af projektet. Så det skal være velskrevet og afprøvet. Enhedstest er de test, der bruges til at teste disse typer af uafhængige kodeblokke. Hvad sker der, hvis vi ikke bruger enhedstest til vores projekt?

Migrer databaser problemfrit med BackupBuddy

Lad os antage, at vi ikke testede små kodeblokke, der bruges på tværs af projektet. Alle andre tests som integrationstests, end-to-end tests osv., der bruger de andre små kodeblokke, kan mislykkes. Dette bryder applikationen. Derfor skal de grundlæggende byggesten i koden testes godt.

Nu ved vi vigtigheden af enhedstest og skriftlige enhedstests for alle uafhængige kodeblokke. Da vi har udført enhedstests, vil andre tests som integrationstests, end-to-end tests osv. ikke fejle på grund af den uafhængige blok af koder.

I de kommende afsnit vil vi se, hvad Python unittest-modulet er, og hvordan vi bruger unittest-modulet til at skrive unittests i Python.

Bemærk: Vi antager, at du er bekendt med Python-klasser, moduler osv. Hvis du ikke er bekendt med Python-mellembegreber som klasser, moduler osv., kan det være svært at forstå de kommende afsnit.

Hvad er Python unittest?

Python unittest er en indbygget testramme til at teste Python-kode. Den har en testløber, som giver os mulighed for at køre testene uden den store indsats. Så vi kan bruge det indbyggede unittest-modul til test uden at bruge tredjepartsmodulerne. Men det ændrer sig baseret på dit krav. Det indbyggede unittest-modul er godt at komme i gang med at teste i Python.

Vi skal følge nedenstående trin for at teste Python-koden ved hjælp af unittest-modulet.

#1. Skriv koden.

#2. Importer unittest-modulet.

#3. Opret en fil, der starter med nøgleordstesten. For eksempel test_prime.py. Nøgleordstesten bruges til at identificere testfilerne.

#4. Opret en klasse, der udvider klassen unittest.TestCase.

#5. Skriv metoder (test) inde i klassen. Hver metode indeholder forskellige testcases baseret på dit krav. Vi skal navngive metoden, der starter med test nøgleord.

#6. Kør testene. Vi kan køre testene på forskellige måder.

Kør kommandoen python -m unittest test_filnavn.py.
Vi kører testfilerne som generelle Python-filer med kommandoen python test_filename.py. For at denne metode skal fungere, skal vi påberåbe hovedmetoden for unittesten i testfilen.
Og endelig ved at bruge opdagelsen. Vi kan køre testene automatisk ved hjælp af kommandoen python -m unittest discover uden at nævne testens filnavn. Den vil finde testene ved hjælp af den navnekonvention, som vi fulgte. Så vi skal navngive vores testfiler med nøgleordet test i starten.

Sådan genstartes Chrome

Generelt i test sammenligner vi outputtet af koden med det forventede output. Så for at sammenligne output giver unittest forskellige metoder. Du kan finde listen over sammenlignende funktioner her.

Du kan nemt forstå dem uden problemer. De er ligetil.

Det er meget teori. Vi skal nu i gang med kodning.

Bemærk: Hvis du har spørgsmål om unittest-modulet, kan du gå til dokumentation og fjern din tvivl. Uden yderligere forsinkelse, lad os bruge unittest-modulet.

Enhedstest i Python ved hjælp af unittest

Vi vil først skrive nogle funktioner, og derefter vil vi fokusere på at skrive testene. Åbn først en mappe i din foretrukne kodeeditor. Og opret en fil kaldet utils.py. Indsæt følgende kode i filen.

import math


def is_prime(n):
    if n < 0:
        return 'Negative numbers are not allowed'

    if n <= 1:
        return False

    if n == 2:
        return True

    if n % 2 == 0:
        return False

    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True


def cubic(a):
    return a * a * a


def say_hello(name):
    return "Hello, " + name

Vi har tre forskellige funktioner i filen utils.py. Nu skal vi teste hver funktion med forskellige testcases. Lad os skrive testene for den første funktion is_prime.

#1. Opret en fil kaldet test_utils.py i eksempelmappen som utils.py.

#2. Importer modulet utils og unittest.

#3. Opret en klasse med navnet TestUtils, der udvider unittest.TestCase-klassen. Klassens navn kan være hvad som helst. Prøv at give klassen et meningsfuldt navn.

#4. Inde i klassen skal du skrive en metode kaldet test_is_prime, som accepterer sig selv som et argument.

#5. Skriv forskellige testcases med argumenter til is_prime og sammenlign output med det forventede output.

#6. Eksempel på testcase self.assertFalse(utils.is_prime(1)).

#7. Vi forventer, at output fra is_prime(1) vil være falsk i ovenstående tilfælde.

#8. I lighed med ovenstående case vil vi forskellige testcases baseret på den funktion, vi tester.

Sådan konfigurerer og bruger du Google Drev på din Mac

Lad os se testene.

import unittest

import utils


class TestUtils(unittest.TestCase):
    def test_is_prime(self):
        self.assertFalse(utils.is_prime(4))
        self.assertTrue(utils.is_prime(2))
        self.assertTrue(utils.is_prime(3))
        self.assertFalse(utils.is_prime(8))
        self.assertFalse(utils.is_prime(10))
        self.assertTrue(utils.is_prime(7))
        self.assertEqual(utils.is_prime(-3),
                         "Negative numbers are not allowed")


if __name__ == '__main__':
    unittest.main()

Vi påberåber os hovedmetoden til unittest modulet for at køre testene ved hjælp af kommandoen python filename.py. Kør nu testene.

Du vil se output svarende til nedenstående output.

$ python test_utils.py 
.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Prøv nu også at skrive testcaserne for andre funktioner. Tænk på forskellige cases for funktionerne og skriv test for dem. Tag et kig på følgende test, der er tilføjet til ovenstående klasse.

...


class TestUtils(unittest.TestCase):
    def test_is_prime(self):
        ...

    def test_cubic(self):
        self.assertEqual(utils.cubic(2), 8)
        self.assertEqual(utils.cubic(-2), -8)
        self.assertNotEqual(utils.cubic(2), 4)
        self.assertNotEqual(utils.cubic(-3), 27)

    def test_say_hello(self):
        self.assertEqual(utils.say_hello("toadmin.dk"), "Hello, toadmin.dk")
        self.assertEqual(utils.say_hello("Chandan"), "Hello, Chandan")
        self.assertNotEqual(utils.say_hello("Chandan"), "Hi, Chandan")
        self.assertNotEqual(utils.say_hello("Hafeez"), "Hi, Hafeez")


...

Vi brugte kun nogle af sammenligningsfunktionerne fra unittest-modulet. Du kan finde den komplette liste her.

Vi har lært, hvordan man skriver enhedstests ved hjælp af unittest modulet. Nu er det tid til at se forskellige måder at køre testene på.

Sådan køres tests ved hjælp af unittest

Vi har allerede set en måde at køre testcases på i ovenstående afsnit. Lad os se de to andre måder at køre testene på ved hjælp af unittest-modulet.

#1. Brug af filnavnet og unittest-modulet.

I denne metode vil vi bruge unittest-modulet og filnavnet til at køre testene. Kommandoen til at køre testene er python -m unittest filnavn.py. I vores tilfælde er kommandoen til at køre testene python -m unittest test_utils.py.

#2. Brug af opdagelsesmetoden

Vi vil bruge opdagelsesmetoden i unittest-modulet til automatisk at detektere alle testfilerne og køre dem. For automatisk at detektere testfilerne skal vi navngive dem begyndende med nøgleordet test.

Kommandoen til at køre testene ved hjælp af discover-metoden er python -m unittest discover. Kommandoen vil finde alle de filer, hvis navne starter med test og udføre dem.

Konklusion 👩‍💻

Enhedstest er grundlæggende test i programmeringsverdenen. Der er mange andre tests i den virkelige verden. Prøv at lære dem én efter én. Jeg håber, at denne tutorial hjælper dig med at skrive grundlæggende tests i Python ved hjælp af unittest-modulet. Der er tredjepartsbiblioteker som pytest, Robot Framework, nose, nose2, slash osv. Du kan udforske dem baseret på dine projektkrav.

God test 😎

Du kan også være interesseret i Python-interviewspørgsmål og -svar.