PHPUnit සහ PEST භාවිතයෙන් සරල උදාහරණ සමඟ Laravel හි පරීක්ෂණ සිදු කරන ආකාරය ඉගෙන ගන්න

ස්වයංක්‍රීය පරීක්ෂණ හෝ ඒකක පරීක්ෂණ සම්බන්ධයෙන්, ඕනෑම ක්‍රමලේඛන භාෂාවක, ප්‍රතිවිරුද්ධ මත දෙකක් තිබේ:

• කාලය නාස්ති කිරීම
• ඔබට එය නොමැතිව කළ නොහැක

එබැවින්, මෙම ලිපිය සමඟ අපි කලින් සිටි අයට ඒත්තු ගැන්වීමට උත්සාහ කරමු, විශේෂයෙන් Laravel හි ස්වයංක්‍රීය පරීක්ෂණ සමඟ ආරම්භ කිරීම කොතරම් පහසුද යන්න නිරූපණය කිරීමෙන්.

මුලින්ම අපි "ඇයි" ගැන කතා කරමු, ඉන්පසු අපි උදාහරණ කිහිපයක් බලමු.

අපට ස්වයංක්‍රීය පරීක්ෂණ අවශ්‍ය ඇයි?

ස්වයංක්‍රීය පරීක්ෂණ මඟින් කේතයේ කොටස් ධාවනය කර කිසියම් දෝෂයක් වාර්තා කරයි. ඒවා විස්තර කිරීමට ඇති සරලම ක්‍රමය එයයි. යෙදුමක නව විශේෂාංගයක් එළිදැක්වීම ගැන සිතන්න, පසුව පුද්ගලික රොබෝ සහායකයකු ගොස් නව විශේෂාංගය අතින් පරීක්ෂා කරන අතරම, නව කේතය පැරණි විශේෂාංග කිසිවක් බිඳ නොදැමුවේ දැයි පරීක්ෂා කරයි.

මෙය ප්රධාන වාසියයි: සියලු විශේෂාංග ස්වයංක්රීයව නැවත පරීක්ෂා කිරීම. මෙය අමතර කාර්යයක් සේ පෙනෙනු ඇත, නමුත් ඔබ "රොබෝට" එය කිරීමට නොකියන්නේ නම්, අපි විකල්පයක් ලෙස එය අතින් කළ යුතුයි, හරිද? 

නැතහොත් පරිශීලකයින් දෝෂ වාර්තා කරනු ඇතැයි බලාපොරොත්තු වන නව විශේෂාංග ක්‍රියා කරන්නේ දැයි පරීක්ෂා නොකර නිකුත් කළ හැකිය.

ස්වයංක්‍රීය පරීක්ෂණ අපට වාසි කිහිපයක් ලබා දිය හැක:

• අතින් පරීක්ෂණ කාලය ඉතිරි කරන්න;
• ක්‍රියාත්මක කරන ලද නව ශ්‍රිතය සහ ප්‍රතිගාමී වීම වැළැක්වීම මගින් ඒකාබද්ධ ශ්‍රිත දෙකෙහිම කාලය ඉතිරි කර ගැනීමට ඒවා ඔබට ඉඩ සලසයි;
• සියලුම නව විශේෂාංග සහ දැනටමත් ක්‍රියාත්මක කර ඇති සියලුම විශේෂාංග මගින් මෙම ප්‍රතිලාභය ගුණ කරන්න;
• පෙර කරුණු තුන සෑම නව අනුවාදයකටම අදාළ වේ;
• ...

පෙර වසරවල ලියා ඇති කේතය හෝ එය පරීක්ෂා කරන්නේ කෙසේදැයි නොදන්නා කණ්ඩායමේ නව සංවර්ධකයින් සමඟ ඔබේ යෙදුම වසරකින් හෝ දෙකකින් සිතා ගැනීමට උත්සාහ කරන්න. 

අපගේ පළමු ස්වයංක්‍රීය පරීක්ෂණ

පළමු ඉටු කිරීමට Laravel හි ස්වයංක්‍රීය පරීක්ෂණය, ඔබට කිසිම කේතයක් ලිවීමට අවශ්‍ය නැත. ඔව්, ඔබ එය නිවැරදිව කියෙව්වා. සෑම දෙයක්ම දැනටමත් වින්යාස කර ඇති අතර පූර්ව ස්ථාපනය තුළ සූදානම් කර ඇතdefiපළමු මූලික උදාහරණය ඇතුළුව, Laravel නයිට්.

