Testing av webapplikasjonene dine er en av de beste tingene du kan gjøre for å sikre sin helse, sikkerhet og sikkerhet, både for appen og appens besøkende. Symfony 2 tilbyr en komplett integreringstestpakke som du kan bruke til å sikre at programmene dine går som du forventer. I dag ser vi på hvordan vi kan bruke Symfony 2 og PHPUnit, testrammen som den bruker, for å skrive grunnleggende funksjonstester ved hjelp av Crawler.

Installasjon

Før vi kan starte noen form for testing, la oss sette opp vårt prosjekt ved å laste ned Symfony 2-rammen, konfigurere det og deretter også laste ned PHPUnit. 

Installere Symfony 2

Den beste måten å laste ned Symfony 2 på er å bruke Komponist. Hvis du ennå ikke vet hva Composer er, pass på å sjekke ut noen av de fantastiske Tuts + artiklene og kursene på den, så tar de deg raskt opp. 

Vi vil først åpne vårt Terminal- eller kommandolinjegrensesnitt, slik at vi kan utstede noen komposittkommandoer. En gang i Terminal, bytt kataloger til din lokale utviklings webroot. For meg, på OS X, vil dette være min ~ / nettsteder katalogen:

cd ~ / Nettsteder

En gang i riktig katalog kan vi nå bruke Komponist til å lage et nytt Symfony 2-prosjekt som vil laste ned og installere rammen pluss noen av dens avhengigheter. 

komponent create-project symfony / rammeverk-standard-utgave gjennomgang / '~ 2,5'

Denne kommandoen forteller komponist for å lage et nytt prosjekt ved hjelp av Symfony 2-rammen i et nytt katalognavn krypende /, og så spesifiserer vi også den nøyaktige versjonen for nedlasting, versjon ~ 2,5. Hvis dette er første gang du laster ned rammen, kan det ta litt tid siden det er mange biblioteker som skal lastes ned for alle leverandørene. Så du vil kanskje ta en rask pause og komme tilbake om noen få minutter. 

Etter at nedlastingen er ferdig, bør Terminal nå vise en interaktiv veiviser som hjelper deg med å konfigurere konfigurasjonen. Det er veldig selvforklarende, bare skriv inn din egen legitimasjon eller ta standardverdiene som jeg har gjort:

Når du har angitt konfigurasjonsinformasjonen din, lastes Symfony 2 ned, installeres og er klar til bruk. Nå trenger vi bare å få PHPUnit, så vi kan teste vår kode.

Installere PHPUnit

For å laste ned PHPUnit kan vi bruke en wget-kommando i Terminal for å hente .Phar fil eller bare last ned den fra deres hjemmeside, er det opp til deg:

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

Med .Phar lastet ned, nå må vi justere sine tillatelser og flytte den til et sted der vår terminal eller kommandolinje og PHP vil ha tilgang til det. På min maskin med OS X flyttet jeg dette inn i min / Usr / local / bin katalogen. Jeg endret også filen til å være rett PHPUnit så jeg trenger ikke å bekymre meg for utvidelsen når jeg prøver å kjøre testene mine, og sparer meg litt tid:

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

Vi bør nå kunne verifisere at PHPUnit ble installert og er tilgjengelig via Terminal ved å kjøre PHPUnit kommando. Du bør se noe slikt:

Opprette krypteringspakken

Nå trenger vi et bunt for å holde vår søknad og testkode. La oss lage en som bruker Symfony 2-konsollen, fra vår terminal:

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

Her bytter vi først kataloger inn i vår kryp prosjekt og bruk deretter konsollen til å generere et nytt bunt. Vi spesifiserer også dette buntens leverandør- og buntnavn, skilt av et fremoverstrekk (/). Til slutt forteller vi det å bruke YAML som formatet for vår konfigurasjon. Nå kan du bruke hvilket som helst format du vil ha hvis du ikke vil bruke YAML, og du kan også nevne buntet ditt, men du foretrekker det, så lenge du først gir det et leverandørnavn og avslutter buntnavnet ditt med suffikset Bunt.

