Enhetstesting med Python unittest-modul

Ingen gode utviklere distribuerer kode uten grundig testing. Enhetstesting er prosessen med å teste de individuelle modulene i et stort program.

Denne artikkelen vil diskutere hvordan du kan utføre enhetstesting av koden din ved å bruke Python unittest-modulen. Først, la oss forstå hva slags testing er.

Når det gjelder testing er det manuell testing og automatisk testing. Manuell testing er en testteknikk der mennesker utfører testen manuelt etter at utviklingen er fullført. Automatiseringstesting er en testteknikk der programmer utfører testen automatisk og gir oss resultatene.

Du ville ha forstått at manuell testing er tidkrevende og vanskelig å utføre. Så utviklerne skriver kode for å utføre tester (automatisk testing). Det finnes forskjellige typer testing i automatisert testing. Noen av dem er enhetstesting, integreringstesting, ende-til-ende-testing, stresstesting, etc..,

La oss se standardflyten for testing.

• Skriv eller oppdater koden.
• Skriv eller oppdater tester for forskjellige tilfeller for koden din.
• Kjør testene (enten manuelt eller med en testløper).
• Se testresultatene. Hvis det er noen feil, fiks dem og gjenta trinnene.

Her skal vi diskutere den mest essensielle og grunnleggende testtypen kalt enhetstesting. Uten videre, la oss dykke inn i selve opplæringen.

Hva er enhetstesting?

Enhetstesting er en teknikk for å teste en liten blokk med uavhengig kode. Småblokkkoden vil være en funksjon i de fleste tilfeller. Ordet uavhengig betyr at det ikke er avhengig av andre kodebiter i prosjektet.

La oss si at vi må sjekke om en streng er lik «tipsbilk.net» eller ikke. For det har vi skrevet en funksjon som tar ett argument og returnerer om det er lik «tipsbilk.net» eller ikke.

def is_equal_to_geekflare(string):
	return string == "tipsbilk.net"

Funksjonen ovenfor er ikke avhengig av noen annen kode. Så vi kan teste det uavhengig ved å gi forskjellige input. Den uavhengige kodebiten kan brukes på tvers av prosjektet.

Viktigheten av enhetstesting

Generelt kan den uavhengige blokkkoden brukes på tvers av prosjektet. Så det må være godt skrevet og testet. Enhetstester er testene som brukes til å teste disse typene uavhengige kodeblokker. Hva skjer hvis vi ikke bruker enhetstester for prosjektet vårt?

La oss anta at vi ikke testet små kodeblokker som brukes på tvers av prosjektet. Alle andre tester som integrasjonstester, ende-til-ende-tester osv., som bruker de andre små kodeblokkene, kan mislykkes. Dette bryter søknaden. Det er derfor de grunnleggende byggesteinene i koden må testes godt.

Nå vet vi viktigheten av enhetstesting og skriftlige enhetstester for alle uavhengige kodeblokker. Siden vi har utført enhetstester, vil ikke andre tester som integrasjonstester, ende-til-ende-tester osv. mislykkes på grunn av den uavhengige blokken med koder.

I de kommende avsnittene vil vi se hva Python unittest-modulen er og hvordan vi bruker unittest-modulen til å skrive enhetstester i Python.

Merk: Vi antar at du er kjent med Python-klasser, moduler osv. Hvis du ikke er kjent med Python-mellomkonsepter som klasser, moduler osv., kan det være vanskelig å forstå de kommende delene.

Hva er Python unittest?

Python unittest er et innebygd testrammeverk for å teste Python-kode. Den har en testløper, som gjør at vi kan kjøre testene uten store anstrengelser. Så vi kan bruke den innebygde unittest-modulen for testing uten å bruke tredjepartsmodulene. Men det endres basert på dine krav. Den innebygde unittest-modulen er god for å komme i gang med testing i Python.

Vi må følge trinnene nedenfor for å teste Python-koden ved å bruke unittest-modulen.

#1. Skriv koden.

#2. Importer enhetstestmodulen.

#3. Opprett en fil som starter med nøkkelordtesten. For eksempel test_prime.py. Nøkkelordet test brukes til å identifisere testfilene.

#4. Opprett en klasse som utvider klassen unittest.TestCase.

#5. Skriv metoder (tester) inne i klassen. Hver metode inneholder forskjellige testtilfeller basert på ditt krav. Vi må navngi metoden som starter med test nøkkelord.

#6. Kjør testene. Vi kan kjøre testene på forskjellige måter.