ඔබට Laravel ව්‍යාපෘතියක් ස්ථාපනය කිරීමට උත්සාහ කර පළමු පරීක්ෂණ වහාම ක්‍රියාත්මක කරන්න:

laravel new project
cd project
php artisan test

මෙය ඔබගේ කොන්සෝලයේ ප්‍රතිඵලය විය යුතුය:

අපි කලින් බැලුවොත්defiලාරාවෙල් රාත්‍රිය /tests, අපට ගොනු දෙකක් තිබේ:

tests/Feature/ExampleTest.php:

class ExampleTest extends TestCase
{
    public function test_the_application_returns_a_successful_response()
    {
        $response = $this->get('/');
 
        $response->assertStatus(200);
    }
}

මෙහි සිදුවන්නේ කුමක්ද යන්න තේරුම් ගැනීමට ඔබට කිසිදු වාක්‍ය ඛණ්ඩයක් දැන ගැනීමට අවශ්‍ය නැත: මුල් පිටුව පූරණය කර තත්ව කේතය දැයි පරීක්ෂා කරන්න HTTP è "200 OK".

ක්රමයේ නම ලෙසද හැඳින්වේ test_the_application_returns_a_successful_response() ඔබ පරීක්ෂණ ප්‍රතිඵල බලන විට, යටි ඉරි සංකේතය හිස්තැනකින් ප්‍රතිස්ථාපනය කිරීමෙන් කියවිය හැකි පෙළ බවට පත් වේ.

tests/Unit/ExampleTest.php:

class ExampleTest extends TestCase
{
    public function test_that_true_is_true()
    {
        $this->assertTrue(true);
    }
}

ටිකක් තේරුමක් නැති බව පෙනේ, මෙය සත්‍ය දැයි බැලීමට පරීක්ෂා කරනවාද? 

ඒකක පරීක්ෂණ ගැන අපි ටිකක් පසුව කතා කරමු. දැනට, ඔබ සෑම පරීක්ෂණයකදීම සාමාන්‍යයෙන් සිදුවන්නේ කුමක්ද යන්න තේරුම් ගත යුතුය.

• ෆෝල්ඩරයේ ඇති සෑම පරීක්ෂණ ගොනුවක්ම /tests යනු TestCase දිගු කරන PHP පන්තියකි PHPU ඒකකය
• සෑම පන්තියක් තුළම, ඔබට ක්‍රම කිහිපයක් නිර්මාණය කළ හැකිය, සාමාන්‍යයෙන් තත්වයක් පරීක්ෂා කිරීම සඳහා එක් ක්‍රමයක්
• එක් එක් ක්‍රමය තුළ ක්‍රියා තුනක් ඇත: තත්වය සකස් කිරීම, පසුව ක්‍රියා කිරීම සහ ප්‍රතිඵලය අපේක්ෂා කළ පරිදි දැයි තහවුරු කිරීම (තහවුරු කිරීම).

ව්‍යුහාත්මකව, ඔබ දැනගත යුත්තේ එපමණයි, අනෙක් සියල්ල ඔබට පරීක්ෂා කිරීමට අවශ්‍ය නිශ්චිත දේවල් මත රඳා පවතී.

හිස් පරීක්ෂණ පන්තියක් උත්පාදනය කිරීමට, මෙම විධානය ක්‍රියාත්මක කරන්න:

php artisan make:test HomepageTest

ගොනුව ජනනය වේ tests/Feature/HomepageTest.php:

class HomepageTest extends TestCase
{
    // Replace this method with your own ones
    public function test_example()
    {
        $response = $this->get('/');
 
        $response->assertStatus(200);
    }
}

දැන් අපි බලමු Laravel වල test code එකක් fail උනොත් මොකද වෙන්නේ කියලා

පරීක්ෂණ ප්‍රකාශයන් අපේක්ෂිත ප්‍රතිඵලය ලබා නොදුන්නේ නම් කුමක් සිදුවේදැයි අපි දැන් බලමු.

උදාහරණ පරීක්ෂණ මෙයට වෙනස් කරමු:

class ExampleTest extends TestCase
{
    public function test_the_application_returns_a_successful_response()
    {
        $response = $this->get('/non-existing-url');
 
        $response->assertStatus(200);
    }
}
 
 
class ExampleTest extends TestCase
{
    public function test_that_true_is_false()
    {
        $this->assertTrue(false);
    }
}

