PHPUnit மற்றும் PEST ஐப் பயன்படுத்தி எளிய எடுத்துக்காட்டுகளுடன் Laravel இல் சோதனைகளை எவ்வாறு செய்வது என்பதை அறியவும்

தானியங்கு சோதனைகள் அல்லது அலகு சோதனைகள் என்று வரும்போது, ​​எந்த நிரலாக்க மொழியிலும், இரண்டு எதிர் கருத்துக்கள் உள்ளன:

• நேர விரயம்
• நீங்கள் இல்லாமல் செய்ய முடியாது

எனவே, இந்தக் கட்டுரையின் மூலம், லாரவெல்லில் தானியங்கு சோதனையை தொடங்குவது எவ்வளவு எளிது என்பதை நிரூபிப்பதன் மூலம், முந்தையதை நம்ப வைக்க முயற்சிப்போம்.

முதலில் "ஏன்" பற்றி பேசலாம், பின்னர் எப்படி என்பதற்கான சில எடுத்துக்காட்டுகளைப் பார்ப்போம்.

நமக்கு ஏன் தானியங்கி சோதனை தேவை

தானியங்கு சோதனைகள் குறியீட்டின் பகுதிகளை இயக்கி ஏதேனும் பிழைகள் இருந்தால் புகாரளிக்கின்றன. அவற்றை விவரிக்க இதுவே எளிய வழி. ஒரு பயன்பாட்டில் ஒரு புதிய அம்சத்தை வெளியிடுவதை கற்பனை செய்து பாருங்கள், பின்னர் ஒரு தனிப்பட்ட ரோபோ உதவியாளர் சென்று புதிய அம்சத்தை கைமுறையாக சோதிப்பார், அதே நேரத்தில் புதிய குறியீடு பழைய அம்சங்களை உடைக்கவில்லையா என்று சோதிக்கும்.

இது முக்கிய நன்மை: அனைத்து அம்சங்களையும் தானாக மறுபரிசீலனை செய்தல். இது கூடுதல் வேலையாகத் தோன்றலாம், ஆனால் “ரோபோவை” செய்யச் சொல்லவில்லை என்றால், நாங்கள் அதை கைமுறையாகச் செய்ய வேண்டும், இல்லையா? 

அல்லது பயனர்கள் பிழைகளைப் புகாரளிப்பார்கள் என்ற நம்பிக்கையில் புதிய அம்சங்கள் செயல்படுகின்றனவா என்பதைச் சோதிக்காமல் வெளியிடலாம்.

தானியங்கு சோதனைகள் நமக்கு பல நன்மைகளைத் தரலாம்:

• கைமுறை சோதனை நேரத்தை சேமிக்கவும்;
• செயல்படுத்தப்பட்ட புதிய செயல்பாட்டிலும், பின்னடைவைத் தவிர்ப்பதன் மூலம் ஒருங்கிணைந்த செயல்பாடுகளிலும் நேரத்தைச் சேமிக்க அவை உங்களை அனுமதிக்கின்றன;
• அனைத்து புதிய அம்சங்கள் மற்றும் ஏற்கனவே செயல்படுத்தப்பட்ட அனைத்து அம்சங்களால் இந்த நன்மையை பெருக்கவும்;
• முந்தைய மூன்று புள்ளிகள் ஒவ்வொரு புதிய பதிப்பிற்கும் பொருந்தும்;
• ...

முந்தைய ஆண்டுகளில் எழுதப்பட்ட குறியீடு அல்லது அதை எப்படிச் சோதிப்பது என்று தெரியாத புதிய டெவலப்பர்களுடன், உங்கள் விண்ணப்பத்தை ஓரிரு வருடங்களில் கற்பனை செய்து பார்க்கவும். 

எங்களின் முதல் தானியங்கி சோதனைகள்

முதல் செய்ய Laravel இல் தானியங்கி சோதனை, நீங்கள் எந்த குறியீட்டையும் எழுத வேண்டியதில்லை. ஆம், நீங்கள் படித்தது சரிதான். எல்லாம் ஏற்கனவே கட்டமைக்கப்பட்டு முன் நிறுவலில் தயாராக உள்ளதுdefiலாரவெலின் இரவு, முதல் அடிப்படை உதாரணம் உட்பட.

