Phenquestions
Enhetstestning är en testmetod som används i programvaruteknik för enskilda enheter av vilken kod som helst. Användare kan testa de enskilda testerna för att bestämma källans status och hur mycket koden är lämplig att använda. På så sätt kan användare testa kodkvaliteten.
Testning görs när utvecklingsprocessen är klar. Användare kan också börja testa när testskriptet ska verifieras baserat på kriterierna för testningen. Utvecklare förväntas skriva manuella typer av källkoden. Generellt är manuell skrivning av enhetstestkoder en hektisk uppgift, men i Python görs det med en inbyggd funktion som kallas unittest.
Enhetstest
Testningen i Python görs av unittest framework. Enhetstestning gör koden säker och lätt att använda även i framtiden. Användare kan vanligtvis inte förutsäga dessa fall men kan enkelt ta itu med dem. Unittest kan antingen vara hela modulen, en viss funktion och ett helt gränssnitt (klass / modul).
Hur man skriver enhetstester för din kod?
För att skriva enhetstesterna för din kod, börja alltid med den minsta enheten som kan testas från hela koden och gå sedan vidare till andra enheter. På det här sättet kommer du att kontrollera hur den minsta valda enheten samverkar för att bygga ett helhetstest.
Enhetstestningsramen för Python bildades genom att ta hänsyn till Java's Junit. Det har samma funktioner som att enhetstester görs på andra språk. Ramverket för enhetstestning i Python hjälper till med automatiseringstestning, konfigurera delning, aggregering av många tester i en stor uppsättning och oberoende tester
Exempel:
Nu, i exemplet, kontrollerar vi koden för att ta reda på summan i Python-kod med funktionen sum (). Svaret på denna summering måste vara 12, vilket är korrekt.
>>> hävda summan ([2, 4, 6]) == 12, "Bör vara lika med 12"
Å andra sidan, om vi försöker skriva fel utdatavärde, som summan () är felaktig, kommer resultaten att misslyckas. Det kommer att returnera en AssertionError. Den utdata som anges av oss är fel, det vill säga 12, och den faktiska utgången måste vara 6, därför returnerade den detta fel.
>>> hävda summan ([2, 2, 2]) == 12, "Bör vara lika med 12"
Nu, istället för att testa på REPL, lägger vi in en ny Python-fil och heter den test_sum.py
>> def testValue_sum ():hävda summan ([2, 4, 6]) == 12, "Bör vara lika med 12"
om __name__ == "__main__":
testValue_sum ()
skriva ut ("Allt har skickats korrekt")
Efter att ha skrivit testfallet kan du komma åt katalogen som har test_sum.py-fil och skriv sedan:
$ python test_sum.pyProduktion:
Utgångsvärdet, när det liknar det som visas, godkänner rätt värde.
Låt oss skapa en annan fil för .py för att testa summan. Exemplet som visas i koden och kan användas som ett exempel genom att kopiera:
def testValue_sum ():hävda summan ([2, 4, 6]) == 12, "Bör vara lika med 12"
def testValue_sum_tuple ():
hävda summan ((1, 1, 1)) == 6, "Bör vara lika med 6"
om __name__ == "__main__":
testValue_sum ()
testValue_sum_tuple ()
skriva ut ("Allt har skickats korrekt")
Den här gången kommer vi att namnge filen igen test_sum.py
Det första kodblocket är korrekt, medan det andra kodblocket är fel och har ett fel, så vår utgång kommer att returnera densamma.
Nu kommer vi tillbaka till katalogen för projektet, där vi sparade .py-fil, och testa sedan filen med följande kommando:
$ python test_sum.py
Produktion:
Den här gången eftersom ingångskoden hade ett fel förväntas den returnera påståendefelet som svar.
Exempel på att använda unittest:
Unittest krav är att användare kan sätta sina tester i klasser som olika metoder, användare kan använda en serie påståendemetoder och TestCase-klassen kan användas i stället för påståendet.
Användare kan konvertera exemplet som diskuterades under föregående halvdel till ett otestat testfall.
Importera först enhetsbiblioteket. Därefter måste du skapa en TestSum från olika klasser.
Skapa en ny fil för koden som diskuteras nedan:
importera unittestklass TestSum (unittest.Testfall):
def testValue_sum (själv):
själv.assertEqual (sum ([2, 4, 6]), 12, "Bör vara lika med 12")
def testValue_sum_tuple (själv):
själv.assertEqual (sum ((1, 1, 1)), 6, "Bör vara lika med 6")
om __name__ == '__main__':
enhetstest.huvud ()
När du har kört detta kommando har utgången en punkt. Detta betyder framgång och ett F betyder ett misslyckande.
Så vi har framgång och en annan är ett misslyckande.
Produktion:
Skriva det första testet:
Skapa en ny projektmapp och skapa sedan en ny mapp, vi kommer att kalla den sum_file. Inne i den, skapa en fil och namnge den, __init__.py. Gör projektmappen så här:
projekt/│
└── sum_fil /
└── __init__.py
Då måste du öppna my_sum / __ init__.py och skapa en ny funktionssumma (). Det kommer att vara iterabelt (en lista, tupel eller set) för att lägga till många värden:
def sum (arg):total_ValueCalculated = 0
för val i arg:
total_ValueCalculated + = val
returnera total_ValueCalculated
Därefter måste du skapa en testa fil. Börja med att skriva tester och skapa en testfil som heter testFile.py. För att importera applikationen och den måste testas, placera filen testFile.py ovanför din mapp i paketet. Följande kommer att se din katalogs övergripande utseende:
projekt/│
├── sum_fil /
│ └── __init__.py
|
└── testFile.py
Som diskuterats tidigare för att testa koden kan du använda följande kommando i terminalfönstret / kommandoraden:
$ python -m unittest testSlutsats
Artikeln diskuterar processen för enhetstestning i Python. Testning är en av de användbara funktionerna i programvaruteknik som kan dela upp koder i mindre bitar och sedan prova dem en efter en. Användare kan också sammanställa hela testproverna / enhetskoderna i en stor samling. Unittest är en funktion som används i Python för att göra det enkelt att testa.