දැන්, අපි විධානය ක්රියාත්මක කරන්නේ නම් php artisan test නැවතත්:

 FAIL  Tests\Unit\ExampleTest
⨯ that true is true
 
 FAIL  Tests\Feature\ExampleTest
⨯ the application returns a successful response
 
---
 
• Tests\Unit\ExampleTest > that true is true
Failed asserting that false is true.
 
at tests/Unit/ExampleTest.php:16
   12▕      * @return void
   13▕      */
   14▕     public function test_that_true_is_true()
   15▕     {
➜  16▕         $this->assertTrue(false);
   17▕     }
   18▕ }
   19▕
 
• Tests\Feature\ExampleTest > the application returns a successful response
Expected response status code [200] but received 404.
Failed asserting that 200 is identical to 404.
 
at tests/Feature/ExampleTest.php:19
   15▕     public function test_the_application_returns_a_successful_response()
   16▕     {
   17▕         $response = $this->get('/non-existing-url');
   18▕
➜  19▕         $response->assertStatus(200);
   20▕     }
   21▕ }
   22▕
 
 
Tests:  2 failed
Time:   0.11s

අසාර්ථක පරීක්ෂණ දෙකක් ඇත, FAIL ලෙස සලකුණු කර ඇති අතර, පහත පැහැදිලි කිරීම් සහ අසාර්ථක වූ පරීක්ෂණ වල නිශ්චිත රේඛාව වෙත ඊතල පෙන්වයි. දෝෂ මේ ආකාරයෙන් දක්වා ඇත.

උදාහරණය: Laravel හි ලියාපදිංචි පෝරම කේතය පරීක්ෂා කිරීම

අපට පෝරමයක් තිබේ යැයි සිතමු සහ අපට විවිධ අවස්ථා පරීක්ෂා කිරීමට අවශ්‍ය වේ: එය වලංගු නොවන දත්ත සමඟ අසමත් වේද යන්න අපි පරීක්ෂා කරමු, නිවැරදි ආදානය සමඟ එය සාර්ථක දැයි අපි පරීක්ෂා කරමු.

නිල ආරම්භක කට්ටලය Laravel Breeze විසිනි i ඇතුළත් වේ එය තුළ ක්රියාකාරිත්වය පරීක්ෂා කිරීම. අපි එතැන් සිට උදාහරණ කිහිපයක් බලමු:

tests/Feature/RegistrationTest.php

use App\Providers\RouteServiceProvider;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
 
class RegistrationTest extends TestCase
{
    use RefreshDatabase;
 
    public function test_registration_screen_can_be_rendered()
    {
        $response = $this->get('/register');
 
        $response->assertStatus(200);
    }
 
    public function test_new_users_can_register()
    {
        $response = $this->post('/register', [
            'name' => 'Test User',
            'email' => 'test@example.com',
            'password' => 'password',
            'password_confirmation' => 'password',
        ]);
 
        $this->assertAuthenticated();
        $response->assertRedirect(RouteServiceProvider::HOME);
    }
}

මෙහිදී අපට එක් පන්තියක පරීක්ෂණ දෙකක් තිබේ, ඒවා දෙකම ලියාපදිංචි කිරීමේ පෝරමයට සම්බන්ධ බැවින්: එකක් පෝරමය නිවැරදිව පටවා ඇත්දැයි පරීක්ෂා කරන අතර තවත් එකක් ඉදිරිපත් කිරීම හොඳින් ක්‍රියාත්මක වේද යන්න පරීක්ෂා කරයි.

ප්‍රති result ලය සත්‍යාපනය කිරීම සඳහා තවත් ක්‍රම දෙකක්, තවත් ප්‍රකාශ දෙකක් සමඟ අපි හුරුපුරුදු වෙමු: $this->assertAuthenticated()e $response->assertRedirect(). හි නිල ලේඛනවල ඇති සියලුම ප්‍රකාශයන් ඔබට පරීක්ෂා කළ හැකිය PHPU ඒකකය e Laravel ප්‍රතිචාරය . මෙම විෂය සම්බන්ධයෙන් සමහර පොදු ප්රකාශයන් සිදු වන බව සලකන්න $this, අනෙක් අය නිශ්චිතව පරීක්ෂා කරන අතර $responseමාර්ග ඇමතුමෙන්.