நீங்கள் லாராவெல் திட்டத்தை நிறுவ முயற்சி செய்யலாம் மற்றும் முதல் சோதனைகளை உடனடியாக இயக்கலாம்:

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 டெஸ்ட்கேஸை நீட்டிக்கும் 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 இல் ஒரு சோதனைக் குறியீடு தோல்வியுற்றால் என்ன ஆகும் என்று பார்ப்போம்

சோதனை உறுதிமொழிகள் எதிர்பார்த்த முடிவைத் தரவில்லை என்றால் என்ன நடக்கும் என்று இப்போது பார்க்கலாம்.

எடுத்துக்காட்டு சோதனைகளை இதற்கு மாற்றுவோம்:

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

தோல்வியுற்ற இரண்டு சோதனைகள் உள்ளன, அவை தோல்வி எனக் குறிக்கப்பட்டுள்ளன, கீழே விளக்கங்கள் மற்றும் தோல்வியுற்ற சோதனைகளின் சரியான வரிசையை சுட்டிக்காட்டும் அம்புகள் உள்ளன. பிழைகள் இந்த வழியில் சுட்டிக்காட்டப்படுகின்றன.

எடுத்துக்காட்டு: Laravel இல் பதிவுப் படிவக் குறியீட்டைச் சோதித்தல்

எங்களிடம் ஒரு படிவம் உள்ளது என்று வைத்துக்கொள்வோம், மேலும் பல்வேறு நிகழ்வுகளை சோதிக்க வேண்டும்: தவறான தரவு மூலம் அது தோல்வியுற்றதா என்பதை நாங்கள் சரிபார்க்கிறோம், சரியான உள்ளீடு மூலம் அது வெற்றிபெறுகிறதா என்பதை நாங்கள் சரிபார்க்கிறோம்.

அதிகாரப்பூர்வ ஸ்டார்டர் கிட் Laravel Breeze மூலம் ஐ உள்ளடக்கியது அதில் உள்ள செயல்பாட்டை சோதிக்கிறது. அதிலிருந்து சில உதாரணங்களைப் பார்ப்போம்:

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);
    }
}

இங்கே ஒரு வகுப்பில் இரண்டு சோதனைகள் உள்ளன, ஏனெனில் அவை இரண்டும் பதிவுப் படிவத்துடன் தொடர்புடையவை: ஒன்று படிவம் சரியாக ஏற்றப்பட்டுள்ளதா என்பதைச் சரிபார்க்கிறது, மற்றொன்று சமர்ப்பிப்பு நன்றாக வேலைசெய்கிறதா என்று சரிபார்க்கிறது.

முடிவைச் சரிபார்க்க இன்னும் இரண்டு முறைகள், மேலும் இரண்டு வலியுறுத்தல்களைப் பற்றி அறிந்து கொள்வோம்: $this->assertAuthenticated()e $response->assertRedirect(). உத்தியோகபூர்வ ஆவணத்தில் கிடைக்கும் அனைத்து உறுதிமொழிகளையும் நீங்கள் சரிபார்க்கலாம் PHPU அலகு e லாராவெல் பதில் . இந்த விஷயத்தில் சில பொதுவான கூற்றுக்கள் ஏற்படுகின்றன என்பதை நினைவில் கொள்க $this, மற்றவர்கள் குறிப்பிட்டதைச் சரிபார்க்கும்போது $responseபாதை அழைப்பிலிருந்து.

மற்றொரு முக்கியமான விஷயம் என்னவென்றால் use RefreshDatabase;அறிக்கை, பக்கவாதத்துடன், வகுப்பிற்கு மேலே செருகப்பட்டது. சோதனைச் செயல்கள் தரவுத்தளத்தை பாதிக்கும் போது இது அவசியம், இந்த எடுத்துக்காட்டில், உள்நுழைவு ஒரு புதிய நுழைவை சேர்க்கிறது usersதரவுத்தள அட்டவணை. இதற்காக, நீங்கள் ஒரு தனி சோதனை தரவுத்தளத்தை உருவாக்க வேண்டும், அது புதுப்பிக்கப்படும் php artisan migrate:freshஒவ்வொரு முறையும் சோதனைகள் நடத்தப்படும்.

