Basisfunctioneel testen met de Crawler van Symfony 2

Het testen van uw webtoepassingen is een van de beste dingen die u kunt doen om de gezondheid, veiligheid en beveiliging te garanderen, zowel voor de app als voor de bezoekers van uw app. Symfony 2 biedt een complete test suite voor integratie testen die u kunt gebruiken om ervoor te zorgen dat uw applicaties worden uitgevoerd zoals u verwacht. Vandaag zullen we bekijken hoe we Symfony 2 en PHPUnit, het testraamwerk dat het gebruikt, kunnen gebruiken om basisfunctionaaltests te schrijven met behulp van de Crawler.

Installatie

Voordat we kunnen beginnen met testen, kunnen we ons project instellen door het Symfony 2-framework te downloaden, het te configureren en vervolgens ook PHPUnit te downloaden.. 

Symfony 2 installeren

De beste manier om Symfony 2 te downloaden is door Composer te gebruiken. Als je nog niet weet wat Composer is, vergeet dan niet om een ​​paar van de geweldige Tuts + -artikelen en -cursussen erop te bekijken, ze brengen je snel op snelheid. 

We willen eerst onze Terminal- of opdrachtregelinterface openen, zodat we een paar opdrachten voor componisten kunnen geven. Eenmaal in uw Terminal, verander mappen in de webroot van uw lokale ontwikkeling. Voor mij is dit OS op mijn computer ~ / Sites directory:

cd ~ / Sites

Als we eenmaal in de juiste directory staan, kunnen we Composer nu gebruiken om een ​​nieuw Symfony 2-project te maken dat het framework plus afhankelijkheden van Symphony 2 zal downloaden en installeren. 

componist create-project symfony / framework-standard-edition crawling / '~ 2.5'

Deze opdracht vertelt componist om een ​​nieuw project te maken met behulp van het Symfony 2-raamwerk in een nieuwe mapnaam kruipen/, en dan specificeren we ook de exacte versie om te downloaden, versie ~ 2.5. Als dit de eerste keer is dat u het framework downloadt, kan dit een tijdje duren omdat er veel bibliotheken zijn om te downloaden voor alle leveranciers. Misschien wilt u even een korte pauze nemen en binnen een paar minuten terugkomen. 

Nadat de download is voltooid, geeft uw terminal nu een interactieve wizard weer die u helpt bij het instellen van de configuratie. Het spreekt voor zich, voer gewoon je eigen inloggegevens in of neem de standaardinstellingen zoals ik heb gedaan:

Nadat u uw configuratie-informatie hebt ingevoerd, wordt Symfony 2 gedownload, geïnstalleerd en klaar voor gebruik. Nu moeten we gewoon PHPUnit krijgen, zodat we onze code kunnen testen.

PHPUnit installeren

Om PHPUnit te downloaden, kunnen we een wget-opdracht in onze Terminal gebruiken om de .phar bestand of gewoon downloaden van hun website, het is aan jou:

wget https://phar.phpunit.de/phpunit.phar

Met de .phar gedownload, moeten we nu de machtigingen aanpassen en deze naar een locatie verplaatsen waar onze terminal of opdrachtregel staat en PHP heeft er toegang toe. Op mijn computer met OS X heb ik dit naar mijn verplaatst / Usr / local / bin directory. Ik hernoemde ook het bestand om rechtvaardig te zijn PHPUnit dus ik hoef me geen zorgen te maken over de extensie wanneer ik mijn tests probeer uit te voeren, wat me een beetje tijd bespaart:

chmod + x phpunit.phar sudo mv phpunit.phar / usr / local / bin / phpunit

We zouden nu moeten kunnen verifiëren dat PHPUnit is geïnstalleerd en toegankelijk is via de Terminal door het PHPUnit commando. Je zou zoiets als dit moeten zien:

De kruipbundel maken

Nu hebben we een bundel nodig voor onze applicatie- en testcode. Laten we er een aanmaken met de console van Symfony 2, vanuit onze Terminal:

cd ~ / Sites / crawling php-app / console genereren: bundle --namespace = Crawling / FtestingBundle --format = yml