තවත් වැදගත් දෙයක් නම් use RefreshDatabase;ප්‍රකාශය, ආඝාතය සමඟ, පන්තියට ඉහළින් ඇතුළත් කර ඇත. පරීක්ෂණ ක්‍රියා දත්ත සමුදායට බලපෑම් කළ හැකි විට එය අවශ්‍ය වේ, මෙම උදාහරණයේ දී, ලොග් වීම නව ප්‍රවේශයක් එක් කරයි usersදත්ත සමුදා වගුව. මේ සඳහා, ඔබ විසින් යාවත්කාලීන කරනු ලබන වෙනම පරීක්ෂණ දත්ත සමුදායක් සෑදිය යුතුය php artisan migrate:freshපරීක්ෂණ පවත්වන සෑම අවස්ථාවකම.

ඔබට විකල්ප දෙකක් තිබේ: භෞතිකව වෙනම දත්ත සමුදායක් සාදන්න හෝ මතකයේ ඇති SQLite දත්ත සමුදායක් භාවිතා කරන්න. දෙකම ගොනුවේ වින්‍යාස කර ඇත phpunit.xmlපෙරනිමියෙන් සපයනු ලැබේdefinita සමග Laravel. විශේෂයෙන්, ඔබට මෙම කොටස අවශ්ය වේ:

<php>
    <env name="APP_ENV" value="testing"/>
    <env name="BCRYPT_ROUNDS" value="4"/>
    <env name="CACHE_DRIVER" value="array"/>
    <!-- <env name="DB_CONNECTION" value="sqlite"/> -->
    <!-- <env name="DB_DATABASE" value=":memory:"/> -->
    <env name="MAIL_MAILER" value="array"/>
    <env name="QUEUE_CONNECTION" value="sync"/>
    <env name="SESSION_DRIVER" value="array"/>
    <env name="TELESCOPE_ENABLED" value="false"/>
</php>

බලන්න DB_CONNECTIONe DB_DATABASEඅදහස් දක්වන්නේ කුමන ඒවාද? ඔබට ඔබේ සේවාදායකයේ SQLite තිබේ නම්, සරලම ක්‍රියාව වන්නේ එම රේඛා අදහස් දැක්වීම ඉවත් කිරීම වන අතර ඔබේ පරීක්ෂණ එම මතකයේ ඇති දත්ත ගබඩාවට එරෙහිව ක්‍රියාත්මක වේ.

මෙම පරීක්ෂණයේදී අපි පවසන්නේ පරිශීලකයා සාර්ථකව සත්‍යාපනය කර නිවැරදි මුල් පිටුවට හරවා යවා ඇති බවයි, නමුත් අපට දත්ත සමුදායේ සත්‍ය දත්ත පරීක්ෂා කළ හැකිය.

මෙම කේතයට අමතරව:

$this->assertAuthenticated();
$response->assertRedirect(RouteServiceProvider::HOME);

අපිටත් පාවිච්චි කරන්න පුළුවන් දත්ත සමුදා පරීක්ෂණ ප්‍රකාශයන් සහ මේ වගේ දෙයක් කරන්න:

$this->assertDatabaseCount('users', 1);
 
// Or...
$this->assertDatabaseHas('users', [
    'email' => 'test@example.com',
]);

පිවිසුම් පිටුවේ උදාහරණය

අපි දැන් බලමු Laravel Breeze සමඟින් Login page එකක තවත් උදාහරණයක්

tests/Feature/AuthenticationTest.php:

class AuthenticationTest extends TestCase
{
    use RefreshDatabase;
 
    public function test_login_screen_can_be_rendered()
    {
        $response = $this->get('/login');
 
        $response->assertStatus(200);
    }
 
    public function test_users_can_authenticate_using_the_login_screen()
    {
        $user = User::factory()->create();
 
        $response = $this->post('/login', [
            'email' => $user->email,
            'password' => 'password',
        ]);
 
        $this->assertAuthenticated();
        $response->assertRedirect(RouteServiceProvider::HOME);
    }
 
    public function test_users_can_not_authenticate_with_invalid_password()
    {
        $user = User::factory()->create();
 
        $this->post('/login', [
            'email' => $user->email,
            'password' => 'wrong-password',
        ]);
 
        $this->assertGuest();
    }
}

