Menu

Aan de slag met FitNesse - een samenwerkingstool voor testers en ontwikkelaars

  • Hoofd
  • Agile Testen
  • Aan de slag met FitNesse - een samenwerkingstool voor testers en ontwikkelaars

getting started with fitnesse collaboration tool

Probeer Ons Instrument Voor Het Oplossen Van Problemen

Nu gaat de wereld naar Agile. Vroege en continue feedback is essentieel voor elk scrumteam. Omdat de wereld verandert, moet ook de mentaliteit van testers worden veranderd.

In plaats van 'bugs te vinden, software te doorbreken, vereiste te meten', denken testers nu aan 'de eerste keer de kwaliteit leveren, testen zonder de UI of testen nog voordat de UI beschikbaar is'.

Aan de slag met FitNesse

Testers moeten nu ook reageren op veranderingen, en daarom is het belangrijk om uit de black box-testtechniek te komen en niet te wachten tot de gebruikersinterface is ontwikkeld; begin in plaats daarvan ook met het testen van de tussentijdse resultaten.

Wat je leert:

hoe je handmatige testcases schrijft

Maar waarom?

'NU IS DIT ZEER WENDBAAR PERSPECTIEF'.

Telkens wanneer we software bouwen, worden de laagste testlagen op unit- / componentniveau gehouden. Unit-tests worden uitgevoerd door het ontwikkelteam. Deze unit tests zijn zeer technologisch georiënteerd en meestal geschreven in dezelfde taal waarin het te testen systeem is geschreven.

Deze unit tests zijn geschreven met ' X-eenheid ”Testtool. Dat zeggen we in de testwereld als onze unit-test zeer solide is worden defecten veel eerder ontdekt en wordt het testen boven de unit-testlaag gemakkelijk in een stabiele omgeving. En als we in Agile praten, zeggen we dat als een team de kunst van TDD (Test Driven Development) beheerst, de tests op unit-niveau de snelste feedback geven.

De laag boven de unit / componentenlaag is de Acceptatietestlaag die de business uitvoert. Dit zijn functionele tests die meer dekking hebben dan de unit tests en worden meestal uitgevoerd door de niet-ontwikkelaars. Deze tests testen de laag achter de presentatielaag of de API's. Deze API's of methoden geven bij het testen een snelle feedback en tegen de tijd dat de GUI is ontwikkeld, zijn de meeste functionaliteiten getest.

FitNesse is een voorbeeld van deze Automated Acceptance Tests Layer.

Wat is FitNesse?

FitNesse is 'Een volledig geïntegreerde standalone wiki en een framework voor acceptatietesten'. Het is de open source wiki-webserver. Wiki- omdat het het mogelijk maakt om uw eigen webpagina's te maken waarop testtabellen worden gemaakt. Deze testtafels zijn niets anders dan de testgegevens ​

De bedoeling is om een ​​agile stijl van black box-acceptatie en regressietesten te ondersteunen. Het is ook een samenwerkingstool omdat testers samenwerken met ontwikkelaars om de testsuite voor te bereiden.

Waarom zou ik FitNesse gebruiken?

Agile testteam kan FitNesse gebruiken om testpakken voor te bereiden die de methoden in de code testen. FitNesse is analoog aan Junit op een manier dat het ook de methoden test, maar het is anders dan Junit, omdat de tests de vorm hebben van eenvoudige tabellen die door zowel ontwikkelaars als niet-ontwikkelaars kunnen worden gebruikt.

Voordelen:

  • Vroege feedback, door de geautomatiseerde acceptatietests zo vaak als nodig uit te voeren.
  • Testresultaten zijn deterministisch omdat ze rood of groen zijn gemarkeerd.
  • Testgegevens kunnen worden ontworpen om aan de kwaliteitsbehoeften te voldoen.
  • De tests zijn geschreven in eenvoudige taal en gemakkelijk te begrijpen omdat ze in tabelvorm zijn geschreven.
  • Deze tabellen zijn gedefinieerd in termen van input en verwachte output.
  • Alles zien FitNesse-functies hier.

Dus wat kan ik allemaal maken?

In FitNesse kunt u Tests en Suite maken. De termen zijn vrijwel hetzelfde als in de testwereld. Tests zijn enkelvoudig script en pak is een verzameling / groep tests. Als je een reeks aanmaakt en deze uitvoert, heeft het voordeel dat alle tests in die reeks worden uitgevoerd. Je hebt dus een goede planning nodig om je tests in een pak te organiseren.

FitNesse downloaden en configureren:

=> Om FitNesse te downloaden, Klik hier

​Notitie: Klik op een afbeelding voor een vergrote weergave)

fitnesse1

Download de nieuwste versie van fitnesse-standalone.jar en sla deze op uw lokale schijf op.

FitNesse2

Open een opdrachtprompt en voer het jar-bestand uit. Voor het gemak heb ik een batchbestand gemaakt:

FitNesse3

Zodra het jar-bestand is uitgevoerd, wordt FitNesse gestart zoals hieronder weergegeven: (klik op afbeelding voor vergrote weergave)

FitNesse4