• Kjør kommandoen python -m unittest test_filnavn.py.
• Vi kjører testfilene som generelle Python-filer med kommandoen python test_filename.py. For at denne metoden skal fungere, må vi påkalle hovedmetoden for unittest i testfilen.
• Og til slutt, ved å bruke oppdagelsen. Vi kan kjøre testene automatisk ved å bruke kommandoen python -m unittest discover uten å nevne filnavnet til testen. Den vil finne testene ved å bruke navnekonvensjonen som vi fulgte. Så vi må navngi testfilene våre med nøkkelordet test i starten.

Generelt, i testing, sammenligner vi utdata fra koden med forventet utgang. Så for å sammenligne utgangene gir unittest forskjellige metoder. Du kan finne listen over sammenligningsfunksjoner her.

Du kan lett forstå dem uten problemer. De er greie.

Det er mye teori. Vi må nå komme inn på koding.

Merk: Hvis du har spørsmål om unittest-modulen, kan du gå til dokumentasjon og fjern tvilen din. Uten ytterligere forsinkelse, la oss bruke unittest-modulen.

Unit Tests i Python ved hjelp av unittest

Vi skal skrive noen funksjoner først, og deretter skal vi fokusere på å skrive prøvene. Først åpner du en mappe i din favorittkoderedigerer. Og lag en fil som heter utils.py. Lim inn 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 forskjellige funksjoner i filen utils.py. Nå må vi teste hver funksjon med forskjellige testtilfeller. La oss skrive testene for den første funksjonen is_prime.

#1. Opprett en fil kalt test_utils.py i eksempelmappen som utils.py.

#2. Importer utils and unittest-modulen.

#3. Lag en klasse med navnet TestUtils som utvider unittest.TestCase-klassen. Navnet på klassen kan være hva som helst. Prøv å gi klassen et meningsfylt navn.

#4. Inne i klassen, skriv en metode kalt test_is_prime som aksepterer seg selv som et argument.

#5. Skriv forskjellige testtilfeller med argumenter til is_prime og sammenlign utdata med forventet utdata.

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

#7. Vi forventer at utdataene fra is_prime(1) vil være usann i tilfellet ovenfor.

#8. I likhet med tilfellet ovenfor vil vi forskjellige testtilfeller basert på funksjonen vi tester.

La oss 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åkaller hovedmetoden for unittest modulen for å kjøre testene ved å bruke kommandoen python filename.py. Kjør testene nå.

Du vil se utgangen som ligner på utgangen nedenfor.

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

OK

Prøv nå å skrive testsakene for andre funksjoner også. Tenk på forskjellige tilfeller for funksjonene og skriv tester for dem. Ta en titt på følgende tester som er lagt til klassen ovenfor.

...


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("tipsbilk.net"), "Hello, tipsbilk.net")
        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 brukte bare noen av sammenligningsfunksjonene fra unittest-modulen. Du finner hele listen her.

Vi har lært hvordan man skriver enhetstester ved hjelp av unittest-modulen. Nå er det på tide å se forskjellige måter å kjøre testene på.

Hvordan kjøre tester med unittest

Vi har allerede sett en måte å kjøre testsakene i avsnittet ovenfor. La oss se på de to andre måtene å kjøre testene ved hjelp av unittest-modulen.

#1. Bruke filnavnet og unittest-modulen.

I denne metoden vil vi bruke unittest-modulen og filnavnet for å kjøre testene. Kommandoen for å kjøre testene er python -m unittest filnavn.py. I vårt tilfelle er kommandoen for å kjøre testene python -m unittest test_utils.py.

#2. Bruker oppdage-metoden

Vi vil bruke oppdagelsesmetoden til unittest-modulen for å automatisk oppdage alle testfilene og kjøre dem. For å oppdage testfilene automatisk, må vi gi dem et navn som starter med nøkkelordet test.

Kommandoen for å kjøre testene ved hjelp av discover-metoden er python -m unittest discover. Kommandoen vil oppdage alle filene hvis navn starter med test og kjøre dem.

Konklusjon 👩‍💻

Enhetstester er grunnleggende testing i programmeringsverdenen. Det er mange andre tester i den virkelige verden. Prøv å lære dem én etter én. Jeg håper denne opplæringen hjelper deg med å skrive grunnleggende tester i Python ved å bruke unittest-modulen. Det finnes tredjepartsbiblioteker som pytest, Robot Framework, nose, nose2, slash osv. Du kan utforske dem basert på prosjektkravene dine.

Lykke til med testingen 😎

Du kan også være interessert i Python-intervjuspørsmål og -svar.