Etter å ha kjørt kommandoen ovenfor, får vi igjen en fin veiviser for å hjelpe til med å fullføre buntinstallasjonen. Jeg har nettopp slått på Enter for hver ledetekst for å ta standardinnstillingene, da dette holder hele prosessen fin og enkel og jevner ut eventuelle problemer med banen ved å sette filene dine på egendefinerte steder. Her er et skjermbilde av min pakkeveiviser:

Slik kjører du testene dine

Ok, vi har Symfony 2, PHPUnit og vårt bunt; Jeg tror vi er klar til å lære å kjøre våre PHPUnit-tester sammen med Symfony. Det er faktisk veldig enkelt, bare endre kataloger til din kryp prosjekt og utgitt phpunit -c app / kommandoen for å kjøre alle programmets tester. Du bør få følgende resultat i Terminal:

Da vi genererte vår pakke, genererte den også en liten prøvekode for oss. Testen du ser løp over er en del av denne prøven. Du kan se at vi har en grønn bar, som forteller oss at våre tester passerte. Nå rett over Tid: 1,97 sekunder, Vi har også en enkelt prikk som viser oss at bare en test ble spilt. I den grønne linjen har vi statusen vår OK så vel som hvor mange tester og påstander som ble spilt. 

Så ved å kjøre bare denne kommandoen vet vi at vår Symfony 2 app er installert, kjører riktig og testet! 

Opprette en kontroller, mal og rute

Vi trenger nå en faktisk kode som vi kan teste. 

Kontrolleren

La oss starte med å opprette en ny kontroller klassefil og kontroller handling. Innsiden av din kryp prosjekt, under src / Crawling / FtestingBundle / Controller, opprett en ny fil som heter CrawlingController.php og sett inn følgende i det:

I denne filen definerer vi bare vår grunnleggende kontrollerklassestruktur, og gir den det riktige navneområdet og inkludert det nødvendige Controller foreldre klasse. 
Controller Actions
Inne i vår klasse, la oss nå definere våre to enkle kontrollerhandlinger. De skal bare gjengi to forskjellige sider: a hjem side og an annen side:
offentlig funksjon homeAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: home.html.twig');  offentlig funksjon otherAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: other.html.twig'); 
Maler
Nå må vi lage malfiler for disse kontrolleringshandlingene. Under src / Crawling / Ftesting / Resources / visninger, opprett en ny katalog som heter Crawling å holde vår CrawlingControllers malfiler. Inside, først opprett home.html.twig fil, med følgende HTML inne:
Gjennomsøker Hjemmeside
 
Her er vår gjennomsøkingsside.
 
Vennligst besøk denne siden også!
Dette inneholder bare noen grunnleggende HTML og en link til annen side.
Nå også gå videre og opprett other.html.twig fil, med denne HTML inne:
Annen side
 
