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.
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..
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.
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:
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:
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!
We hebben nu een aantal echte applicatiecode nodig die we kunnen testen.
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 eenanders
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 naamKruipen
om onze te houdenCrawlingController
sjabloonbestanden. Maak binnen eerst hethome.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: otherHier 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 hebbenCrawlingController
, we moeten een makenCrawlingControllerTest.php
bestand binnensrc / 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 jouwtestHome
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
voorwerpenfilter()
methode om het antwoord van de pagina te filteren en alles te selecterenh1
elementen. We kunnen dan op andere methodeaanroepen ketenen om onze selectie nog verder te filteren. Hier gebruik ik deeq ()
methode die een indexpositie van het h1-element accepteert dat we willen selecteren. Ik koos ervoor om de index te selecteren0
, 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, uitvoerenphpunit -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 filtereneen
tags op basis van hun inhoud, dus we zorgen ervoor dat u de juiste link selecteert. We ketenen dan gewoon op deeerste()
methode om de eerste te pakken en delink()
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
voorwerpenKlik()
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 deassertEquals ()
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.