Hier veranderen we eerst mappen in onze kruipen project en gebruik vervolgens de console om een ​​nieuwe bundel te genereren. We geven ook de naam van de leverancier en de bundel op, gescheiden door een schuine streep (/). Ten slotte vertellen we het YAML te gebruiken als het formaat voor onze configuratie. U kunt nu elke gewenste indeling gebruiken als u YAML niet wilt gebruiken en u kunt uw bundel desgewenst ook een naam geven, net zo lang als u deze eerst een leveranciersnaam geeft en uw bundelnaam eindigt met het achtervoegsel Bundel.

Na het uitvoeren van de bovenstaande opdracht, krijgen we weer een leuke wizard om de bundelinstallatie te voltooien. Ik heb gewoon op enter gereageerd voor elke prompt om de standaardinstellingen te nemen, omdat dit het hele proces leuk en eenvoudig houdt en eventuele padproblemen oplost door je bestanden op aangepaste locaties te plaatsen. Hier is een screenshot van mijn bundelwizard:

Hoe u uw testen uitvoert

Ok, we hebben Symfony 2, PHPUnit en onze bundel; Ik denk dat we nu klaar zijn om te leren hoe we onze PHPUnit-tests naast Symfony kunnen uitvoeren. Het is eigenlijk heel gemakkelijk, verander eenvoudig van mappen naar jouw kruipen project en geef het phpunit -c app / opdracht om alle tests van uw toepassing uit te voeren. U zou het volgende resultaat moeten krijgen in uw Terminal:

Toen we onze bundel genereerden, genereerde deze ook een kleine voorbeeldcode voor ons. De test die hierboven wordt weergegeven, is onderdeel van die voorbeeldcode. U kunt zien dat we een groene balk hebben en ons laten weten dat onze tests zijn geslaagd. Nu precies boven de Tijd: 1,97 seconden, we hebben ook een enkele punt die ons laat zien dat slechts één test is uitgevoerd. In de groene balk hebben we onze status OK evenals hoeveel tests en beweringen werden uitgevoerd. 

Dus door alleen deze ene opdracht uit te voeren, weten we dat onze Symfony 2-app is geïnstalleerd, correct werkt en wordt getest! 

Een controller, sjabloon en route maken

We hebben nu een aantal echte applicatiecode nodig die we kunnen testen. 

De controller

Laten we beginnen met het maken van een nieuw controllerklassebestand en controlleractie. Binnenin je kruipen project, onder src / Crawling / FtestingBundle / Controller, maak een nieuw bestand met de naam CrawlingController.php en voeg er het volgende in:

In dit bestand definiëren we alleen onze basiscontrollerklassenstructuur, waardoor deze de juiste naamruimte krijgt en de noodzakelijke naam bevat controleur ouderklasse. 

De controlleracties

Binnenin onze klas definiëren we nu onze twee eenvoudige controlleracties. Ze gaan gewoon twee verschillende pagina's weergeven: a huis pagina en een anders pagina:

public function homeAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: home.html.twig');  openbare functie otherAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: other.html.twig'); 

De sjablonen

Nu moeten we de sjabloonbestanden maken voor deze controlleracties. Onder src / Crawling / Ftesting / Resources / views, maak een nieuwe map met de naam Kruipen om onze te houden CrawlingControllersjabloonbestanden. Maak binnen eerst het home.html.twig bestand, met de volgende HTML erin:

Crawling Home Page

Dit is onze kruipende startpagina.

Bezoek ook deze andere pagina!

Dit bevat alleen wat standaard HTML en een link naar de anders pagina.

Ga nu door en maak het other.html.twig bestand, met deze HTML erin:

Andere pagina

Hier is nog een pagina, waarnaar werd verwezen vanaf onze startpagina, alleen voor testdoeleinden.

De routes

Ten slotte, voor onze applicatiecode, laten we de routes voor deze twee pagina's definiëren. Doe open src / Crawling / FtestingBundle / Resources / config / routing.yml en voer de volgende twee routes in, onder de standaard gegenereerde route die bij ons routebestand is geleverd:

crawling_home: pad: / crawling / standaardinstellingen: _controller: CrawlingFtestingBundle: Crawling: home crawling_other: pad: / crawling / andere standaardinstellingen: _controller: CrawlingFtestingBundle: Crawling: other

