Testare le tue applicazioni web è una delle migliori cose che puoi fare per assicurarti salute, sicurezza e sicurezza, sia per l'app che per i visitatori della tua app. Symfony 2 offre una suite di test di integrazione completa che puoi utilizzare per assicurarti che le tue applicazioni vengano eseguite esattamente come ti aspetti. Oggi vedremo come possiamo usare Symfony 2 e PHPUnit, il framework di testing che impiega, per scrivere test funzionali di base usando il Crawler.

Installazione

Prima di iniziare qualsiasi tipo di test, impostiamo il nostro progetto scaricando il framework Symfony 2, configurandolo e scaricando anche PHPUnit. 

Installazione di Symfony 2

Il modo migliore per scaricare Symfony 2 è usare Composer. Se non sai ancora cosa sia il compositore, assicurati di controllare alcuni fantastici articoli e corsi su Tuts +, ti aggiorneranno rapidamente. 

Prima di tutto vorremmo aprire il nostro terminale o l'interfaccia della riga di comando in modo da poter emettere alcuni comandi di composizione. Una volta nel tuo terminale, cambia le directory nel webroot del tuo sviluppo locale. Per me, su OS X, questo sarà il mio ~ / siti directory:

cd ~ / Sites

Una volta nella giusta directory, ora possiamo usare Composer per creare un nuovo progetto Symfony 2 che scaricherà e installerà il framework più qualsiasi delle sue dipendenze. 

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

Questo comando dice al compositore di creare un nuovo progetto usando il framework Symfony 2 in un nuovo nome di directory strisciando /, e poi stiamo anche specificando la versione esatta da scaricare, versione ~ 2.5. Se questa è la prima volta che scarichi il framework, questo potrebbe richiedere un po 'di tempo perché ci sono un sacco di librerie da scaricare per tutti i fornitori. Quindi potresti voler fare una breve pausa e tornare tra pochi minuti. 

Al termine del download, il terminale dovrebbe ora visualizzare una procedura guidata interattiva che ti aiuterà a configurare la configurazione. È molto intuitivo, basta inserire le proprie credenziali o prendere le impostazioni predefinite come ho fatto io:

Dopo aver inserito le informazioni di configurazione, Symfony 2 viene scaricato, installato e pronto per essere utilizzato. Ora abbiamo solo bisogno di ottenere PHPUnit per poter testare il nostro codice.

Installazione di PHPUnit

Per scaricare PHPUnit possiamo usare un comando wget nel nostro Terminale per recuperare il .phar file o semplicemente scaricarlo dal loro sito Web, tocca a voi:

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

Con il .phar scaricato, ora abbiamo bisogno di modificare le sue autorizzazioni e spostarlo in una posizione in cui il nostro terminale o riga di comando e PHP avrà accesso ad esso. Sulla mia macchina che utilizza OS X, l'ho spostato nel mio / Usr / local / bin directory. Ho anche rinominato il file per essere giusto PHPUnit quindi non devo preoccuparmi dell'estensione quando provo a eseguire i miei test, risparmiando un po 'di tempo:

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

Ora dovremmo essere in grado di verificare che PHPUnit sia stato installato ed è accessibile tramite il Terminale eseguendo il PHPUnit comando. Dovresti vedere qualcosa di simile a questo:

Creazione del pacchetto di scansione

Ora abbiamo bisogno di un pacchetto per contenere la nostra applicazione e il codice di prova. Creiamo uno utilizzando la console di Symfony 2, dal nostro terminale:

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

Qui, prima cambiamo le directory nel nostro strisciando progetto e quindi utilizzare la console per generare un nuovo pacchetto. Specifichiamo anche il nome del fornitore e del bundle di questo bundle, separati da una barra (/). Infine, diciamo di usare YAML come formato per la nostra configurazione. Ora puoi usare qualsiasi formato desideri se non vuoi usare YAML e puoi anche nominare il tuo bundle come preferisci, purché tu gli dia il nome di un venditore e termini il nome del bundle con il suffisso impacchettare.

