Wat is unittesten?

Wat is unittesten?

Testen van een eenheid is een vorm van softwaretesten waarbij individuele eenheden of componenten van software worden getest. Het doel is om te valideren dat elke eenheid van de softwarecode presteert zoals verwacht. Unit Testing wordt gedaan tijdens de ontwikkeling (codeerfase) van een applicatie door de ontwikkelaars. Unit Tests isoleren een codegedeelte en verifiëren de juistheid ervan. Een eenheid kan een individuele functie, methode, procedure, module of object zijn.

In SDLC, STLC, V-model en unit-testen is het eerste testniveau dat wordt uitgevoerd vóór integratietesten. Eenheidstest is een witteBox testtechniek die doorgaans door de ontwikkelaar wordt uitgevoerd. Hoewel QA-ingenieurs in een praktische wereld, vanwege tijdgebrek of onwil van ontwikkelaars om te testen, ook unit-tests uitvoeren.

Wat is unit-testen

Video-uitleg over het testen van eenheden

Waarom unittesten uitvoeren?

Testen van een eenheid is belangrijk omdat softwareontwikkelaars soms tijd proberen te besparen door minimale unit-tests uit te voeren en dit is een mythe omdat ongepaste unit-tests tot hoge kosten leiden Defect fixeren tijdens Systeem testen, Integratietesten en zelfs bètatesten nadat de applicatie is gebouwd. Als er in de beginfase van de ontwikkeling de juiste unit-tests worden uitgevoerd, bespaart dit uiteindelijk tijd en geld.

Dit zijn de belangrijkste redenen om unit-tests uit te voeren in software-engineering:

Testniveaus voor eenheden
Testniveaus voor eenheden
  1. Unit-tests helpen bugs vroeg in de ontwikkelingscyclus op te lossen en kosten te besparen.
  2. Het helpt de ontwikkelaars de testcodebasis te begrijpen en stelt hen in staat snel wijzigingen aan te brengen
  3. Goede unittests dienen als projectdocumentatie
  4. Unit-tests helpen bij het hergebruik van code. Migreer uw beide code en uw tests naar uw nieuwe project. Pas de code aan totdat de tests opnieuw worden uitgevoerd.

Hoe u unittests uitvoert

Om Unit Tests uit te voeren, schrijven ontwikkelaars een stuk code om een ​​specifieke functie in een softwareapplicatie te testen. Ontwikkelaars kunnen deze functie ook isoleren om rigoureuzer te testen, waardoor onnodige afhankelijkheden tussen de geteste functie en andere eenheden aan het licht komen, zodat de afhankelijkheden kunnen worden geëlimineerd. Ontwikkelaars gebruiken over het algemeen UnitTest-framework het ontwikkelen van geautomatiseerde testgevallen voor het testen van eenheden.

Er zijn twee typen unittests

  • Handmatig
  • Automated

Het testen van eenheden is doorgaans geautomatiseerd, maar kan nog steeds handmatig worden uitgevoerd. Software Engineering geeft niet de voorkeur aan de een boven de ander, maar automatisering heeft de voorkeur. Bij een handmatige benadering van het testen van eenheden kan gebruik worden gemaakt van een stapsgewijs instructiedocument.

Onder de geautomatiseerde aanpak

  • Een ontwikkelaar schrijft een stuk code in de applicatie om de functie te testen. Zij zouden later geef commentaar en verwijder uiteindelijk de testcode wanneer de applicatie is geïmplementeerdyed.
  • Een ontwikkelaar zou de functie ook kunnen isoleren om deze grondiger te testen. Dit is een grondigere praktijk voor het testen van eenheden, waarbij code naar de eigen testomgeving wordt gekopieerd en geplakt dan naar de natuurlijke omgeving. Het isoleren van de code helpt bij het onthullen van onnodige afhankelijkheden tussen de code die wordt getest en andere eenheden of dataruimten in het product. Deze afhankelijkheden kunnen vervolgens worden geëlimineerd.
  • Een codeerder gebruikt doorgaans een UnitTest Framework om geautomatiseerde testgevallen te ontwikkelen. Met behulp van een automatiseringsframework codeert de ontwikkelaar criteria in de test om de juistheid van de code te verifiëren. Tijdens de uitvoering van de testgevallen registreert het raamwerk falende testgevallen. Veel raamwerken zullen deze ook automatisch markeren en rapporteren mislukte testgevallen. Afhankelijk van de ernst van een storing kan het raamwerk de daaropvolgende tests stopzetten.
  • De workflow van Unit Testing is 1) Testcases maken 2) Beoordelen/herwerken 3) Basislijn 4) Testcases uitvoeren.