එය පිවිසුම් පෝරමය ගැන ය. ලොජික් එක රෙජිස්ටර් වෙන්න සමානයි නේද? නමුත් ක්‍රම දෙකක් වෙනුවට ක්‍රම තුනක්, එබැවින් මෙය හොඳ සහ නරක අවස්ථා දෙකම පරීක්ෂා කිරීමේ උදාහරණයකි. එබැවින්, පොදු තර්කය නම්, ඔබ අවස්ථා දෙකම පරීක්ෂා කළ යුතුය: දේවල් හොඳින් සිදුවන විට සහ ඒවා අසාර්ථක වූ විට.

එසේම, මෙම පරීක්ෂණයේදී ඔබ දකින්නේ භාවිතයයි දත්ත සමුදා කර්මාන්තශාලා : Laravel ව්‍යාජ පරිශීලකයෙකු නිර්මාණය කරයි ( නැවතත්, ඔබගේ යාවත්කාලීන කළ පරීක්ෂණ දත්ත ගබඩාවේ ) පසුව නිවැරදි හෝ වැරදි අක්තපත්‍ර සමඟ ලොග් වීමට උත්සාහ කරයි.

නැවත වරක්, Laravel කර්මාන්තශාලාව පෙර උත්පාදනය කරයිdefiසඳහා සාවද්‍ය දත්ත සමඟ nita Userආකෘතිය, පෙට්ටියෙන් පිටත.

database/factories/UserFactory.php:

class UserFactory extends Factory
{
    public function definition()
    {
        return [
            'name' => $this->faker->name(),
            'email' => $this->faker->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
            'remember_token' => Str::random(10),
        ];
    }
}

ඔයාලට පේනවා Laravel විසින්ම කොච්චර දේවල් ලෑස්ති ​​කරනවාද කියලා, ඉතින් අපිට test කරන්න ලේසි වෙයිද?

ඉතින් අපි ක්‍රියාත්මක කළොත් php artisan testLaravel Breeze ස්ථාපනය කිරීමෙන් පසු, අපට මෙවැනි දෙයක් දැකිය යුතුය:

 PASS  Tests\Unit\ExampleTest
✓ that true is true
 
 PASS  Tests\Feature\Auth\AuthenticationTest
✓ login screen can be rendered
✓ users can authenticate using the login screen
✓ users can not authenticate with invalid password
 
 PASS  Tests\Feature\Auth\EmailVerificationTest
✓ email verification screen can be rendered
✓ email can be verified
✓ email is not verified with invalid hash
 
 PASS  Tests\Feature\Auth\PasswordConfirmationTest
✓ confirm password screen can be rendered
✓ password can be confirmed
✓ password is not confirmed with invalid password
 
 PASS  Tests\Feature\Auth\PasswordResetTest
✓ reset password link screen can be rendered
✓ reset password link can be requested
✓ reset password screen can be rendered
✓ password can be reset with valid token
 
 PASS  Tests\Feature\Auth\RegistrationTest
✓ registration screen can be rendered
✓ new users can register
 
 PASS  Tests\Feature\ExampleTest
✓ the application returns a successful response
 
Tests:  17 passed
Time:   0.61s

ඒකක පරීක්ෂණ සහ අනෙකුත් ඒවාට සාපේක්ෂව ක්‍රියාකාරී පරීක්ෂණ

ඔබ උප ෆෝල්ඩර දැක ඇත tests/Feature e tests/Unit ?. 

ඔවුන් අතර වෙනස කුමක්ද? 

ගෝලීය වශයෙන්, Laravel/PHP පරිසර පද්ධතියෙන් පිටත, ස්වයංක්‍රීය පරීක්ෂණ වර්ග කිහිපයක් තිබේ. ඔබට එවැනි නියමයන් සොයාගත හැකිය:

• ඒකක පරීක්ෂණ
• විශේෂාංග පරීක්ෂාව
• ඒකාබද්ධතා පරීක්ෂණ
• ක්රියාකාරී පරීක්ෂණ
• අන්තයේ සිට අවසානය දක්වා පරීක්ෂා කිරීම
• පිළිගැනීමේ පරීක්ෂණ
• දුම් පරීක්ෂණ
• ආදිය

එය සංකීර්ණ ලෙස පෙනෙන අතර, මෙම වර්ගයේ පරීක්ෂණ අතර සැබෑ වෙනස්කම් සමහර විට නොපැහැදිලි වේ. Laravel විසින් මෙම ව්‍යාකූල පද සියල්ල සරල කර ඒවා දෙකට කාණ්ඩගත කර ඇත: ඒකක/විශේෂාංගය.