Om FitNesse te openen, open je je browser en typ je: http: // localhost: ​In dit geval is het poortnummer 2222.

De ontvangen pagina wordt hieronder weergegeven: (klik op afbeelding voor vergrote weergave)

FitNesse5

Dus hier, als u de vervolgkeuzelijst Tests kunt zien, kunnen we zowel een 'Suite-pagina' als een 'Testpagina' maken. Wanneer u een suite maakt, worden alle testscripts binnen die suite uitgevoerd.

Ter verduidelijking neem ik een voorbeeld van een testpagina.

FitNesse-voorbeeld - De dingen om te testen:

Vanaf nu testen we een eenvoudig rekenprogramma dat hieronder wordt weergegeven.

Hier is de code in Java, die 4 methoden heeft:

  • toevoeging ()
  • min ()
  • vermenigvuldigen ()
  • verdelen ()

(Let erop dat FitNesse werkt met elke taal naar keuze. Voor uitleg heb ik java gebruikt)

Deze code wordt in de FitNesse-wereld 'Fixture' genoemd.

Armaturen zijn niets anders dan de voorbeeldcode - of een koppeling tussen FitNesse en de te testen applicatie. Dus wanneer we een methode willen testen, moeten we een fixture schrijven en deze fixture zal de methode aanroepen en testen.

Dus de 'Fixture' -code voor ons voorbeeld is als volgt:

​

De code in eclips wordt weergegeven als: (klik op afbeelding voor vergrote weergave)

fitnesse6

We hebben het class-bestand nodig, dus zorg ervoor dat je het compileert.

Je test schrijven in FitNesse:

Stap 1) Laten we teruggaan naar de browser waar we de FitNesse-voorpagina hebben.

Klik op de voorpagina op 'Testpagina', voer de naam van de test in en klik op de knop 'Opslaan'. In ons geval is het ‘Calculator’

FitNesse6

Stap 2) Voeg in uw URL een punt 'toe' aan de naam van uw test. Operator.

Leuk vinden: http: // localhost: 2222 / FrontPage.Calculator

FitNesse7

Stap 3) Klik op de knop Bewerken en voer de onderstaande regels in

FitNesse8

Hier zijn de ingevoerde regels:

! definieer TEST_SYSTEM {slim}

! pad F: Eclipse TestFitness bin

! | Rekenmachine |

| eerste | tweede | optellen? | min? | vermenigvuldigen? | delen? |

| 4 | 2 | 6 | 2 | 8 | 2.0 |

| 10 | 5 | 15 | 5 | 50 | 2,0 |

hoe apk-bestanden op Windows te openen

| 10 | 10 | 20 | 0 | 100 | 1,0 |

Laten we de regels een voor een begrijpen.

naar) De eerste regel zegt FitNesse om SLIM-testsysteem te gebruiken.

​ SLANK - Staat voor Simple List Invocation Method. Door SLIM-testsysteem te zeggen, wordt alle tafelverwerking gedaan door FitNesse. SLIM heeft SLIM Runner en SLIM Executer. SLIM Runner verdeelt de testpagina's in eenvoudige instructies en deze instructies worden doorgegeven aan SLIM Executer die de fixture-code opdracht geeft om het te testen systeem op te roepen)

b) De tweede regel definieert de locatie van het klassenbestand. In dit geval wordt de Java-code gecompileerd en wordt het klassenbestand bewaard op locatie 'pad F: Eclipse TestFitness bin​

c) Op de derde regel staat de naam van de klasse. In ons geval is het “Rekenmachine​

d) Nu komt de vierde regel:

De eerste twee kolommen| eerste | tweede |zijn de parameters of de invoer van de java-methode.

De volgende 4 kolommen die worden gevolgd door '?'optellen? | min? | vermenigvuldigen? | delen? | zijn de methoden in de java-klasse. Deze methoden retourneren een waarde die zou worden vergeleken met de verwachte waarden.

is) De lijnen:

| 4 | 2 | 6 | 2 | 8 | 2.0 |

| 10 | 5 | 15 | 5 | 50 | 2,0 |

| 10 | 10 | 20 | 0 | 100 | 1,0 |

Zijn de testcases of ik zou moeten zeggen Testgegevens voor onze methode.

De eerste regel:

| eerste | tweede | optellen? | min? | vermenigvuldigen? | delen? |

| 4 | 2 | 6 | 2 | 8 | 2.0 |

Neemt 4 als de eerste parameter en 2 als de tweede parameter en geeft deze twee waarden door in de optelmethode van de java-klasse. De methode wordt uitgevoerd en levert een waarde op. Deze geretourneerde waarde wordt vergeleken met de verwachte waarde die is geschreven onder de 'optelling?' dat is| 6 |

Op dezelfde manier geeft FitNesse de eerste 2 parameters door in de min? Methode van de Java-klasse en retourneert een waarde. Deze waarde wordt vergeleken met de verwachte waarde | 2 |

Op dezelfde manier vermenigvuldigen? en verdelen? werkt door de waarden van de eerste en tweede parameter te nemen en geeft een waarde terug die wordt vergeleken met| 8 | 2.0 |respectievelijk

