Eerste stapjes met Jasmine

Vandaag is een goed moment om ontwikkelaar te zijn in JavaScriptHet kan gezegd worden dat het zelfs opwindend is omdat de technologieën die het omvat behoorlijk volwassen zijn geworden, webbrowsers meer gestandaardiseerd zijn en elke dag meer nieuwe dingen verschijnen om mee te spelen en te experimenteren.
JavaScript is een gevestigde taal en het web is tegenwoordig het belangrijkste platform, waar we de opkomst hebben gezien van toepassingen met één pagina, de verspreiding van MVC-frameworks zoals AngularJS of Backbone.js, met behulp van server-side JavaScript met Node.js en zelfs mobiele applicaties die uitsluitend zijn gemaakt met HTML, CSS Y JavaScript met technologieën zoals TelefoonGap.
Vanaf het bescheiden begin heeft JavaScript de leiding gehad om als taal te dienen om de gegevens te manipuleren en te valideren in de formulieren in HTML en op dit moment wordt het gebruikt om de krachtige applicaties te bouwen die we op internet kunnen zien. Als je dit ziet, kun je zeggen dat JavaScript Het heeft een lange weg afgelegd, evenals de tools die zijn verschenen om ervoor te zorgen dat we dezelfde kwaliteit hebben als in andere talen.
Een van deze tools is: Jasmijn, wat niets meer is dan een gedragsgericht ontwikkelingskader en waarmee we geautomatiseerde unit-tests voor de programmeertaal kunnen maken JavaScript. Voordat we volledig met deze tool beginnen, laten we de achtergrond bekijken die tot de ontwikkeling heeft geleid, evenals de belangrijkste concepten om te begrijpen hoe het werkt JavaScript.
Vandaag twijfelt niemand aan de kracht van JavaScriptEr zijn echter complicaties bij het werken aan de kant van de klant en een van de voor de hand liggende redenen is dat we de uitvoeringsomgeving niet kunnen beheersen. Op de server hebben we dit probleem niet omdat we een specifieke versie van kunnen draaien Node.js maar in het geval van de webbrowser kunnen we de gebruiker niet vertellen om een ​​specifieke versie van te gebruiken Chroom of Firefox.
De taal JavaScript is gedefinieerd onder de specificaties ECMAScript dus elke browser kan zijn eigen implementatie van de omgeving hebben om het uit te voeren, waardoor er kleine verschillen of bugs tussen hen kunnen zijn. Elk object van JavaScript het is veranderlijk, dus we hebben geen enkele vorm van controle om te voorkomen dat een module delen van anderen overschrijft, om dit te illustreren laten we eens kijken naar een klein codesegment waar we kunnen zien hoe gemakkelijk het is om de globale functie te overschrijven console.log:

 console.log ('test'); console.log = 'pauze'; console.log ('test');

Laten we het antwoord per console bekijken, waar we de fout duidelijk kunnen zien omdat we de functie hebben overschreven:

Deze manier van zijn van de taal was een beslissing die werd genomen in het ontwerp, omdat het ontwikkelaars in staat stelde ontbrekende functionaliteiten toe te voegen, maar gezien deze veelzijdigheid is het relatief gemakkelijker om fouten te maken, zelfs een recentere versie van de taal introduceerde de functie Object.zegel die dit verhinderde, maar de ondersteuning ervan werd slechts voor een paar browsers uitgebreid.
Een ander probleem dat we presenteren met JavaScript is de afhandeling van typen, in andere talen zal een uitdrukking als '1' + 1 waarschijnlijk een fout opleveren, maar in JavaScript dit zou resulteren in 11. Dit kan leiden tot een paar moeilijk te vinden problemen, bijvoorbeeld als we het volgende hebben:

 var a = 1, b = '5', c = 4, d = 2; var resultaat = a + b + c * d; console.log (resultaat);

Laten we het antwoord via de console bekijken wanneer we onze code in de browser uitvoeren:

