Testen in Laravel

Ongeacht de applicatie waar u mee te maken hebt, testen is een belangrijk en vaak over het hoofd gezien aspect dat u de aandacht moet geven die het verdient. Vandaag gaan we het bespreken in de context van het Laravel-webraamwerk.

In feite ondersteunt Laravel het PHPUnit-testraamwerk al in de kern zelf. PHPUnit is een van de meest populaire en algemeen aanvaarde testkaders in de PHP-community. Hiermee kunt u beide soorten tests-eenheid en functioneel maken.

We beginnen met een basisinleiding voor unit- en functionele testen. Naarmate we verdergaan, zullen we onderzoeken hoe we unit- en functionele tests kunnen maken in Laravel. Ik neem aan dat je bekend bent met de basisprincipes van het PHPUnit-framework, zoals we dit in de context van Laravel in dit artikel zullen onderzoeken.

Eenheid en functionele tests

Als u al bekend bent met het PHPUnit-framework, moet u weten dat u tests kunt verdelen in twee smaken: unit tests en functionele tests.

In eenheidscontroles test u de juistheid van een bepaalde functie of een methode. Wat nog belangrijker is, u test een enkel stuk van de logica van uw code op een bepaald moment.

Als u in uw ontwikkeling vindt dat de methode die u hebt geïmplementeerd meer dan één logische eenheid bevat, kunt u dat beter opsplitsen in meerdere methoden, zodat elke methode één logisch en toetsbaar stuk code bevat.

Laten we snel een voorbeeld bekijken dat een ideaal geval is voor unit-testen.

openbare functie getNameAttribute ($ value) return ucfirst ($ value); 

Zoals je kunt zien, doet de methode maar één ding. Het gebruikt de ucfirst functie om een ​​titel om te zetten in een titel die begint met een hoofdletter.

Terwijl de eenheidstest wordt gebruikt om de juistheid van een enkele logische code-eenheid te testen, kunt u met de functietest aan de andere kant de juistheid van een specifieke use-case testen. Meer specifiek kunt u hiermee acties simuleren die een gebruiker in een toepassing uitvoert om een ​​specifieke use-case uit te voeren.

U kunt bijvoorbeeld een functionele testcase voor enkele aanmeldingsfunctionaliteit implementeren die de volgende stappen kan omvatten.

• Maak het GET-verzoek om toegang te krijgen tot de inlogpagina.
• Controleer of we op de inlogpagina staan.
• Genereer de POST-aanvraag om gegevens naar de inlogpagina te verzenden.
• Controleer of de sessie met succes is gemaakt.

Dus dat is hoe je de functionele testcase zou moeten maken. In de volgende sectie zullen we voorbeelden maken die laten zien hoe eenheid en functionele testgevallen in Laravel kunnen worden gemaakt.

De vereisten instellen

Voordat we doorgaan en echte tests maken, moeten we een aantal dingen instellen die in onze tests zullen worden gebruikt.

We zullen het Post-model en de gerelateerde migratie creëren om mee te beginnen. Ga je gang en voer het volgende artisan-commando uit om het te maken Post model-.

$ php artisan make: model Post --migration

Het bovenstaande commando zou het moeten maken Post modelklasse en een bijbehorende databasemigratie.

De Post modelklasse moet er als volgt uitzien:

