Test in Laravel

Indipendentemente dall'applicazione che stai affrontando, il test è un aspetto importante e spesso sottovalutato che dovresti dare l'attenzione che merita. Oggi lo discuteremo nel contesto del framework web di Laravel.

In effetti, Laravel supporta già il framework di testing PHPUnit nel core stesso. PHPUnit è uno dei framework di test più popolari e ampiamente accettati in tutta la comunità PHP. Ti permette di creare entrambi i tipi di test-unità e funzionali.

Inizieremo con una introduzione di base ai test unitari e funzionali. Mentre andiamo avanti, esploreremo come creare test unitari e funzionali in Laravel. Presumo che tu abbia familiarità con le basi del framework PHPUnit mentre lo esploreremo nel contesto di Laravel in questo articolo.

Test unitari e funzionali

Se hai già familiarità con il framework PHPUnit, dovresti sapere che puoi dividere i test in due test di unità di sapori e test funzionali.

Nei test unitari, si verifica la correttezza di una determinata funzione o di un metodo. Ancora più importante, si prova un singolo pezzo della logica del codice in un dato momento.

Nel tuo sviluppo, se trovi che il metodo che hai implementato contiene più di un'unità logica, è meglio dividerlo in più metodi in modo che ogni metodo contenga una singola parte di codice logica e verificabile.

Diamo una rapida occhiata a un esempio che è un caso ideale per i test unitari.

funzione pubblica getNameAttribute (valore $) return ucfirst ($ value); 

Come puoi vedere, il metodo fa una sola cosa. Usa il ucfirst funzione per convertire un titolo in un titolo che inizia con lettere maiuscole.

Mentre il test unitario viene utilizzato per verificare la correttezza di una singola unità logica di codice, il test funzionale, d'altra parte, consente di verificare la correttezza di un caso d'uso specifico. Più specificamente, consente di simulare le azioni eseguite da un utente in un'applicazione per eseguire un caso d'uso specifico.

Ad esempio, è possibile implementare un caso di test funzionale per alcune funzionalità di accesso che potrebbero richiedere i seguenti passaggi.

• Creare la richiesta GET per accedere alla pagina di accesso.
• Controlla se siamo nella pagina di accesso.
• Genera la richiesta POST per inviare i dati alla pagina di accesso.
• Controlla se la sessione è stata creata correttamente.

Ecco come si suppone di creare il caso di test funzionale. Dalla prossima sezione in poi, creeremo degli esempi che dimostrano come creare casi di test unitari e funzionali in Laravel.

Impostazione dei prerequisiti

Prima di andare avanti e creare test effettivi, abbiamo bisogno di impostare un paio di cose che verranno utilizzate nei nostri test.

Creeremo il modello Post e la migrazione correlata per iniziare. Vai avanti ed esegui il seguente comando artigiano per creare il file Inviare modello.

$ php artisan make: modello Post - migrazione

Il comando precedente dovrebbe creare il Inviare modello di classe e una migrazione del database associato pure.

Il Inviare la classe del modello dovrebbe essere simile a:

E il file di migrazione del database dovrebbe essere creato su Database / migrazioni / YYYY_MM_DD_HHMMSS_create_posts_table.php.
Vogliamo anche memorizzare il titolo del post. Rivediamo il codice del Inviare file di migrazione del database per assomigliare al seguente.
incrementi ( 'id'); $ Tavola-> string ( 'name'); $ Tavola-> timestamp (); );  / ** * Invertire le migrazioni. * * @return void * / public function down () Schema :: dropIfExists ('posts'); 
Come puoi vedere, abbiamo aggiunto il $ Tavola-> string ( 'name') colonna per memorizzare il titolo del post. Quindi, è sufficiente eseguire il comando migrate per creare effettivamente quella tabella nel database.
$ php artisan migrate
Inoltre, sostituiamo il Inviare modello con i seguenti contenuti.
Abbiamo appena aggiunto il di accesso metodo, che modifica il titolo del post, ed è esattamente ciò che testeremo nel nostro caso di test unitario. Questo è fino al Inviare modello è interessato.
Successivamente, creeremo un file controller su App / HTTP / Controller / AccessorController.php. Ci sarà utile quando creeremo il caso di test funzionale in una fase successiva.
get ("id", 0); // carica il post richiesto $ post = Post :: find ($ post_id); // controlla la proprietà name return $ post-> name; 
Nel indice metodo, recuperiamo l'ID post dai parametri della richiesta e proviamo a caricare l'oggetto del modello post.
Aggiungiamo anche un percorso associato nel percorsi / web.php file.
Route :: get ('accessor / index', 'AccessorController @ index');
E con questo, puoi eseguire l'URL http://your-laravel-site.com/accessor/index per vedere se funziona come previsto.
Test unitario
Nella sezione precedente, abbiamo fatto la configurazione iniziale che ci sarà utile in questa sezione e nelle prossime sezioni. In questa sezione, creeremo un esempio che dimostra i concetti di unit test in Laravel.
Come sempre, Laravel fornisce un comando artigiano che consente di creare la classe template base del caso di test unitario.
Eseguire il seguente comando per creare il AccessorTest unità di test case class. È importante notare che stiamo passando il --unità parola chiave che crea il caso di test unitario e verrà inserito sotto test / Unità elenco.
$ php artisan make: test AccessorTest --unit
E quello dovrebbe creare la seguente classe a test / Unità / AccessorTest.php.
assertTrue (true); 
Sostituiamolo con un codice significativo.
nome); // carica post usando Eloquent $ model_post = Post :: find (1); $ model_post_title = $ model_post-> nome; $ this-> assertEquals ($ db_post_title, $ model_post_title); 
Come puoi vedere, il codice è esattamente lo stesso di quello che sarebbe stato nel core PHP. Abbiamo appena importato le dipendenze specifiche di Laravel che ci consentono di utilizzare le API richieste. Nel testAccessorTest metodo, dovremmo testare la correttezza del getNameAttribute metodo del Inviare modello.
Per fare ciò, abbiamo recuperato un post di esempio dal database e preparato l'output previsto in $ db_post_title variabile. Successivamente, carichiamo lo stesso post usando il modello Eloquent che esegue il getNameAttribute metodo anche per preparare il titolo del post. Finalmente, usiamo il assertEquals metodo per confrontare entrambe le variabili come al solito.
Ecco come preparare i casi di test unitari in Laravel.
Test funzionali
In questa sezione creeremo il test case funzionale che verifica la funzionalità del controller che abbiamo creato in precedenza.
Eseguire il seguente comando per creare il AccessorTest classe di test case funzionale. Dato che non stiamo usando il --unità parola chiave, verrà trattato come un caso di test funzionale e inserito sotto test / Caratteristica elenco.
$ php artisan make: test AccessorTest
Creerà la seguente classe a test / funzione / AccessorTest.php.
assertTrue (true); 
Sostituiamolo con il seguente codice.
nome); $ response = $ this-> get ('/ accessor / index? id = 1'); $ Response-> assertStatus (200); $ Response-> assertSeeText ($ db_post_title); 
Ancora una volta, il codice dovrebbe sembrare familiare a coloro che hanno una precedente esperienza nel test funzionale.
In primo luogo, stiamo recuperando un post di esempio dal database e preparando l'output previsto in $ db_post_title variabile. In seguito, proviamo a simulare il / Di accesso / index? Id = 1 OTTENERE la richiesta e afferrare la risposta di tale richiesta in $ risposta variabile.
Successivamente, abbiamo cercato di far corrispondere il codice di risposta nel file $ risposta variabile con il codice di risposta previsto. Nel nostro caso, dovrebbe essere 200 poiché dovremmo ottenere una risposta valida per la nostra richiesta GET. Inoltre, la risposta dovrebbe contenere un titolo che inizia con lettere maiuscole, ed è esattamente ciò che stiamo cercando di abbinare usando il assertSeeText metodo.
E questo è un esempio del caso di test funzionale. Ora, abbiamo tutto ciò su cui potremmo eseguire i nostri test. Andiamo avanti ed eseguiamo il seguente comando nella root della tua applicazione per eseguire tutti i test.
$ PHPUnit
Questo dovrebbe eseguire tutti i test nella tua applicazione. Dovresti vedere un output PHPUnit standard che visualizza lo stato dei test e delle asserzioni nella tua applicazione.
E con questo, siamo alla fine di questo articolo.
Conclusione
Oggi abbiamo esplorato i dettagli dei test in Laravel, che già supporta PHPUnit nel suo nucleo. L'articolo è iniziato con un'introduzione di base ai test di unità e funzionali e, mentre procedevamo, abbiamo esplorato le specifiche dei test nel contesto di Laravel.
Nel processo, abbiamo creato una manciata di esempi che hanno dimostrato come è possibile creare casi di test unitari e funzionali utilizzando il comando artisan.
Se hai appena iniziato con Laravel o stai cercando di espandere le tue conoscenze, il tuo sito o la tua applicazione con le estensioni, abbiamo una varietà di cose che puoi studiare nel mercato di Envato.
Non esitare a esprimere i tuoi pensieri usando il feed qui sotto!



		
			
	   
	




Codice