Unit-testtechnieken

De Unit-testtechnieken zijn hoofdzakelijk onderverdeeld in drie delen, namelijk zwart box testen waarbij de gebruikersinterface wordt getest, samen met invoer en uitvoer, White box testen waarbij het functionele gedrag van de softwareapplicatie en Gray wordt getest box testen dat wordt gebruikt voor het uitvoeren van testsuites, testmethoden, testgevallen en het uitvoeren van risicoanalyses.

Codedekkingstechnieken die worden gebruikt bij Unit Testing worden hieronder vermeld:

  • Verklaring Dekking
  • Beslissingsdekking
  • Branchedekking
  • Conditiedekking
  • Dekking van eindige toestandsmachines

Voor meer informatie zie https://www.guru99.com/code-coverage.html

Voorbeeld van eenheidstest: nepobjecten

Unit-testen zijn gebaseerd op het maken van nepobjecten om delen van de code te testen die nog geen deel uitmaken van een volledige applicatie. Mock-objecten vullen de ontbrekende delen van het programma in.

Het kan bijvoorbeeld zijn dat u een functie heeft die variabelen of objecten nodig heeft die nog niet zijn gemaakt. Bij het testen van eenheden wordt hiermee rekening gehouden in de vorm van nepobjecten die uitsluitend zijn gemaakt met het doel van het testen van eenheden op dat codegedeelte.

Hulpmiddelen voor het testen van eenheden

Er zijn verschillende geautomatiseerde unit-testsoftware beschikbaar om te helpen bij het testen van units bij het testen van software. Hieronder geven wij enkele voorbeelden:

  1. Junit: Junit is een gratis te gebruiken testtool die wordt gebruikt voor de Java-programmeertaal. Het biedt beweringen om de testmethode te identificeren. Deze tool test eerst gegevens en voegt deze vervolgens in het stukje code in.
  2. NUn: NUnit is een veelgebruikt unit-testingframework voor alle .net-talen. Het is een open source-tool waarmee u handmatig scripts kunt schrijven. Het ondersteunt datagestuurde tests die parallel kunnen worden uitgevoerd.
  3. JMockit: JMockit is een open source tool voor het testen van eenheden. Het is een tool voor codedekking met lijn- en padstatistieken. Het maakt spot-API mogelijk met opname- en verificatiesyntaxis. Deze tool biedt lijndekking, paddekking en gegevensdekking.
  4. EMMA: EMMA is een open-source toolkit voor het analyseren en rapporteren van code geschreven in Java-taal. Emma ondersteunt dekkingstypen zoals methode, lijn, basisblok. Het is op Java gebaseerd, dus het heeft geen externe bibliotheekafhankelijkheden en heeft toegang tot de broncode.
  5. PHPEenheid: PHPUnit is een unit-testtool voor PHP-programmeurs. Er zijn kleine stukjes code nodig, die eenheden worden genoemd, en deze worden afzonderlijk getest. Met de tool kunnen ontwikkelaars ook vooraf gedefinieerde bevestigingsmethoden gebruiken om te beweren dat een systeem zich op een bepaalde manier gedraagt.

Dit zijn slechts enkele van de beschikbare tools voor het testen van eenheden. Er zijn er nog veel meer, vooral voor C-talen en Java, maar u zult zeker een unit-testtool vinden voor uw programmeerbehoeften, ongeacht de taal die u gebruikt.