සරලව කිවහොත්, විශේෂාංග පරීක්ෂණ ඔබගේ යෙදුම්වල සැබෑ ක්‍රියාකාරීත්වය ක්‍රියාත්මක කිරීමට උත්සාහ කරයි: URL ලබා ගන්න, API අමතන්න, පෝරමය පිරවීම වැනි නිවැරදි හැසිරීම අනුකරණය කරන්න. විශේෂාංග පරීක්ෂණ සාමාන්‍යයෙන් සැබෑ ජීවිතයේදී ඕනෑම ව්‍යාපෘති පරිශීලකයෙකු අතින් සිදු කරන ආකාරයටම හෝ සමාන මෙහෙයුම් සිදු කරයි.

ඒකක පරීක්ෂණ වලට අර්ථ දෙකක් ඇත. පොදුවේ ගත් කල, ඕනෑම ස්වයංක්‍රීය පරීක්ෂණයක් "ඒකක පරීක්ෂාව" ලෙස හැඳින්වෙන අතර සම්පූර්ණ ක්‍රියාවලියම "ඒකක පරීක්ෂාව" ලෙස හැඳින්විය හැක. නමුත් ක්‍රියාකාරීත්වයට එදිරිව ඒකකයේ සන්දර්භය තුළ, මෙම ක්‍රියාවලිය හුදකලාව, විශේෂිත පොදු නොවන කේත ඒකකයක් පරීක්ෂා කිරීමයි. උදාහරණයක් ලෙස, ඔබට පරාමිති සහිත සම්පූර්ණ ඇණවුම් මිල වැනි යමක් ගණනය කරන ක්‍රමයක් සහිත Laravel පන්තියක් ඇත. එබැවින්, විවිධ පරාමිති සහිත එම ක්‍රමයෙන් (කේත ඒකකය) නිවැරදි ප්‍රතිඵල ලබා දෙන්නේද යන්න ඒකක පරීක්‍ෂණයේ සඳහන් වේ.

ඒකක පරීක්ෂණයක් උත්පාදනය කිරීමට, ඔබ ධජයක් එක් කළ යුතුය:

php artisan make:test OrderPriceTest --unit

ජනනය කරන ලද කේතය පෙර ඒකක පරීක්ෂණයට සමාන වේdefiLaravel පද්ධතිය:

class OrderPriceTest extends TestCase
{
    public function test_example()
    {
        $this->assertTrue(true);
    }
}

ඔබට පෙනෙන පරිදි, එය නොපවතී RefreshDatabase, සහ මෙය ඉන් එකකි defiවඩාත් පොදු ඒකක පරීක්ෂණ නිර්වචන: එය දත්ත සමුදාය ස්පර්ශ නොකරයි, එය ක්රියාත්මක වන යෙදුමෙන් හුදකලා වූ "කළු පෙට්ටියක්" ලෙස ක්රියා කරයි.

මම කලින් කියපු උදාහරණය අනුකරණය කරන්න හදනකොට අපි හිතමු අපිට සේවා පන්තියක් තියෙනවා කියලා OrderPrice.

app/Services/OrderPriceService.php:

class OrderPriceService
{
    public function calculatePrice($productId, $quantity, $tax = 0.0)
    {
        // Some kind of calculation logic
    }
}

එවිට, ඒකක පරීක්ෂණය මේ වගේ දෙයක් විය හැකිය:

class OrderPriceTest extends TestCase
{
    public function test_single_product_no_taxes()
    {
        $product = Product::factory()->create(); // generate a fake product
        $price = (new OrderPriceService())->calculatePrice($product->id, 1);
        $this->assertEquals(1, $price);
    }
 
    public function test_single_product_with_taxes()
    {
        $price = (new OrderPriceService())->calculatePrice($product->id, 1, 20);
        $this->assertEquals(1.2, $price);
    }
 
    // More cases with more parameters
}

Laravel ව්‍යාපෘති පිළිබඳ මගේ පුද්ගලික අත්දැකීම අනුව, පරීක්ෂණවලින් අතිමහත් බහුතරයක් විශේෂාංග පරීක්ෂණ මිස ඒකක පරීක්ෂණ නොවේ. පළමුව, ඔබ ඔබේ යෙදුම ක්‍රියා කරන්නේද යන්න පරීක්ෂා කළ යුතුය, සැබෑ පුද්ගලයින් එය භාවිතා කරන ආකාරය.