En het database-migratiebestand zou moeten worden aangemaakt bij databank / migraties / YYYY_MM_DD_HHMMSS_create_posts_table.php.
We willen ook de titel van de post opslaan. Laten we de code van de Post databasemigratiebestand om er als volgt uit te zien.
verhogingen ( 'id'); $ Tafel-> string ( 'name'); $ Tafel-> timestamps (); );  / ** * Keer de migraties terug. * * @return void * / public function down () Schema :: dropIfExists ('berichten'); 
Zoals u kunt zien, hebben we het $ Tafel-> string ( 'name') kolom om de titel van het bericht op te slaan. Vervolgens moet u de opdracht Migratie uitvoeren om die tabel daadwerkelijk in de database te maken.
$ php artisan migreren
Laten we ook de Post model met de volgende inhoud.
We hebben zojuist het accessor methode, die de titel van het bericht wijzigt, en dat is precies wat we zullen testen in onze eenheidstestcase. Dat is het voor zover als het Post model betreft.
Vervolgens maken we een controllerbestand aan app / Http / Controllers / AccessorController.php. Het is nuttig voor ons wanneer we de functionele testcase in een later stadium maken.
get ("id", 0); // laad de gevraagde post $ post = Post :: find ($ post_id); // controleer de eigenschap name return $ post-> name; 
In de inhoudsopgave methode, halen we de post-id op uit de verzoekparameters en proberen we het post-modelobject te laden.
Laten we ook een bijbehorende route toevoegen in de routes / web.php het dossier.
Route :: get ('accessor / index', 'AccessorController @ index');
En met dat op zijn plaats, kunt u de http://your-laravel-site.com/accessor/index URL uitvoeren om te zien of het werkt zoals verwacht.
Testen van een eenheid
In het vorige gedeelte hebben we de eerste installatie gedaan die nuttig zal zijn voor ons in deze en de komende secties. In deze sectie gaan we een voorbeeld maken dat de concepten van unit testing in Laravel demonstreert.
Zoals altijd biedt Laravel een ambachtelijke opdracht waarmee u de basismarkerklasse van de unit-testcase kunt maken.
Voer de volgende opdracht uit om de. Te maken AccessorTest eenheid testklasse. Het is belangrijk op te merken dat we de --eenheid sleutelwoord dat de eenheidstestcase creëert, en het zal onder de worden geplaatst proeven / Unit directory.
$ php artisan make: test AccessorTest - eenheid
En dat zou de volgende klasse moeten creëren proeven / Unit / AccessorTest.php.
assertTrue (true); 
Laten we het vervangen door een betekenisvolle code.
naam); // laad bericht met behulp van Eloquent $ model_post = Post :: find (1); $ model_post_title = $ model_post-> naam; $ this-> assertEquals ($ db_post_title, $ model_post_title); 
Zoals u kunt zien, is de code precies hetzelfde als die in kern-PHP zou zijn geweest. We hebben zojuist Laravel-specifieke afhankelijkheden geïmporteerd waarmee we de vereiste API's kunnen gebruiken. In de testAccessorTest methode, we zijn verondersteld om de juistheid van de te testen getNameAttribute methode van de Post model-.
Om dat te doen, hebben we een voorbeeldpost opgehaald uit de database en de verwachte uitvoer voorbereid in de $ db_post_title variabel. Vervolgens laden we dezelfde post met behulp van het Eloquent-model dat de getNameAttribute methode ook om de titel van het bericht voor te bereiden. Ten slotte gebruiken we de assertEquals methode om beide variabelen zoals gebruikelijk te vergelijken.
Dus dat is hoe je eenheidstestgevallen moet voorbereiden in Laravel.
Functioneel testen
In deze sectie maken we de functionele testcase die de functionaliteit test van de controller die we eerder hebben gemaakt.
Voer de volgende opdracht uit om de. Te maken AccessorTest functionele testcase klasse. Omdat we de. Niet gebruiken --eenheid sleutelwoord, het zal worden behandeld als een functionele testcase en onder de proeven / Feature directory.
$ php artisan make: test AccessorTest
Hiermee maak je de volgende les op proeven / Functie / AccessorTest.php.
assertTrue (true); 
Laten we het vervangen door de volgende code.
naam); $ response = $ this-> get ('/ accessor / index? id = 1'); $ Response-> assertStatus (200); $ Response-> assertSeeText ($ db_post_title); 
Nogmaals, de code moet bekend voorkomen bij mensen die ervaring hebben met functioneel testen.
Ten eerste halen we een voorbeeldbericht uit de database en bereiden we de verwachte uitvoer voor in de $ db_post_title variabel. Hierna proberen we het te simuleren / Accessor / index? Id = 1 GET verzoek en pak de reactie van dat verzoek in de $ response veranderlijk.
Vervolgens hebben we geprobeerd de responscode in de $ response variabele met de verwachte responscode. In ons geval zou dit 200 moeten zijn, want we zouden een geldig antwoord moeten krijgen voor ons GET-verzoek. Verder moet het antwoord een titel bevatten die begint met een hoofdletter en dat is precies wat we proberen te matchen met de assertSeeText methode.
En dat is een voorbeeld van de functionele testcase. Nu hebben we alles waarmee we onze tests kunnen uitvoeren. Laten we doorgaan en de volgende opdracht uitvoeren in de hoofdmap van uw toepassing om alle tests uit te voeren.
$ PHPUnit
Dat zou alle tests in uw toepassing moeten uitvoeren. U zou een standaard PHPUnit-uitvoer moeten zien die de status van tests en beweringen in uw toepassing weergeeft.
En daarmee staan ​​we aan het einde van dit artikel.
Conclusie
Vandaag hebben we de details van testen in Laravel onderzocht, die PHPUnit al in zijn kern ondersteunt. Het artikel begon met een basisinleiding voor unit- en functionele testen en naarmate we verder gingen, onderzochten we de details van testen in de context van Laravel..
Tijdens het proces hebben we een handvol voorbeelden gemaakt die aantoonden hoe je unit- en functionele testcases kunt maken met behulp van de artisan-opdracht.
Als je net bent begonnen met Laravel of je kennis, site of applicatie met uitbreidingen wilt uitbreiden, hebben we een aantal dingen die je kunt bestuderen in Envato Market.
Aarzel niet om uw mening te geven met behulp van de onderstaande feed!



		
			
	   
	




Code