Tagalog (Wikang Tagalog) translation by Anna Nelson (you can also view the original English article)
Kahit na anong application ang pinagkakaabalahan mo,ang pagsusuri ay mahalaga at madalas ay nababaliwalang aspeto na kailangang bigyan ng kaukulang atensyon.Sa ngayon, tatalakayin natin ito sa konteksto ng Laravel web framework.
Sa katunayan, dati ng sinu-support ng Laravel ang PHPUnit testing framework sa core mismo nito. Ang PHPUnit ay isa sa pinakasikat at malawakang tinatanggap na testing framework sa buong PHP community.Dito ay makakagawa ka ng dalawang uri ng pagsusuri-unit at functional.
Magsisimula tayo sa pangunahing panimula sa unit at functional testing.Habang umuusad tayo, tutuklasin natin kung paano gumawa ng unit at functional tests sa Laravel. Ipalagay kong pamilyar ka sa basics ng PHPUnit framework dahil mas aalamin pa natin ito sa konteksto ng Laravel sa artikulong ito.
Unit at Functional Tests
Kung pamilyar ka na sa PHPUnit framework, dapat alam mo na maaaring hatiin ang tests sa dalawang flavors — unit tests at functional tests.
Sa unit tests, susuriin mo ang kawastuhan ng naturang function o method. At ang mas mahalaga, susuriin mo ang isang bahagi ng iyong code’s logic sa nakatakdang oras.
At habang umuusad, kapag nakita mo na ang method na iyong ginamit ay nagtataglay ng mahigit isang logical unit, mas mabuting hatiin ang iba’t ibang methods para ang bawat method ay mayroong isang logical at testable piece ng code.
Tingnan natin ng mabilis ang halimbawa na ideyal para sa unit testing.
public function getNameAttribute($value) { return ucfirst($value); }
Kung iyong makikita, ang method ay
mayroong isang bagay lang na ginagawa. Gumagamit ito ng ucfirst
function para
palitan ang pamagat ng pamagat na nagsisimula sa uppercase.
Habang ang unit test ay ginagamit para suriin ang kawastuhan ng isang logical unit ng code,sa functional test, sa kabilang banda, ay masusuri mo ang kawastuhan ng partikular na use case. At mas partikular na maaari mong gayahin ang ginagawa ng user sa application para paganahin ang particular na use case.
Halimbawa, maaari mong ipatupad ang functional test case para sa ilang login functionality na maaaring may nakapaloob na mga sumusunod na hakbang.
- Gumawa ng GET request para ma-access ang login page.
- Tingnan kung tayo ay nasa login page.
- Gawin ang POST request para i-post ang data sa login page.
- Tingnan kung mapatagumpay na nagawa ang session.
Ganyan kung papaano ka dapat gumawa ng functional test case.Mula sa susunod na bahagi hanggang sa mga susunod pa, gagawa tayo ng mga halimbawa na nagpapakita kung paano gumawa ng unit at functional test cases sa Laravel.
Pag Set-Up ng Prerequisites
Bago tayo magpatuloy at gumawa ng totoong pagsusuri, kailangan nating mag-set up ng ilang mga bagay na gagamitin sa ating pagsusuri.
Gagawa tayo ng Post model at magkaugnay
na migration para magsimula. Magpatuloy at paganahin ang mga sumusunod na
artisan command para magawa ang Post
model.
$php artisan make:model Post --migration
Ang nasa itaas na command ay dapat na
makagawa ng Post
model class at gayundin ang kaugnay na database migration.
Ang Post
model class ay dapat ganito ang
maging itsura:
<?php // app/Post.php namespace App; use Illuminate\Database\Eloquent\Model; class Post extends Model { // }
At ang data migration file ay dapat
gawin sa database/migrations/YYYY_MM_DD_HHMMSS_create_posts
Gusto din natin na i-store ang pamagat
ng post. Baguhin natin ang code ng Post
database migration file para ganito ang
maging itsura.
<?php use Illuminate\Support\Facades\Schema; use Illuminate\Database\Schema\Blueprint; use Illuminate\Database\Migrations\Migration; class CreatePostsTable extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::create('posts', function (Blueprint $table) { $table->increments('id'); $table->string('name'); $table->timestamps(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::dropIfExists('posts'); } }
Kung makikita mo, dinagdag natin
ang $table->string('name')
na hanay
para i-store ang pamagat ng post. Sunod, kailangan mo lang paganahin ang
migrate command para magawa ang table na iyon sa database.
$php artisan migrate
Gayon din, palitan natin ang Post
model
ng mga sumusunod na nilalaman.
<?php namespace App; use Illuminate\Database\Eloquent\Model; class Post extends Model { /** * Get the post title. * * @param string $value * @return string */ public function getNameAttribute($value) { return ucfirst($value); } }
Kakalagay lang natin ng accessor
method, na nagbabago
ng pamagat ng post, at iyan mismo ang
susuriin natin sa ating unit test case. Iyan lamang ang tungkol sa Post
model.
Sunod, gagawa tayo ng controller file
atapp/Http/Controllers/AccessorController.php
. Ito ay makakatulong sa atin
kapag gagawa tayo ng functional test case sa susunod.
<?php // app/Http/Controllers/AccessorController.php namespace App\Http\Controllers; use App\Post; use Illuminate\Http\Request; use App\Http\Controllers\Controller; class AccessorController extends Controller { public function index(Request $request) { // get the post-id from request params $post_id = $request->get("id", 0); // load the requested post $post = Post::find($post_id); // check the name property return $post->name; } }
Sa index
method, iri-retrieve natin ang
post id mula sa request parameters at subukang i-load ang post model object.
Magdagdag din tayo ng kaugnay na route
sa routes/web.php na
file.
Route::get('accessor/index', 'AccessorController@index');
At sa ganyang pagkakasunud-sunod, maaari mo nang i-run ang http://your-laravel-site.com/accessor/index URL para makita kung gumagana ito katulad ng inaasahan.
Unit Testing
Sa nakaraang bahagi, ginawa natin ang unang setup na makakatulong sa atin dito at sa susunod na mga bahagi.Sa bahaging ito, gagawa tayo ng halimbawa na magpapakita ng konsepto ng unit testing sa Laravel.
Katulad ng dati, ang Laravel ay nagbibigay ng artisan command kung saan makakagawa ka ng base templates class ng unit test case.
I-run ang mga susunod na command para
makagawa ng AccessorTest
unit test case class. Mahalaga na tandaan na ipinapasa
natin ang --unit
keyword na gumagawa ng unit test case, at ilalagay ito sa
ibabaw ng mga tests/Unit
directory.
$php artisan make:test AccessorTest --unit
At dapat ito ay makagawa ng mga
sumusunod na class sa tests/ Unit/AccessorTest.php.
<?php // tests/Unit/AccessorTest.php namespace Tests\Unit; use Tests\TestCase; use Illuminate\Foundation\Testing\DatabaseMigrations; use Illuminate\Foundation\Testing\DatabaseTransactions; class AccessorTest extends TestCase { /** * A basic test example. * * @return void */ public function testExample() { $this->assertTrue(true); } }
Palitan natin ito ng ilang makahulugang code.
<?php // tests/Unit/AccessorTest.php namespace Tests\Unit; use Tests\TestCase; use Illuminate\Foundation\Testing\DatabaseMigrations; use Illuminate\Foundation\Testing\DatabaseTransactions; use Illuminate\Support\Facades\DB; use App\Post; class AccessorTest extends TestCase { /** * Test accessor method * * @return void */ public function testAccessorTest() { // load post manually first $db_post = DB::select('select * from posts where id = 1'); $db_post_title = ucfirst($db_post[0]->name); // load post using Eloquent $model_post = Post::find(1); $model_post_title = $model_post->name; $this->assertEquals($db_post_title, $model_post_title); } }
Kung iyong makikita, ay code ay
eksaktong pareho kung ito man ay nasa core PHP. Kinuha lang natin ang
Laravel-specific dependencies na nagbigay daan para magamit natin ang
kailangang APIs. Sa testAccessorTest
method, dapat ay
suriin natin ang kawastuhan ng getNameAttribute
method ng Post
model.
Para magawa ito, kumuha tayo ng
halimbawa na post mula sa database at naghanda ng inaasahang output sa
$db_post_title
variable. Sunod, ilo-load natin ang parehong post
gamit ang Eloquent model na nag-execute din ng getNameAttribute
method para
ihanda ang post title.Ang panghuli , gagamitin natin ang assertEquals
method
para ikumpara ang parehong variables katulad ng dati.
At iyan kung paano ihanda ang unit test cases sa Laravel.
Functional Testing
Sa bahaging ito, gagawa tayo ng functional test case na nagsusuri ng functionality ng controller na ginawa natin kanina.
I-run ang sumusunod na command para
makagawa ng AccessorTest
functional test case class. Dahil hindi tayo gumagamit
ng --unit
keyword,ituturing itong functional test case at ilalagay sa ibabaw ng
tests/Feature
directory.
$php artisan make:test AccessorTest
Gagawa ito ng mga sumusunod na class sa
tests/Feature/AccessorTest.php
.
<?php // tests/Feature/AccessorTest.php namespace Tests\Feature; use Tests\TestCase; use Illuminate\Foundation\Testing\WithoutMiddleware; use Illuminate\Foundation\Testing\DatabaseMigrations; use Illuminate\Foundation\Testing\DatabaseTransactions; class AccessorTest extends TestCase { /** * A basic test example. * * @return void */ public function testExample() { $this->assertTrue(true); } }
Palitan natin ito ng sumusunod na code.
<?php // tests/Feature/AccessorTest.php namespace Tests\Feature; use Tests\TestCase; use Illuminate\Foundation\Testing\WithoutMiddleware; use Illuminate\Foundation\Testing\DatabaseMigrations; use Illuminate\Foundation\Testing\DatabaseTransactions; use Illuminate\Support\Facades\DB; class AccessorTest extends TestCase { /** * A basic test example. * * @return void */ public function testBasicTest() { // load post manually first $db_post = DB::select('select * from lvl_posts where id = 1'); $db_post_title = ucfirst($db_post[0]->name); $response = $this->get('/accessor/index?id=1'); $response->assertStatus(200); $response->assertSeeText($db_post_title); } }
Muli, ang code ay kailangang magmukhang pamilyar sa mga may dati ng karanasan sa functional testing.
Una, kumukuha tayo ng halimbawang post
mula sa database at hinahanda ang inaasahang output sa $db_post_title
variable. Kasunod nito, susubukan nating gayahin
ang /accessor/index?id=1
GET request at kunin ang sagot sa request sa $response
variable.
Sunod, sinubukan natin na pagtugmain ang
response code sa the $response
variable sa expected response code. Sa kaso
natin, ito ay dapat 200 dahil dapat makakuha tayo ng valid na response para sa
ating GET request. Bilang karagdagan, ang response ay dapat
mayroong pamagat na nagsisimula sa uppercase, at iyan mismo ang sinusubukan
nating itugma gamit ang assertSeeText
method.
At iyan ang halimbawa ng functional test case. Ngayon, mayroon na tayo ng lahat ng kailangan kung saan maaari nating i-run ang ating tests. Magpatuloy tayo at i-run ang sumusunod na command sa root ng iyong application para i-run ang lahat ng tests.
$phpunit
Dapat mapa-run nito ang lahat ng tests sa iyong application.Dapat may makita kang standard PHPUnit output na ipinapakita ang istado ng tests at assertions sa iyong application.
At dahil diyan, nasa huling parte na tayo ng artikuong ito.
Konklusyon
Ngayon, tinuklas natin ang mga detalye sa pag-test sa Laravel, na dati ng nagsu-support ng PHPUnit sa core nito. Ang artikulong ito ay nagsimula sa pangunahing panimula sa unit at functional testing, at habang umuusad tayo tinuklas natin ang specifics ng testing sa konteksto ng Laravel.
Sa pagpapatuloy, gumawa tayo ng mangilan-ngilang halimbawa na nagpapakita kung paano gumawa ng unit at functional test cases gamit ang artisan command.
Kung nagsisimula ka pa lang sa Laravel o naghahanap na mapalawak ang kaalaman, site, o application na may extension, mayroon tayong iba’t ibang bagay na maaari mong pag-aralan sa Envato Market.
Huwag mag-atubili na ipahayag ang iyong nasa isip gamit ang feed sa ibaba!
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Update me weeklyEnvato Tuts+ tutorials are translated into other languages by our community members—you can be involved too!
Translate this post