Dopo aver eseguito il comando precedente, otteniamo di nuovo una procedura guidata per completare l'installazione del pacchetto. Ho appena premuto invio per ogni prompt di prendere le impostazioni predefinite in quanto questo mantiene l'intero processo semplice e semplice e appianare eventuali problemi di percorso mettendo i file in posizioni personalizzate. Ecco uno screenshot del mio mago:

Come eseguire i tuoi test

Ok, abbiamo Symfony 2, PHPUnit e il nostro pacchetto; Penso che ora siamo pronti per imparare come eseguire i nostri test PHPUnit insieme a Symfony. In realtà è davvero facile, basta cambiare directory nel tuo strisciando progettare e rilasciare il phpunit -c app / comando per eseguire tutti i test dell'applicazione. Dovresti ottenere il seguente risultato nel tuo terminale:

Quando abbiamo generato il nostro pacchetto, abbiamo generato anche un piccolo codice di esempio per noi. Il test che vedi sopra è parte di quel codice di esempio. Puoi vedere che abbiamo una barra verde, facendoci sapere che i nostri test sono passati. Ora proprio sopra il Tempo: 1,97 secondi, abbiamo anche un singolo punto che ci mostra che è stato eseguito un solo test. Nella barra verde abbiamo il nostro stato di ok così come quanti test e asserzioni sono stati eseguiti. 

Quindi, eseguendo solo questo comando, sappiamo che la nostra app Symfony 2 è installata, funzionante e testata! 

Creazione di un controller, modello e percorso

Ora abbiamo bisogno di un codice di applicazione reale che possiamo testare. 

Il controller

Iniziamo creando un nuovo file di classe controller e un'azione controller. Dentro il tuo strisciando progetto, sotto src / Strisciare / FtestingBundle / regolatore, crea un nuovo file chiamato CrawlingController.php e inserire il seguente in esso:

In questo file definiamo semplicemente la nostra struttura di base del controller di classe, dandogli il namespace corretto e includendo il necessario controllore classe genitore. 
Le azioni del controller
All'interno della nostra classe, definiamo ora le nostre due semplici azioni del controllore. Renderanno solo due pagine diverse: a casa pagina e un altro pagina:
public function homeAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: home.html.twig');  public function otherAction () return $ this-> render ('CrawlingFtestingBundle: Crawling: other.html.twig'); 
I modelli
Ora dobbiamo creare i file modello per queste azioni del controller. Sotto src / Strisciare / Ftesting / Resources / views, crea una nuova directory chiamata crawling per mantenere il nostro CrawlingControllerI file del modello. Dentro, prima crea il home.html.twig file, con il seguente codice HTML all'interno:
Pagina iniziale della scansione
 
Ecco la nostra home page di scansione.
 
Si prega di visitare anche quest'altra pagina!
Questo contiene solo HTML di base e un link al altro pagina.
Ora vai avanti e crea il other.html.twig file, con questo HTML all'interno:
Altra pagina
 