Testgestuurde ontwikkeling (TDD) en unit-testen

Unit-testen in TDD omvatten een uitgebreid gebruik van testkaders. Er wordt gebruik gemaakt van een unit-testframework om geautomatiseerde unit-tests te creëren. Unit-testframeworks zijn niet uniek voor TDD, maar ze zijn er wel essentieel voor. Hieronder bekijken we wat TDD te bieden heeft in de wereld van unit-testen:

  • Tests worden vóór de code geschreven
  • Vertrouw sterk op testframeworks
  • Alle klassen in de applicaties worden getest
  • Snelle en eenvoudige integratie wordt mogelijk gemaakt

Eenheidstest-mythe

Mythe: Het kost tijd, en ik ben altijd overgepland
Mijn code is ijzersterk! Ik heb geen unit-tests nodig.

Mythen zijn van nature valse veronderstellingen. Deze aannames leiden tot een vicieuze cirkel als volgt:

UNIT-testmythe

De waarheid is dat unit-testen de ontwikkelingssnelheid verhogen.

Programmeurs denken dat Integratietesten alle fouten zullen opsporen en de unittest niet uitvoeren. Zodra eenheden zijn geïntegreerd, duurt het erg lang voordat zeer eenvoudige fouten, die heel gemakkelijk in geteste eenheden hadden kunnen worden gevonden en opgelost, worden opgespoord en opgelost.

Unit Testen Voordeel

  • Ontwikkelaars die willen weten welke functionaliteit een eenheid biedt en hoe ze deze kunnen gebruiken, kunnen de unit-tests bekijken om basiskennis te krijgen van de unit-API.
  • Met unit-testen kan de programmeur code refactoreren op a later datum, en zorg ervoor dat de module nog steeds correct werkt (bijv Regressietesten). De procedure bestaat uit het schrijven van testgevallen voor alle functies en methoden, zodat wanneer een wijziging een fout veroorzaakt, deze snel kan worden geïdentificeerd en verholpen.
  • Vanwege het modulaire karakter van het testen van eenheden kunnen we delen van het project testen zonder te wachten tot andere voltooid zijn.

Nadelen van unit-testen

  • Van unit-testen kan niet worden verwacht dat ze elke fout in een programma kunnen onderkennen. Het is niet mogelijk om alle uitvoeringspaden te evalueren, zelfs niet in de meest triviale programma's
  • Unit-testen richten zich van nature op een code-eenheid. Daarom kan het geen integratiefouten of fouten op algemeen systeemniveau onderkennen.

Het wordt aanbevolen om unit-tests te gebruiken in combinatie met andere testactiviteiten.

Best practices voor unittesten

  • Eenheidstestgevallen moeten onafhankelijk zijn. In het geval van verbeteringen of wijzigingen in de vereisten mogen de unit-testgevallen niet worden beïnvloed.
  • Test slechts één code tegelijk.
  • Volg duidelijke en consistente naamgevingsconventies voor uw unit-tests
  • In het geval van een codewijziging in een module, zorg ervoor dat er een overeenkomstige eenheid is Testgeval voor de module, en de module slaagt voor de tests voordat de implementatie wordt gewijzigd
  • Bugs die tijdens het testen van eenheden worden geïdentificeerd, moeten worden opgelost voordat doorgaat naar de volgende fase in SDLC
  • Kies voor een ‘test as your code’-aanpak. Hoe meer code u schrijft zonder te testen, hoe meer paden u moet controleren op fouten.

Best practices voor unittesten

Samengevat

  • UNIT TESTING wordt gedefinieerd als een soort softwaretest waarbij individuele eenheden of componenten van software worden getest.
  • Zoals u kunt zien, kan er veel komen kijken bij het testen van eenheden. Het kan complex of eerder eenvoudig, afhankelijk van de applicatie die wordt getest en de teststrategieën, tools en philosofie gebruikt. Unit-testen zijn altijd op een bepaald niveau nodig. Dat is een zekerheid.