Hier definieer ik twee routes, één voor elk van onze controlleracties. We beginnen met de naam van de route, die we kunnen gebruiken in koppelingen, enz ... en dan specificeren we het route-pad dat zijn URI is om toegang te krijgen tot de pagina in de browser, en dan vertellen we welke controller het ook zou moeten toewijzen.

Onthoud nu dat u met YAML geen tabbladen wilt gebruiken, altijd spaties wilt gebruiken of dat uw routes niet werken!

Met deze twee pagina's kunnen we dus nog leren, zelfs met hoe eenvoudig en statisch ze zijn veel over het gebruik van de Crawler van Symfony 2 om te testen of het volledige spectrum van het hebben van een controller, sjabloon, route en koppelingen, werkt als een geïntegreerd geheel (een functionele test), en zorg ervoor dat onze pagina's de juiste HTML-structuur weergeven. 

Een functionele test schrijven

We zijn nu klaar om te beginnen met het leren schrijven van functionele tests met behulp van de Crawler. Eerst maken we een testbestand.

Ons testbestand maken

Al uw tests in Symfony 2, PHPUnit-tests worden opgeslagen in uw bundels Tests / Controller map Elke controller moet zijn eigen controller-testbestand hebben, genoemd naar de controllerklasse die wordt getest. Omdat we een hebben CrawlingController, we moeten een maken CrawlingControllerTest.php bestand binnen src / Crawling / FtestingBundle / Tests / Controller, met de volgende klassedefinitie:

Hier voeren we de naam van onze test in en nemen we op in de oudergroep van WebTestCase die ons onze PHPUnit-testfunctionaliteit geeft. Onze testklasse heeft precies dezelfde naam als onze bestandsnaam en we breiden de oudergroep van WebTestCase uit zodat we de kenmerken ervan erven..

Laten we nu een testmethode maken voor onze beweringen die we zullen doen om onze startpagina te testen. Laten we binnen onze testklasse de volgende methode maken:

public function testHome () 

Telkens wanneer u een testmethode maakt met PHPUnit in Symfony 2, geven we altijd de naam van onze methode de woordtest. U kunt de naam van de methode zelf elke naam geven die u wilt, hoewel de conventie deze moet benoemen na de controlleractie die u test. Dus hier heb ik de mijne genoemd testHome om die conventie te volgen.

De cliënt

Nu hebben we binnen onze testmethode een manier nodig om een ​​browser te simuleren, zodat we een HTTP-verzoek kunnen verzenden naar een van onze routes en kunnen testen of alles werkt zoals we verwachten. Om dit te doen, zullen we een cliëntobject maken door een statisch te bellen createClient () methode:

$ client = static :: createClient ();

We kunnen dit nu gebruiken $ client object om dat HTTP-verzoek te maken en de Crawler te gaan gebruiken.

The Crawler

De Crawler vormt de kern van functioneel testen in Symfony 2 en stelt ons in staat om informatie over de pagina van onze webapplicatie te doorlopen en acties uit te voeren zoals klikken op koppelingen of het indienen van formulieren. Laten we ons Crawler-object definiëren door een HTTP-verzoek te doen met behulp van de client. Voeg het volgende recht toe onder uw $ client object, in jouw testHome methode:

$ crawler = $ client-> request ('GET', '/ crawling / home');

Hiermee wordt een Crawler-object geretourneerd om onze startpagina te testen. Dit laat ons zowel weten dat onze pagina bestaat, het heeft de juiste HTML en opmaak en dat de controller, sjabloon en route allemaal werken als een eenheid.  

De koers en alinea testen

Om onze functionele testen te beginnen, willen we beweren dat onze startpagina de juiste kop bevat met de juiste inhoud erin. We gebruiken onze $ crawler object en de verschillende methoden om dit te doen. Deze methoden retourneren allemaal een ander Crawler-object dat de reactie van de geteste pagina bevat. We zullen dit antwoord vervolgens testen om ervoor te zorgen dat alles verloopt zoals verwacht.

Voeg de volgende code toe aan uw testHome methode:

$ heading = $ crawler-> filter ('h1') -> eq (0) -> text (); $ this-> assertEquals ('Crawling Home Page', $ heading);