ඊළඟට, ඔබට විශේෂ ගණනය කිරීම් හෝ තර්කනයක් තිබේ නම් ඔබට හැකිය definire ඒකකයක් ලෙස, පරාමිතීන් සමඟ, ඔබට ඒ සඳහා විශේෂයෙන් ඒකක පරීක්ෂණ නිර්මාණය කළ හැකිය.

සමහර විට, පරීක්ෂණ ලිවීමේදී කේතයම වෙනස් කිරීම සහ එය වඩාත් "පරීක්ෂා කළ හැකි" බවට පත් කිරීම සඳහා එය නැවත සකස් කිරීම අවශ්ය වේ: ඒකක විශේෂ පන්ති හෝ ක්රම වලට වෙන් කිරීම.

පරීක්ෂණ සිදු කරන්නේ කවදාද / කෙසේද?

මේකේ ඇත්තම ප්‍රයෝජනය මොකක්ද php artisan test, ඔබ එය ධාවනය කළ යුත්තේ කවදාද?

ඔබේ ව්‍යාපාර කාර්ය ප්‍රවාහය මත පදනම්ව විවිධ ප්‍රවේශයන් ඇත, නමුත් සාමාන්‍යයෙන් ඔබ අවසාන කේත වෙනස් කිරීම් ගබඩාවට තල්ලු කිරීමට පෙර සියලුම පරීක්ෂණ “කොළ” (එනම් දෝෂ රහිත) බව සහතික කර ගත යුතුය.

ඉන්පසුව, ඔබ ඔබේ කාර්යයේ දේශීයව වැඩ කරන අතර, ඔබ අවසන් යැයි සිතන විට, ඔබ කිසිවක් කැඩී නැති බව සහතික කර ගැනීමට පරීක්ෂණ කිහිපයක් පවත්වන්න. මතක තබා ගන්න, ඔබේ කේතය ඔබේ තර්කයේ පමණක් නොව බොහෝ කලකට පෙර ලියා ඇති වෙනත් කෙනෙකුගේ කේතයේ වෙනත් හැසිරීමක් නොදැනුවත්වම බිඳ දැමිය හැකිය.

අපි තව පියවරක් ඉදිරියට ගියොත්, එය ස්වයංක්රීය කිරීමට හැකි වේ බොහෝ දේවල්. විවිධ CI/CD මෙවලම් සමඟින්, යම්කිසි කෙනෙක් නිශ්චිත Git ශාඛාවකට වෙනස්කම් තල්ලු කරන විට හෝ නිෂ්පාදන ශාඛාව වෙත කේතය ඒකාබද්ධ කිරීමට පෙර ධාවනය කිරීමට පරීක්ෂණ නියම කළ හැක. සරලම කාර්ය ප්‍රවාහය වනුයේ Github ක්‍රියා භාවිතා කිරීමයි වෙනම වීඩියෝ එකක් එය ඔප්පු කරන.

ඔබ පරීක්ෂා කළ යුත්තේ කුමක්ද?

ඊනියා "පරීක්ෂණ ආවරණය" කොතරම් විශාල විය යුතුද යන්න පිළිබඳව විවිධ මත තිබේ: සෑම පිටුවකම හැකි සෑම මෙහෙයුමක්ම සහ නඩුවක් උත්සාහ කරන්න, නැතහොත් කාර්යය වඩාත් වැදගත් කොටස් වලට සීමා කරන්න.

ඇත්ත වශයෙන්ම, ස්වයංක්‍රීය පරීක්ෂණයට සැබෑ ප්‍රතිලාභ ලබා දීමට වඩා වැඩි කාලයක් ගත වන බවට චෝදනා කරන පුද්ගලයින් සමඟ මම එකඟ වන්නේ මෙහිදීය. ඔබ සෑම විස්තරයක් සඳහාම පරීක්ෂණ ලියන්නේ නම් මෙය සිදු විය හැකිය. එනම්, එය ඔබගේ ව්‍යාපෘතියට අවශ්‍ය විය හැකිය: ප්‍රධාන ප්‍රශ්නය වන්නේ "විභව දෝෂයේ මිල කුමක්ද" යන්නයි.