Zoals we kunnen zien, was het resultaat een string, dus als we een getal in een speciale functie of routine verwachtten, kan dit een probleem veroorzaken en het vinden van deze fout kan betekenen dat we een paar uur van onze kostbare ontwikkelingstijd verspillen.
Het is belangrijk om te vermelden dat de punten die we zojuist hebben genoemd geen reden zijn om niet te gebruiken JavaScriptHet is gewoon om te zien waar het enkele zwakke punten heeft, maar dit betekent niet dat het een slechte taal is, we kunnen zelfs verzekeren dat de mogelijkheden die het ons biedt oneindig zijn in termen van applicatie-ontwikkeling en wat nog beter is, we hebben nog steeds tools die wij zullen ze helpen met de best practices van hetzelfde.
Zoals we al zeiden, Jasmijn Het is een klein raamwerk dat ons helpt met onze unit-tests binnen onze ontwikkelingen en dat gebruik maakt van de filosofie van gedragsgerichte ontwikkeling die we later zullen uitleggen, maar voordat we verder gaan, laten we een belangrijk concept zien en dat is dat het unit-tests zijn.
EenheidstestenDe eenheidstests Het zijn stukjes code die de functionaliteiten van de units in de code van onze applicatie testen, waarbij de ontwikkelaar aan het begin van dit pad een traditionele filosofie achterliet die gericht was op testgericht ontwikkelen in plaats van gedragsgericht.
Daarom hebben de makers van Jasmijn ze herstructureren deze traditionele manier van testen, waarbij de ontwikkelaar geen duidelijk beeld had van waar te beginnen in het testproces, niet wetende wat te testen en hoe groot een testmodule zou kunnen zijn of zelfs wat ze een van deze tests zouden noemen . Als we bijvoorbeeld de filosofie van Jasmijn Stel dat we, om de tests uit te voeren, een muziekspeler hebben die de volgende acceptatiecriteria heeft: Gezien de speler, wanneer een nummer is gepauzeerd, moet de speler aangeven dat het nummer is gepauzeerd.
Dus we kunnen het criterium nemen en het als volgt verdelen:

• Gegeven (een eerste context)
• Wanneer (de gebeurtenis vindt plaats)
• Dan (er wordt actie ondernomen)

Jasmijn stelt ons in staat om het bovenstaande te vertalen in een code die zal worden geschreven op een manier die de waarden van onze applicatie zonder problemen weerspiegelt, die er als volgt uit kan zien:

 beschrijven ("Speler", functie () {beschrijven ("Als het nummer is gepauzeerd", functie () {it ("Het moet aangeven dat het nummer is gepauzeerd", functie () {});});});

Zoals we kunnen zien, zijn onze criteria overgebracht naar Jasmijn zonder veel moeite, waarbij we kunnen zeggen dat elk criterium wordt vertaald in een unit-test.
We konden alvast kijken hoe Jasmijn het behandelt de criteria en vertaalt ze in zijn syntaxis en creëert de unit-tests ervoor, maar om daar te komen, laten we eerst kijken hoe we het raamwerk eerst kunnen krijgen. Hiervoor gaan we naar de projectpagina en downloaden deze:

VERGROTEN

Bij het uitpakken moeten we naar de map gaan dist, daar vinden we alle distributies van Jasmijn tot nu toe, waar we het gaan gebruiken, moeten we de gewenste distributie selecteren, bij voorkeur de meest recente en deze uitpakken in de map van ons project, de map invoeren en het bestand uitvoeren SpecRunner.html:

Jasmijn Het bevat standaard enkele voorbeelden van enkele eenheidstests, waarbij het bestand SpecRunner.html is verantwoordelijk voor het koppelen van de Jasmine-code die de bronbestanden en de testbestanden bevat, laten we de inhoud ervan bekijken:

 Jasmine Spec Runner v2.2.0 

Zoals we kunnen zien, is het vrij eenvoudig en stelt het ons in staat om een ​​basisstructuur voor onze tests te definiëren, wat ons een idee geeft waar te beginnen in deze wereld van unittests. Het spreekt voor zich dat het een goed idee is om een ​​kijkje te nemen in de code van onze distributie van Jasmijn om ons vertrouwd te maken met de manier waarop het werkt.
Het is belangrijk om te vermelden dat Jasmijn niet alleen beperkt tot code geschreven met pure JavaScript, we kunnen die applicaties testen die zijn gebouwd met Backbone.js of AngularJS, zelfs zijn veelzijdigheid gaat veel verder en stelt ons in staat om server-side tests uit te voeren in het geval dat we gebruiken Knooppunt.js.
AanbevelingJasmijn Het is een raamwerk dat ons veel helpt bij het testen van eenheden, maar de concepten die erin worden gebruikt zijn niet zo eenvoudig, het wordt ondersteund door bepaalde geavanceerde praktijken van JavaScript zoals het genereren van de HTML met behulp van de functie createDom () om de elementen erin in te voegen, om enkele van deze kenmerken te noemen, dus raden we aan een wandeling door de documentatie van . te maken JavaScript om veel beter voorbereid te zijn op toekomstige tutorials.
Hiermee hebben we deze tutorial afgerond, waar we onze eerste stappen mee konden zetten Jasmijn, een beetje door de motivatie lopen om tools te maken om op te testen JavaScript en hoe gedragsgerichte ontwikkeling ons helpt om betere tests te maken, ook om te zien hoe Jasmijn is een redelijk flexibel framework voor testen, waardoor we dezelfde instantie kunnen gebruiken om allerlei soorten code te testen in JavaScript in onze toepassingen.