We beginnen met ons te bellen $ crawler voorwerpen filter() methode om het antwoord van de pagina te filteren en alles te selecteren h1 elementen. We kunnen dan op andere methodeaanroepen ketenen om onze selectie nog verder te filteren. Hier gebruik ik de eq () methode die een indexpositie van het h1-element accepteert dat we willen selecteren. Ik koos ervoor om de index te selecteren 0, de eerste rubriek. Ten slotte, ik keten op de aanroep van de tekstmethode, die de tekstinhoud van dit HTML-element teruggeeft en het resultaat opslaat in een variabele $ heading.

Na het filteren van het h1-element waarvoor we willen testen, moeten we nu beweren dat we het juiste element hebben. We doen dit met behulp van de assertEquals () methode die als eerste argument de waarde accepteert die we verwachten dat de kop heeft, en als het tweede argument de werkelijke waarde van de geretourneerde reactie, die onze $ kop zelf is. Door dit te doen weten we dat we op de juiste pagina staan, als de inhoud overeenkomt met wat we verwachten dat het is.

De koerstest uitvoeren

Met slechts vier eenvoudige regels PHP-code kunnen we onze controller, sjabloon en route testen. Laten we onze test uitvoeren om ervoor te zorgen dat deze slaagt. In je Terminal, vanuit je kruipen Symfony-project, uitvoeren phpunit -c app /. Je zou het volgende moeten zien:

Hier hebben we nu twee tests en twee beweringen, die allemaal voorbijgaan! Nu kun je op dezelfde manier testen voor de enkele alinea onder de kop, maar deze keer gebruiken we de eerste(), methode, zoals deze:

$ para1 = $ crawler-> filter ('p') -> eerste () -> tekst (); $ this-> assertEquals ("Dit is onze kruipende startpagina.", $ para1);

Als u uw tests opnieuw uitvoert, hebben we nu drie passerende beweringen. Goed gedaan!

Testen Klikken op een link

Laten we nu eens proberen het proces uit te proberen door op onze andere paginakoppeling te klikken. Het moet ons naar de andere pagina brengen en daar ook de juiste inhoud weergeven. Voeg de volgende code in uw testHome methode:

$ link = $ crawler-> filter ('a: contains ("this other page")') -> first () -> link (); $ otherPage = $ client-> klik ($ link); $ this-> assertEquals ('Other Page', $ otherPage-> filter ('h1') -> first () -> text ());

We beginnen met het filteren van onze startpagina met een -tags. Wij gebruiken de : Bevat () filtermethode om de te filteren een tags op basis van hun inhoud, dus we zorgen ervoor dat u de juiste link selecteert. We ketenen dan gewoon op de eerste() methode om de eerste te pakken en de link() methode erop om een ​​koppelingsobject te maken, zodat we het kunnen simuleren door erop te klikken met behulp van onze $ client.

Nu dat we een hebben $ koppeling object, we moeten erop klikken, door het te gebruiken $ client voorwerpen Klik() methode en doorgeven in de $ koppeling er bezwaar tegen hebben en het antwoord terug opslaan in de $ otherPage variabel. Dit is net als elk ander Crawler-object, de klikmethode retourneert het antwoord. Erg makkelijk!

En ten slotte beweren we dat onze $ otherPage's koptekst is gelijk aan wat we verwachten dat het de assertEquals () methode. Als dat zo is, weten we dat onze link werkt!

Voer de laatste keer een test uit!

Laten we onze tests nu nog een laatste keer uitvoeren om ervoor te zorgen dat onze link correct werkt en dat we op de juiste pagina staan ​​nadat erop is geklikt. Hier zijn mijn Terminal-resultaten:

We hebben twee tests en vier beweringen, die allemaal voorbijgaan. App voltooid!

Conclusie

En dat is het. We hebben getest dat onze controller, controlleracties, sjablonen en routes allemaal samenwerken en we weten dat de HTML en content voor elk element correct wordt weergegeven op de pagina, evenals dat onze link naar de juiste locatie linkt. Goed gedaan werk.

Ik moedig je nu aan om te proberen wat je hebt geleerd door het testen van de anders pagina, het toevoegen van meer HTML-code of koppelingen ernaar en meestal krijgt u gewoon het gevoel dat u de Crawler gebruikt om ervoor te zorgen dat uw pagina werkt zoals verwacht.