உங்களுக்கு இரண்டு விருப்பங்கள் உள்ளன: தனிப்பட்ட தரவுத்தளத்தை உருவாக்கவும் அல்லது நினைவகத்தில் உள்ள SQLite தரவுத்தளத்தைப் பயன்படுத்தவும். இரண்டும் கோப்பில் கட்டமைக்கப்பட்டுள்ளன phpunit.xmlமுன்னிருப்பாக வழங்கப்படுகிறதுdefiஉடன் நிதா 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 உடன் உள்நுழைவு பக்கத்தின் மற்றொரு உதாரணத்தை இப்போது பார்க்கலாம்

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),
        ];
    }
}

நீங்கள் பார்க்கிறீர்கள், லாராவெல்லேயே எத்தனை விஷயங்கள் தயாரிக்கப்படுகின்றன, எனவே சோதனையைத் தொடங்குவது எங்களுக்கு எளிதாக இருக்குமா?

எனவே நாம் செயல்படுத்தினால் 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

உருவாக்கப்பட்ட குறியீடு யூனிட் சோதனைக்கு முந்தையதைப் போன்றதுdefiலாராவெல் அமைப்பு:

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 கிளைக்கு யாராவது மாற்றங்களைத் தள்ளும் போதோ அல்லது உற்பத்திக் கிளையில் குறியீட்டை இணைப்பதற்கு முன்பும், இயக்குவதற்கான சோதனைகளை நீங்கள் குறிப்பிடலாம். கிதுப் செயல்களைப் பயன்படுத்துவதே எளிமையான பணிப்பாய்வு, என்னிடம் உள்ளது ஒரு தனி வீடியோ அதை நிரூபிக்கிறது.

நீங்கள் என்ன சோதிக்க வேண்டும்?

"சோதனை கவரேஜ்" என்று அழைக்கப்படுபவை எவ்வளவு பெரியதாக இருக்க வேண்டும் என்பதில் வெவ்வேறு கருத்துக்கள் உள்ளன: ஒவ்வொரு பக்கத்திலும் ஒவ்வொரு சாத்தியமான செயல்பாடு மற்றும் வழக்கை முயற்சிக்கவும் அல்லது வேலையை மிக முக்கியமான பகுதிகளுக்கு மட்டுப்படுத்தவும்.

உண்மையில், தானியங்கு சோதனை உண்மையான பலனைக் காட்டிலும் அதிக நேரம் எடுக்கும் என்று குற்றம் சாட்டுபவர்களுடன் நான் உடன்படுகிறேன். ஒவ்வொரு விவரத்திற்கும் நீங்கள் தேர்வு எழுதினால் இது நிகழலாம். உங்கள் திட்டத்திற்கு இது தேவைப்படலாம்: "சாத்தியமான பிழையின் விலை என்ன" என்பது முக்கிய கேள்வி.

வேறு வார்த்தைகளில் கூறுவதானால், "இந்த குறியீடு தோல்வியுற்றால் என்ன நடக்கும்?" என்ற கேள்வியைக் கேட்டு உங்கள் சோதனை முயற்சிகளுக்கு முன்னுரிமை அளிக்க வேண்டும். உங்கள் கட்டண முறைமையில் பிழைகள் இருந்தால், அது நேரடியாக வணிகத்தை பாதிக்கும். உங்கள் பாத்திரங்கள்/அனுமதிகளின் செயல்பாடு உடைந்தால், இது மிகப்பெரிய பாதுகாப்புச் சிக்கலாகும்.

மாட் ஸ்டாஃபர் அதை ஒரு மாநாட்டில் கூறியது எனக்கு மிகவும் பிடிக்கும்: "நீங்கள் முதலில் அந்த விஷயங்களைச் சோதிக்க வேண்டும், அவை தோல்வியுற்றால், உங்கள் வேலையிலிருந்து உங்களை நீக்கிவிடும்." நிச்சயமாக இது ஒரு மிகைப்படுத்தல், ஆனால் நீங்கள் யோசனை பெறுவீர்கள்: முக்கியமான விஷயங்களை முதலில் முயற்சிக்கவும். பின்னர் மற்ற அம்சங்கள், உங்களுக்கு நேரம் இருந்தால்.

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