වෙනත් වචන වලින් කිවහොත්, "මෙම කේතය අසාර්ථක වුවහොත් කුමක් සිදුවේද?" යන ප්‍රශ්නය ඇසීමෙන් ඔබ ඔබේ පරීක්ෂණ උත්සාහයන් ප්‍රමුඛත්වය දිය යුතුය. ඔබේ ගෙවීම් පද්ධතියට දෝෂ තිබේ නම්, එය ව්‍යාපාරයට සෘජුවම බලපානු ඇත. එබැවින් ඔබගේ භූමිකාවන්/අවසර වල ක්‍රියාකාරීත්වය බිඳී ඇත්නම්, මෙය විශාල ආරක්ෂක ගැටළුවකි.

Matt Stauffer එය සම්මන්ත්‍රණයකදී ප්‍රකාශ කළ ආකාරය මම කැමතියි: "ඔබ මුලින්ම එම දේවල් පරීක්ෂා කළ යුතුය, ඒවා අසාර්ථක වුවහොත්, ඔබව ඔබේ රැකියාවෙන් නෙරපා හරිනු ඇත." ඇත්ත වශයෙන්ම එය අතිශයෝක්තියක්, නමුත් ඔබට අදහස ලැබේ: පළමුව වැදගත් දේවල් උත්සාහ කරන්න. ඔබට කාලය ඇත්නම් වෙනත් විශේෂාංග.

PEST: PHPUnit සඳහා නව විකල්පයක්

ඉහත උදාහරණ සියල්ල Laravel පූර්ව පරීක්ෂණ මෙවලම මත පදනම් වේdefiරාත්රී: PHPU ඒකකය . නමුත් වසර ගණනාවක් පුරා වෙනත් මෙවලම් පරිසර පද්ධතිය තුළ දර්ශනය වී ඇති අතර නවතම ජනප්රිය එකක් වේ පළිබෝධකය . නිල Laravel සේවකයා විසින් නිර්මාණය කරන ලදී නූනෝ මදුරෝ , පරීක්ෂණ සඳහා ලිවීමේ කේතය වඩාත් වේගවත් කරමින් වාක්‍ය ඛණ්ඩය සරල කිරීම අරමුණු කරයි.

කබාය යටතේ, එය ක්රියාත්මක වේ su PHPUnit, අතිරේක ස්ථරයක් ලෙස, පෙර-පුනරාවර්තන කොටස් කිහිපයක් අවම කිරීමට උත්සාහ කරයිdefiPHPUnit කේතයේ නයිට්.

අපි උදාහරණයක් බලමු. පෙර විශේෂාංග පරීක්ෂණ පන්තිය මතක තබා ගන්නdefiLaravel හි ඇති? මම ඔබට මතක් කරන්නම්:

namespace Tests\Feature;
 
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
 
class ExampleTest extends TestCase
{
    public function test_the_application_returns_a_successful_response()
    {
        $response = $this->get('/');
 
        $response->assertStatus(200);
    }
}

PEST සමඟ එකම පරීක්ෂණය කෙබඳු වනු ඇත්දැයි ඔබ දන්නවාද?

test('the application returns a successful response')->get('/')->assertStatus(200);

ඔව්, එක් කේතයක් සහ එපමණයි. එබැවින්, PEST හි අරමුණ වන්නේ පොදු කාර්ය ඉවත් කිරීමයි:

• සෑම දෙයක් සඳහාම පන්ති සහ ක්රම නිර්මාණය කිරීම;
• පරීක්ෂණ නඩුව දිගු කිරීම;
• ක්‍රියා වෙනම රේඛාවල තැබීමෙන්: PEST හි ඔබට ඒවා එකට සම්බන්ධ කළ හැකිය.

Laravel හි PEST පරීක්ෂණයක් උත්පාදනය කිරීමට, ඔබ අතිරේක ධජයක් සඳහන් කළ යුතුය:

php artisan make:test HomepageTest --pest

මෙම ලිපිය ලියන විට, PEST Laravel සංවර්ධකයින් අතර බෙහෙවින් ජනප්‍රියයි, නමුත් මෙම අතිරේක මෙවලම භාවිතා කර එහි වාක්‍ය ඛණ්ඩය මෙන්ම PHPUnit සටහනක් ඉගෙන ගන්නේද යන්න ඔබේ පුද්ගලික මනාපයයි.

BlogInnovazione.it