Her er en annen side, som var koblet til fra vår hjemmeside, bare for testing.
Rutene
Til slutt, for vår søknadskode, la oss definere ruter for disse to sidene. Åpne opp src / Crawling / FtestingBundle / Resources / config / routing.yml og skriv inn i følgende to ruter, under den standardgenererte ruten som fulgte med vår rutefil:
crawling_home: path: / crawling / home standard: _controller: CrawlingFtestingBundle: Crawling: home crawling_other: sti: / crawling / andre standardinnstillinger: _controller: CrawlingFtestingBundle: Crawling: other
Her definerer jeg to ruter, en for hver av våre kontrollerhandlinger. Vi starter med rutenavnet, som vi kan bruke i koblinger, etc ... og deretter angir vi rutebanen som er dens URI for å få tilgang til siden i nettleseren, og så forteller vi hvilken kontroller den skal kartlegge.
Husk nå med YAML at du ikke vil bruke noen faner, bruk alltid mellomrom eller ruter vil ikke fungere!
Så med bare disse to sidene, selv med hvor grunnleggende og statiske de er, kan vi fortsatt lære mye om hvordan du bruker Symfony 2s Crawler for å teste at hele spekteret av å ha en kontroller, mal, rute og koblinger fungerer som en integrert helhet (en funksjonell test), samt sørge for at sidene viser riktig HTML-struktur. 
Skrive en funksjonstest
Vi er nå klar til å begynne å lære å skrive funksjonelle tester ved hjelp av Crawler. Først skal vi opprette en testfil.
Opprette vår testfil
Alle tester i Symfony 2, PHPUnit-tester lagres i buntens Tester / Controller katalog Hver kontroller skal ha sin egen kontroller-testfil oppkalt etter kontrollerklassen som den tester. Siden vi har en CrawlingController, vi må opprette en CrawlingControllerTest.php fil innsiden src / Crawling / FtestingBundle / tester / Controller, med følgende klasses Definisjon:
Her navngir vi vår test og inneholder deretter i WebTestCase foreldreklassen som gir oss vår PHPUnit testfunksjonalitet. Vår testklasse heter nøyaktig det samme som vårt filnavn, og vi utvider forgrunnsklassen WebTestCase slik at vi arver dens egenskaper.
La oss nå lage en testmetode for å holde våre påstander som vi skal gjøre for å teste ut vår hjemmeside. Inne i vår testklasse, la oss lage følgende metode:
offentlig funksjon testHome () 
Når du oppretter en testmetode ved hjelp av PHPUnit i Symfony 2, prefixer vi alltid metodenavnet vårt med ordtesten. Du kan gi metodenavnet seg selv et hvilket som helst navn du vil ha, selv om konvensjonen er å navngi den etter kontrollerens handling du tester. Så her, jeg har kalt min testHome å følge denne konvensjonen.
Klienten
Nå inne i testmetoden vår trenger vi en måte å simulere en nettleser på, slik at vi kan utstede en HTTP-forespørsel til en av våre ruter og teste at alt fungerer som vi forventer det. For å gjøre dette skal vi opprette et klientobjekt ved å ringe en statisk createClient () metode:
$ client = static :: createClient ();
Vi kan nå bruke dette $ klient motsette seg å gjøre HTTP-forespørselen og begynne å bruke Crawler.
The Crawler
Crawleren er kjernen i funksjonstesten i Symfony 2, og lar oss krysse og samle inn informasjon om vår nettsøknadsside, samt utføre handlinger som å klikke på koblinger eller sende inn skjemaer. La oss definere vårt Crawler-objekt ved å lage en HTTP-forespørsel ved hjelp av klienten. Legg til følgende rett under din $ klient objekt, i din testHome metode:
$ crawler = $ klient-> forespørsel ('GET', '/ crawling / home');
Dette returnerer et Crawler-objekt for å teste vår hjemmeside. Dette vil både fortelle oss at siden vår eksisterer, den har riktig HTML og formatering, og at kontrolleren, malen og ruten alle fungerer som en enhet.  
Tester overskriften og avsnittet
For å starte våre funksjonstester, vil vi påstå at vår hjemmeside inneholder riktig overskrift med riktig innhold inni det. Vi bruker vår $ crawler objekt og dets forskjellige metoder for å gjøre dette. Disse metodene vil alle returnere tilbake et annet Crawler-objekt til oss som inneholder den faktiske testte sideens respons. Vi vil deretter teste dette svaret for å sikre at alt er som forventet.
Legg til følgende kode i din testHome metode:
$ heading = $ crawler-> filter ('h1') -> eq (0) -> tekst (); $ this-> assertEquals ('Crawling Home Page', $ heading);
Vi begynner med å ringe vår $ crawler objektets filter() metode for å filtrere sidens svar og velg alle h1 elementer. Vi kan da kjede på andre metallsamtaler for å filtrere utvalget vårt enda lenger. Her bruker jeg eq () metode som aksepterer en indeksposisjon av h1-elementet vi ønsker å velge. Jeg valgte å velge indeks 0, den første overskriften. Til slutt kjører jeg på tekstmetodeanropet, som vil returnere dette HTML-elementets tekstinnhold og lagre resultatet i en $ overskriftsvariabel.
Etter å ha filtrert h1-elementet som vi vil teste for, må vi nå hevde at vi har det riktige elementet. Vi gjør dette ved hjelp av assertEquals () metode som aksepterer som det første argumentet verdien vi forventer at overskriften skal ha, og som det andre argumentet, den faktiske verdien av det returnerte svaret, som er vår $ overskrift selv. Ved å gjøre dette, vet vi at vi er på riktig side, hvis innholdet samsvarer med det vi forventer at det skal være.
Kjører overskriftstesten
Så med bare fire enkle linjer med PHP-kode, kan vi teste vår hjemme-kontroller, mal og rute. La oss kjøre testen vår for å sikre at den passerer. I din terminal, fra din side kryp Symfony-prosjektet, løp phpunit -c app /. Du bør se følgende:
Her har vi nå to tester og to påstander, som alle passerer! Nå kan du teste for det enkle avsnittet under overskriften på en lignende måte, men denne gangen bruker vi først(), metode, slik:
$ para1 = $ crawler-> filter ('p') -> første () -> tekst (); $ this-> assertEquals ("Her er vår gjennomsøkingsside.", $ para1);
Hvis du gjør om testene dine, har vi nå tre forbigående påstander. Godt jobbet!
Testing Klikk på en lenke
La oss nå prøve å teste ut prosessen med å klikke på denne siden for denne andre siden. Det burde ta oss til den andre siden og vise det riktige innholdet der også. Sett inn følgende kode i din testHome metode:
$ link = $ crawler-> filter ('a: contains ("denne andre siden")') -> first () -> link (); $ otherPage = $ klient-> klikk ($ link); $ this-> assertEquals ('Other Page', $ otherPage-> filter ('h1') -> første () -> tekst ());
Vi starter med å filtrere vår hjemmeside ved en tags. Vi bruker : Inneholder () filter metode for å filtrere en koder ved innholdet deres, så vi sørger for å velge riktig kobling. Vi kjeder bare på først() metode for å ta tak i den første og ringe til kobling () Metode på det å opprette et koblingsobjekt slik at vi kan simulere klikke på den ved hjelp av vår $ klient.
Nå som vi har a $ lenke objekt, vi må klikke på det ved å ringe $ klient objektets Klikk () metode og passerer i $ lenke motsette seg det og lagre svaret tilbake i $ otherPage variabel. Dette er akkurat som alle andre Crawler-objekter, og klikmetoden returnerer svaret. Meget lett!
Og så til slutt, hevder vi bare at vår $ otherPageOverskriftsteksten er lik det vi forventer at den skal bruke assertEquals () metode. Hvis det er, vet vi at vår lenke fungerer!
Kjør testene dine en gang!
La oss nå kjøre testene våre en engangs tid for å sikre at vår lenke fungerer riktig, og at vi er på riktig side etter å ha klikket på den. Her er mine Terminalresultater:
Vi har to tester og fire påstander, som alle passerer. Appen er fullført!
Konklusjon
Og det er det. Vi har testet at våre kontroller, kontrollerhandlinger, maler og ruter alle virker sammen, og vi vet at HTML og innhold for hvert element vises riktig på siden, samt at vår lenke, koblinger til riktig sted. Jobb godt utført.
Jeg oppfordrer deg nå til å prøve ut det du har lært, ved å teste ut annen side, legger til flere HTML eller lenker til det, og får vanligvis en følelse av å bruke Crawler for å sikre at siden din fungerer som forventet. 



		
			
	   
	




Kode