Op dezelfde manier worden de onderstaande 2 rijen (of ik zou zeggen de testgevallen) uitgevoerd.

| 10 | 5 | 15 | 5 | 50 | 2,0 |

| 10 | 10 | 20 | 0 | 100 | 1,0 |

Stap 4) Nadat u uw tests heeft bewerkt, klikt u op de knop Opslaan en uw pagina ziet er als volgt uit:

fitnesse9

Stap # 5) Om de tests uit te voeren, klikt u op de knop Test en we krijgen het resultaat als volgt: (klik op afbeelding voor vergrote weergave)

FitNesse10

Voor de eerste rij (wat ons eerste testgeval is), benadrukt de groene kleur dat de waarden, geretourneerd door de methode add (), minus (), multiply () en divide (), overeenkomen met wat wordt verwacht, dwz 6, 2 , 8 en 2.0 respectievelijk. Evenzo komen voor de tweede rij (wat het tweede testgeval is) alle waarden die door de methoden worden geretourneerd, overeen.

Stap # 6) Om het te demonstreren, wil ik enkele van de verwachte waarden veranderen in een aantal andere waarden (de waarden zijn onjuist, maar ik heb het doelbewust gedaan voor uitleg)

FitNesse11

Vanaf nu heb ik:

  • De verwachte waarde voor toevoeging () voor het eerste testgeval is gewijzigd in 7
  • De verwachte waarde voor minus () gewijzigd voor de tweede testcase
  • De verwachte waarde voor divide () gewijzigd voor de derde testcase.

Stap # 7) Voer de test uit door op de knop 'Test' te klikken. De bovenstaande tests zouden moeten mislukken. (klik op afbeelding voor vergrote weergave)

FitNesse12

De rode kleur benadrukt dat deze tests zijn mislukt.

Enkele inzichten over armatuur- / tafelstijlen:

We hebben gezien dat In FitNesse de tests worden uitgevoerd door rijen in een tabel uit te voeren. Om verschillende soorten tests uit te voeren (of ik zou moeten zeggen om verschillende soorten methoden te testen), zouden we verschillende soorten tabellen moeten gebruiken. We gebruiken de onderstaande armatuur / tafelstijlen het vaakst:

  • Column armatuur - wordt het meest gebruikt (en wordt ook gebruikt in het bovenstaande voorbeeld). Hier vertegenwoordigen de rijen met gegevens verschillende sets invoer en de verwachte uitvoer.
  • Rij-armaturen - Het wordt gebruikt voor het testen van query's die een reeks waarden retourneren.
  • Actie-armaturen - Het wordt gebruikt om tests uit te voeren voor een reeks gebeurtenissen. Deze gebeurtenissen kunnen zijn zoals klikken op een knop, waarden controleren

Aanbeveling:

Ik heb geprobeerd de concepten te demonstreren, zodat we meer op FitNesse kunnen gaan verkennen. De mentaliteit van de tester moet ook worden veranderd en verbreed. We moeten onszelf niet langer beperken om in de code te kijken. Ik voel; uiteindelijk testen we de code, dus waarom proberen we de code niet te zien en ter plekke te testen?

Begin uw programmeervaardigheden aan te scherpen en leg de nadruk meer op het bouwen van de logica en liever op het leren van syntaxis. Als je eenmaal goed thuis bent in programmeerconcepten en ervaring hebt met het implementeren ervan, wordt het verkennen van FitNesse gemakkelijker.

Gevolgtrekking

Testen in Agile is er in 4 smaken:

  1. Geautomatiseerd testen van eenheden - door Junit te gebruiken
  2. Geautomatiseerde acceptatieverificatietest - Door FitNesse te gebruiken
  3. Geautomatiseerde UI / regressietests - met behulp van Selenium of QTP
  4. Handmatig testen

We moeten proberen om zoveel mogelijk van onze testen in de eenheid en de acceptatielaag te pushen ​Tot nu toe hebben we geprobeerd om de meeste van onze tests voor de UI-laag te behouden met behulp van tools als QTP en Selenium, maar het nadeel hiervan is dat deze functionaliteiten niet konden worden getest tenzij de UI werd ontwikkeld. Tegen de tijd dat u een defect ontdekt, zijn de ontwikkelaars overgegaan op een andere functie-ontwikkeling.

Aan de andere kant, als we de API's kunnen testen kort nadat ze zijn geschreven, kunnen ontwikkelaars dit direct repareren. Dit zou ook resulteren in minder inspanning wanneer we de GUI testen. Doordat alle functionaliteiten zijn getest, wordt het testen van de GUI eenvoudig.

Met Agile heeft de mentaliteit van testers ook een verandering nodig en ze moeten uit hun routineset van testen komen en nu moet je naar de code kijken en proberen defecten te identificeren, zelfs als de gebruikersinterface niet beschikbaar is.

Over de auteur: Dit is een gastartikel van STH-teamlid Shilpa C. Roy. Ze heeft de afgelopen 9 jaar op het gebied van softwaretesten gewerkt in domeinen als internetreclame, investeringsbankieren en telecom.

Laat ons uw vragen weten in de opmerkingen hieronder.

Aanbevolen literatuur

^