Uw React Native App testen (Part-1)

(21 dec.2020)

Inleiding

De meeste ontwikkelaars vinden testen saai en lastig om te schrijven, maar weet je wat? Er is veel vaardigheid en ervaring voor nodig om te weten hoe u zinvolle en onderhoudbare tests moet schrijven. De kennis die u opdoet door te leren hoe u uw code moet testen, zal ook de manier waarop u code schrijft in ontwikkeling veranderen. Dit artikel zou je moeten helpen om aan de slag te gaan met je testtraject.

Richtlijnen voor beter testen

Dit zijn enkele van de richtlijnen die ik heb geleerd nadat ik heb onderzocht hoe andere ontwikkelaars hun code testen. Door deze richtlijnen te volgen, werd het voor mij gemakkelijker om tests te schrijven en te onderhouden in de hele codebase.

1. Test de implementatie van uw code niet

Laten we een scenario doorlopen om te begrijpen waarom dit belangrijk is. Stel dat je een functie hebt geschreven die n als invoer moet nemen en het resultaat van het toevoegen van de eerste n nummers.

Laten we aannemen dat u getSumOfFirstN test op n=2 door te beweren dat add wordt genoemd 2 times met de argumenten (0, 2) en (2, 1) respectievelijk en de uitvoer van getSumOfFirstN is 3.

Later kom je erachter dat er een betere manier is om de som van de eerste n nummers en herschrijf de bovenstaande code.

Je test zal beginnen te breken omdat je niet langer add

belt. Dit was een duidelijk voorbeeld, en dat is wat y het lijkt misschien contra-intuïtief, maar ik heb veel ontwikkelaars precies dit soort tests zien doen waarbij de fout niet zo gemakkelijk te zien is.

2. Laat uw tests niet een nieuwe technische schuld worden

Testen is belangrijk, maar u moet de code ook op tijd aan de relevante belanghebbenden leveren. Als wanneer u een nieuwe functie schrijft of een bestaande wijzigt, dit uw oude testcases verbreekt of als u een aanzienlijk deel van uw toegewezen tijd besteedt aan het repareren van oude testcases in plaats van aan het bouwen van de vereiste functies, dan zult u uiteindelijk verwijderen alle oude tests en het risico dat het project mislukt in productie.

Het volgen van deze richtlijnen zou u moeten helpen ervoor te zorgen dat uw tests ofwel gemakkelijk te repareren zijn of helemaal niet breken wanneer uw codebase verandert.

3. Schrijf bij het testen van de gebruikersinterface tests op een manier die het werkelijke gebruikersgedrag simuleert.

Stel dat u aan het testen bent of deze knop is weergegeven en werkt zoals verwacht of niet, bedenk dan eerst hoe de gebruiker deze knop zou vinden en ermee zou werken. Ik hoop dat ze de tekst Verzenden zien en erop drukken, en dat is dus precies wat we zouden simuleren. In ons testgeval zullen we eerst zoeken naar de tekst “Verzenden” en vervolgens de “onPress” -gebeurtenis erop simuleren en vervolgens bevestigen wat dat zou moeten doen.

In sommige gevallen is het misschien niet zo gemakkelijk om de component te identificeren die u wilt targeten, en in dat geval kunt u testID prop gebruiken, maar onthoud dat u niet het volledige gebruikersgedrag simuleert als u testID omdat gebruikers componenten niet targeten op basis van hun testID.

Waarom is dit belangrijk? Waarom moeten we proberen om gebruikersgedrag zoveel mogelijk te simuleren bij het testen van de gebruikersinterface? Dit komt omdat het uiteindelijk een mens zal zijn die interactie heeft met uw gebruikersinterface en niet een computer en als ze een Hallo zien worden weergegeven in uw knop in plaats van een Verzenden, zou uw testcase moeten mislukken omdat dat is iets dat de eindgebruiker kan afschrikken.

4. Pure functies zijn gemakkelijker te testen dan onzuivere functies