Ecco un'altra pagina, a cui è stato collegato dalla nostra home page, solo a scopo di test.
I percorsi
Infine, per il nostro codice applicativo, definiamo i percorsi per queste due pagine. Aprire src / Strisciare / FtestingBundle / Resources / config / routing.yml e inserisci le seguenti due rotte, sotto il percorso generato di default fornito con il nostro file di percorso:
crawling_home: percorso: / crawling / home defaults: _controller: CrawlingFtestingBundle: Scansione: home crawling_other: percorso: / crawling / altri valori predefiniti: _controller: CrawlingFtestingBundle: Scansione: altro
Qui definisco due percorsi, uno per ciascuna delle azioni del nostro controller. Iniziamo con il nome delle rotte, che possiamo usare nei collegamenti, ecc ... e quindi specifichiamo il percorso dei percorsi che è il suo URI per accedere alla pagina nel browser, e poi diciamo a quale controller deve mappare anche.
Ora ricorda con YAML che non vuoi usare alcuna scheda, usa sempre spazi o le tue rotte non funzioneranno!
Quindi, con solo queste due pagine, anche se sono semplici e statiche, possiamo ancora imparare Un sacco su come usare Crawler di Symfony 2 per verificare che l'intero spettro di avere un controller, template, route e link funzionino come un intero integrato (un test funzionale), oltre a garantire che le nostre pagine mostrino la struttura HTML corretta. 
Scrivere un test funzionale
Ora siamo pronti per iniziare a imparare come scrivere test funzionali usando il Crawler. Innanzitutto, creeremo un file di test.
Creare il nostro file di prova
Tutti i tuoi test in Symfony 2, i test PHPUnit sono memorizzati nel tuo bundle Test / controller directory Ogni controller deve avere il proprio file di test del controller chiamato dopo la classe controller che sta testando. Dal momento che abbiamo un CrawlingController, avremo bisogno di creare un CrawlingControllerTest.php file all'interno src / Strisciare / FtestingBundle / Test / controller, con la seguente definizione di classe:
Qui assegniamo il namespace al nostro test e quindi includiamo nella classe genitore WebTestCase fornendoci la nostra funzionalità di test PHPUnit. La nostra classe di test è identificata esattamente come il nostro nome di file e estendiamo la classe genitore WebTestCase in modo che ereditiamo le sue caratteristiche.
Ora creiamo un metodo di prova per sostenere le nostre asserzioni che faremo per testare la nostra home page. All'interno della nostra classe di test, creiamo il seguente metodo:
funzione pubblica testHome () 
Ogni volta che crei un metodo di test usando PHPUnit in Symfony 2, il prefisso del nostro metodo viene sempre preceduto dal test del testo. Puoi dare al nome del metodo stesso il nome che desideri, anche se la convenzione è il nome dopo l'azione del controller che stai testando. Quindi, qui ho chiamato il mio testHome seguire quella convenzione.
Il cliente
Ora all'interno del nostro metodo di test abbiamo bisogno di un modo per simulare un browser in modo che possiamo inviare una richiesta HTTP a uno dei nostri percorsi e verificare che tutto funzioni come ci aspettiamo. Per fare ciò creeremo un oggetto client chiamando una statica createClient () metodo:
$ client = static :: createClient ();
Ora possiamo usare questo $ cliente oggetto di fare quella richiesta HTTP e iniziare a utilizzare il crawler.
Il cingolato
Il crawler è al centro dei test funzionali in Symfony 2 e ci consente di attraversare e raccogliere informazioni sulla nostra pagina dell'applicazione web, nonché di eseguire azioni come fare clic sui link o inviare moduli. Definiamo il nostro oggetto Crawler facendo una richiesta HTTP usando il client. Aggiungi il seguente sotto il tuo $ cliente oggetto, nel tuo testHome metodo:
$ crawler = $ client-> request ('GET', '/ crawling / home');
Ciò restituirà un oggetto Crawler per testare la nostra home page. Questo ci permetterà di sapere che la nostra pagina esiste, ha il codice HTML e la formattazione corretti e che il controller, il modello e il percorso funzionano tutti come un'unità.  
Testare l'intestazione e il paragrafo
Per iniziare i nostri test funzionali, vogliamo affermare che la nostra home page contiene la corretta intestazione con i contenuti corretti al suo interno. Usiamo il nostro $ crawler oggetto e i suoi vari metodi per farlo. Questi metodi restituiranno tutti un altro oggetto Crawler che contiene la risposta effettiva della pagina testata. Quindi testeremo questa risposta per garantire che tutto sia come previsto.
Aggiungi il seguente codice al tuo testHome metodo:
$ heading = $ crawler-> filter ('h1') -> eq (0) -> text (); $ this-> assertEquals ('Crawling Home Page', $ heading);
Iniziamo chiamando il nostro $ crawler oggetto di filtro() metodo per filtrare la risposta della pagina e selezionare tutto h1 elementi. Possiamo quindi concatenare altre chiamate di metodo per filtrare ulteriormente la nostra selezione. Qui uso il eq () metodo che accetta una posizione di indice dell'elemento h1 che vogliamo selezionare. Ho scelto di selezionare l'indice 0, la prima intestazione. Infine, collego la chiamata al metodo testo, che restituirà il contenuto del testo di questo elemento HTML e memorizzerà il risultato in una variabile $ heading.
Dopo aver filtrato l'elemento h1 che vogliamo testare, ora dobbiamo affermare che abbiamo l'elemento corretto. Lo facciamo usando il assertEquals () metodo che accetta come primo argomento il valore che ci aspettiamo che l'intestazione abbia, e come secondo argomento, il valore effettivo della risposta restituita, che è la nostra intestazione $ stessa. In questo modo sapremo che siamo sulla pagina corretta, se il contenuto corrisponde a ciò che ci aspettiamo che sia.
Esecuzione del test di direzione
Quindi con solo quattro semplici linee di codice PHP, saremo in grado di testare il nostro controller di casa, il modello e il percorso. Facciamo il test per assicurarci che passi. Nel tuo terminale, dal tuo strisciando Progetto Symfony, corri phpunit -c app /. Dovresti vedere quanto segue:
Qui ora abbiamo due test e due asserzioni, che stanno passando! Ora puoi testare per il singolo paragrafo sotto l'intestazione in modo simile, ma questa volta useremo il primo(), metodo, come questo:
$ para1 = $ crawler-> filter ('p') -> first () -> text (); $ this-> assertEquals ("Ecco la nostra home page di scansione.", $ para1);
Se riesegui i test, ora abbiamo tre asserzioni. Buon lavoro!
Test di clic su un collegamento
Ora proviamo a testare il processo di fare clic sul nostro altro link di questa pagina. Dovrebbe portarci sull'altra pagina e visualizzare anche i contenuti corretti. Inserisci il seguente codice nel tuo testHome metodo:
$ link = $ crawler-> filter ('a: contains ("questa altra pagina")') -> first () -> link (); $ otherPage = $ client-> click ($ link); $ this-> assertEquals ('Other Page', $ otherPage-> filter ('h1') -> first () -> text ());
Iniziamo filtrando la nostra home page di un tag. Noi usiamo il : Contiene () metodo di filtro per filtrare il un tag in base al loro contenuto, quindi ci assicuriamo di selezionare il link corretto. Abbiamo quindi solo catena sul primo() metodo per afferrare il primo e chiamare il Link () metodo su di esso per creare un oggetto link in modo che possiamo simulare cliccarci sopra usando il nostro $ cliente.
Ora che abbiamo un $ link oggetto, dobbiamo fare clic su di esso, chiamando il $ cliente oggetto di clic() metodo e passando nel $ link obiettare ad esso e memorizzare la risposta nel $ otherPage variabile. Questo è proprio come qualsiasi altro oggetto Crawler, il metodo click restituisce la risposta. Molto facile!
E infine, affermiamo solo che il nostro $ otherPageIl testo dell'intestazione è uguale a quello che ci aspettiamo utilizzi il assertEquals () metodo. Se lo è, sappiamo che il nostro link funziona!
Esegui i tuoi test un'ultima volta!
Eseguiamo ora i nostri test un'ultima volta per assicurarci che il nostro link funzioni correttamente e che siamo sulla pagina corretta dopo aver fatto clic su di esso. Ecco i risultati del mio terminale:
Abbiamo due test e quattro asserzioni, che stanno passando. App completa!
Conclusione
E questo è tutto. Abbiamo verificato che il nostro controller, le azioni del controller, i modelli e le rotte funzionano tutti insieme e sappiamo che l'HTML e il contenuto di ogni elemento sono visualizzati correttamente nella pagina, così come il nostro link, link alla posizione corretta. Lavoro ben fatto.
Ora ti incoraggio a provare ciò che hai imparato testando il altro pagina, aggiungendo altro HTML o collegamenti ad esso, e in generale solo un'idea dell'utilizzo del crawler per garantire che la pagina funzioni come previsto. 



		
			
	   
	




Codice