Pure functies zijn functies die altijd dezelfde output geven voor een corresponderende input, dwz als een pure functie eruit pompt 2 voor een 1 dan zou het dat altijd doen, terwijl onzuivere functies 2 bij de eerste oproep zouden kunnen wegpompen en vervolgens leegpompen 5 bij de tweede oproep.

Dit is handig om in gedachten te houden bij het schrijven van code. Onzuivere functies kunnen gemakkelijker te testen worden als de module die de “onzuiverheid” in dergelijke functies introduceert, bespottelijk is.

5.Gebruik fixtures als invoer en beweringen in uw tests

Stel dat u een object van het type werknemer heeft en er verschillende functies op werken, zoals een functie om de name, een functie om te controleren of de werknemer volwassen is of niet, enz.

Stel nu dat u dit object als invoer neemt in al uw testgevallen.

Dit zijn uw dummy-gegevens of uw “fixture”. In uw eerste testcase die test of de functie die de naam met een hoofdletter gebruikt werkt zoals verwacht of niet, beweert u dat de uitvoer gelijk is aan { ...employee, name: employee.name.toUpperCase() } en in uw tweede testcase beweert u of de functie employee.age >= 18 uitvoert of niet, enzovoort.

Je vraagt ​​je misschien af ​​welk voordeel we krijgen door fixtures op zon manier te gebruiken? Het antwoord is dat u het uzelf gemakkelijker maakt om in de toekomst tests snel op te lossen door uw tests op deze manier te schrijven.

Bijv. Wat als we nog een eigenschap maritalStatus in het werknemersobject willen toevoegen, omdat nu al onze werknemers hun burgerlijke staat moeten bekendmaken. Als we in ons eerste testgeval beweren dat de uitvoer gelijk is aan { name: "KARTIK", age: 25, sex: "Male", children: 0 } in plaats van { ...employee, name: employee.name.toUpperCase() }, zal ons testgeval breken. Het zal ook breken als we de waarde van name in iets anders veranderen. Met andere woorden, onze testcase zou helemaal niet flexibel zijn en zal daarom een ​​grotere kans hebben om te breken vanwege niet-gerelateerde veranderingen in de codebase.

6. Schrijf eenheidstests voor componenten en hulpprogramma-functies

Dit zijn delen van uw code die door meerdere modules zullen worden gebruikt. Daarom moeten ze worden getest op alle mogelijke inputs / edge-cases, omdat je niet weet hoe de andere modules deze functies / componenten zullen gebruiken. Daarom mogen deze geen onverwacht gedrag vertonen.

7. Schrijf integratietests voor schermen

Het is moeilijk om unit-tests voor schermen te schrijven, omdat deze meestal afhankelijk zijn van een groot aantal componenten en andere bibliotheken van derden, zoals een redux store. Om unit-tests voor schermen te schrijven, moet je dus eerst al deze afhankelijkheden bespotten, wat veel werk is. Daarom is het in dit geval beter om integratietests te schrijven.

7. Schrijf E2E-tests voor het testen van native code

Native code werkt niet in een grap-omgeving. Dus om het te testen, moet je een bibliotheek zoals Detox gebruiken.

8. Voer altijd snapshot-tests uit voor schermen en componenten

Als u een stijlwijziging aanbrengt in een component die door meerdere andere schermen / componenten wordt gebruikt, zullen de snapshot-tests daarvoor mislukken totdat u de snapshots bijwerkt. Het zal u helpen te begrijpen welke andere modules werden beïnvloed door de wijziging die u heeft aangebracht. Als je in een team werkt, helpt het de recensent tijdens PR-beoordelingen echt om te begrijpen welke modules werden beïnvloed door de specifieke wijziging die je in de component hebt aangebracht, omdat de wijzigingen in de snapshots van die modules worden weerspiegeld in je PR.

Conclusie

Ik hoop dat je dit artikel nuttig vond en als je in de war bent door wat je net hebt gelezen, maak je dan geen zorgen. Het tweede deel van deze serie zal een tutorial zijn over het opzetten van de testomgeving in React Native met codevoorbeelden van testschermen, componenten en functies, volgens de richtlijnen die we in dit eerste deel hebben opgesteld.

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *