PHPUnit અને PEST નો ઉપયોગ કરીને સરળ ઉદાહરણો સાથે Laravel માં પરીક્ષણો કેવી રીતે કરવા તે શીખો

જ્યારે તે સ્વયંસંચાલિત પરીક્ષણો અથવા એકમ પરીક્ષણોની વાત આવે છે, કોઈપણ પ્રોગ્રામિંગ ભાષામાં, ત્યાં બે વિરોધી અભિપ્રાયો છે:

• સમય નો બગાડ
• તમે તેના વિના કરી શકતા નથી

તેથી, આ લેખ સાથે અમે ભૂતપૂર્વને સમજાવવાનો પ્રયાસ કરીશું, ખાસ કરીને લારાવેલમાં સ્વચાલિત પરીક્ષણ સાથે પ્રારંભ કરવું કેટલું સરળ છે તે દર્શાવીને.

પહેલા આપણે "શા માટે" વિશે વાત કરીએ અને પછી કેવી રીતે તેના કેટલાક ઉદાહરણો જોઈએ.

શા માટે અમને સ્વચાલિત પરીક્ષણની જરૂર છે

સ્વચાલિત પરીક્ષણો કોડના ભાગો ચલાવે છે અને કોઈપણ ભૂલોની જાણ કરે છે. તેમનું વર્ણન કરવાની આ સૌથી સરળ રીત છે. એપમાં એક નવી સુવિધાને રોલ આઉટ કરવાની કલ્પના કરો, અને પછી વ્યક્તિગત રોબોટ સહાયક જઈને નવા ફીચરનું મેન્યુઅલી પરીક્ષણ કરશે, જ્યારે નવા કોડે જૂની કોઈ પણ વિશેષતા તોડી નથી કે કેમ તે પણ પરીક્ષણ કરશે.

આ મુખ્ય ફાયદો છે: બધી સુવિધાઓનું આપમેળે ફરીથી પરીક્ષણ કરવું. આ વધારાનું કામ લાગે છે, પરંતુ જો તમે "રોબોટ" ને તે કરવા માટે ન કહો, તો આપણે વૈકલ્પિક રીતે તે જાતે કરવું જોઈએ, ખરું ને? 

અથવા નવી સુવિધાઓ તેઓ કામ કરે છે કે કેમ તે પરીક્ષણ કર્યા વિના રિલીઝ કરી શકાય છે, આશા છે કે વપરાશકર્તાઓ ભૂલોની જાણ કરશે.

સ્વયંસંચાલિત પરીક્ષણો અમને ઘણા ફાયદા આપી શકે છે:

• મેન્યુઅલ પરીક્ષણ સમય બચાવો;
• તેઓ તમને રીગ્રેશનને ટાળીને અમલમાં મૂકાયેલા નવા ફંક્શન અને કોન્સોલિડેટેડ ફંક્શન પર સમય બચાવવા માટે પરવાનગી આપે છે;
• આ લાભને તમામ નવી સુવિધાઓ અને પહેલાથી અમલમાં મૂકેલ તમામ સુવિધાઓ દ્વારા ગુણાકાર કરો;
• અગાઉના ત્રણ મુદ્દા દરેક નવા સંસ્કરણને લાગુ પડે છે;
• ...

એક કે બે વર્ષમાં તમારી એપ્લિકેશનની કલ્પના કરવાનો પ્રયાસ કરો, ટીમમાં નવા વિકાસકર્તાઓ કે જેઓ પાછલા વર્ષોમાં લખેલા કોડને જાણતા નથી અથવા તેનું પરીક્ષણ કેવી રીતે કરવું તે પણ જાણતા નથી. 

અમારા પ્રથમ સ્વચાલિત પરીક્ષણો

પ્રથમ કરવા માટે Laravel માં સ્વચાલિત પરીક્ષણ, તમારે કોઈ કોડ લખવાની જરૂર નથી. હા, તમે તે સાચું વાંચ્યું છે. પ્રી-ઇન્સ્ટોલેશનમાં બધું પહેલેથી જ રૂપરેખાંકિત અને તૈયાર છેdefiલારાવેલની રાત, જેમાં ખૂબ જ પ્રથમ મૂળભૂત ઉદાહરણનો સમાવેશ થાય છે.

તમે 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 એ PHP વર્ગ છે જે ટેસ્ટકેસને વિસ્તરે છે પીએચપીયુનિટ
• દરેક વર્ગની અંદર, તમે બહુવિધ પદ્ધતિઓ બનાવી શકો છો, સામાન્ય રીતે પરિસ્થિતીને ચકાસવા માટે એક પદ્ધતિ
• દરેક પદ્ધતિમાં ત્રણ ક્રિયાઓ હોય છે: પરિસ્થિતિની તૈયારી, પછી ક્રિયા અને પછી ચકાસો (પુષ્ટિ) કે પરિણામ અપેક્ષા મુજબ છે કે કેમ

માળખાકીય રીતે, તમારે એટલું જ જાણવાની જરૂર છે, બાકીનું બધું તમે જે ચોક્કસ વસ્તુઓનું પરીક્ષણ કરવા માંગો છો તેના પર નિર્ભર છે.

ખાલી ટેસ્ટ ક્લાસ જનરેટ કરવા માટે, ફક્ત આ આદેશ ચલાવો:

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

ત્યાં બે નિષ્ફળ પરીક્ષણો છે, જે FAIL તરીકે ચિહ્નિત થયેલ છે, નીચે સ્પષ્ટતા સાથે અને તીરો નિષ્ફળ ગયેલા પરીક્ષણોની ચોક્કસ રેખા તરફ નિર્દેશ કરે છે. ભૂલો આ રીતે સૂચવવામાં આવે છે.

ઉદાહરણ: Laravel માં નોંધણી ફોર્મ કોડનું પરીક્ષણ

ધારો કે અમારી પાસે એક ફોર્મ છે અને અમારે વિવિધ કેસોનું પરીક્ષણ કરવાની જરૂર છે: અમે તપાસીએ છીએ કે તે અમાન્ય ડેટા સાથે નિષ્ફળ જાય છે કે કેમ, અમે તપાસીએ છીએ કે તે યોગ્ય ઇનપુટ સાથે સફળ થાય છે કે નહીં, વગેરે.

સત્તાવાર સ્ટાર્ટર કીટ લારાવેલ બ્રિઝ દ્વારા 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);
    }
}

અહીં અમારી પાસે એક વર્ગમાં બે પરીક્ષણો છે, કારણ કે તે બંને નોંધણી ફોર્મ સાથે સંબંધિત છે: એક તપાસે છે કે શું ફોર્મ યોગ્ય રીતે લોડ થયું છે કે નહીં અને બીજું તપાસે છે કે સબમિશન બરાબર કામ કરે છે કે નહીં.

ચાલો પરિણામ ચકાસવા માટે બે વધુ પદ્ધતિઓથી પરિચિત થઈએ, વધુ બે નિવેદનો: $this->assertAuthenticated()e $response->assertRedirect(). ના સત્તાવાર દસ્તાવેજોમાં ઉપલબ્ધ તમામ નિવેદનો તમે ચકાસી શકો છો પીએચપીયુનિટ e Laravel પ્રતિભાવ . નોંધ કરો કે કેટલાક સામાન્ય નિવેદનો વિષય પર થાય છે $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 બનાવટી વપરાશકર્તા બનાવે છે ( ફરીથી, તમારા અપડેટ કરેલા ટેસ્ટ ડેટાબેઝ પર ) અને પછી સાચા અથવા ખોટા ઓળખપત્રો સાથે લોગ ઇન કરવાનો પ્રયાસ કરે છે.

ફરી એકવાર, લારાવેલ ફેક્ટરી પ્રી જનરેટ કરે છેdefiમાટે ખોટા ડેટા સાથે નીતા 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 testલારાવેલ બ્રિઝ ઇન્સ્ટોલ કર્યા પછી, આપણે આના જેવું કંઈક જોવું જોઈએ:

 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 ઇકોસિસ્ટમની બહાર, સ્વયંસંચાલિત પરીક્ષણના ઘણા પ્રકારો છે. તમે આવા શબ્દો શોધી શકો છો:

• એકમ પરીક્ષણો
• લક્ષણ પરીક્ષણ
• એકીકરણ પરીક્ષણો
• કાર્યાત્મક પરીક્ષણો
• એન્ડ-ટુ-એન્ડ ટેસ્ટિંગ
• સ્વીકૃતિ પરીક્ષણો
• ધૂમ્રપાન પરીક્ષણો
• વગેરે

તે જટિલ લાગે છે, અને આ પ્રકારના પરીક્ષણો વચ્ચેના વાસ્તવિક તફાવતો ક્યારેક ઝાંખા થઈ જાય છે. તેથી જ લારાવેલે આ બધી ગૂંચવણભરી શરતોને સરળ બનાવી છે અને તેમને બેમાં જૂથબદ્ધ કર્યા છે: એકમ/સુવિધા.

સરળ શબ્દોમાં કહીએ તો, સુવિધા પરીક્ષણો તમારી એપ્લિકેશનની વાસ્તવિક કાર્યક્ષમતાને એક્ઝિક્યુટ કરવાનો પ્રયાસ કરે છે: 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
}

લારાવેલ પ્રોજેક્ટ્સ સાથેના મારા અંગત અનુભવમાં, મોટાભાગના પરીક્ષણો લક્ષણ પરીક્ષણો છે, એકમ પરીક્ષણો નહીં. પ્રથમ, તમારે ચકાસવાની જરૂર છે કે તમારી એપ્લિકેશન કામ કરે છે કે કેમ, વાસ્તવિક લોકો તેનો ઉપયોગ કેવી રીતે કરશે.

આગળ, જો તમારી પાસે વિશેષ ગણતરીઓ અથવા તર્ક હોય તો તમે કરી શકો છો defiએકમ તરીકે nire, પરિમાણો સાથે, તમે તેના માટે ખાસ કરીને એકમ પરીક્ષણો બનાવી શકો છો.

કેટલીકવાર, પરીક્ષણો લખવા માટે કોડને જ સંશોધિત કરવાની જરૂર પડે છે અને તેને વધુ "પરીક્ષણયોગ્ય" બનાવવા માટે રિફેક્ટર કરવાની જરૂર પડે છે: એકમોને વિશિષ્ટ વર્ગો અથવા પદ્ધતિઓમાં વિભાજિત કરવા.

પરીક્ષણો ક્યારે/કેવી રીતે કરવા?

આનો વાસ્તવિક ઉપયોગ શું છે php artisan test, તમારે તેને ક્યારે ચલાવવું જોઈએ?

તમારા વ્યવસાયના કાર્યપ્રવાહના આધારે, ત્યાં વિવિધ અભિગમો છે, પરંતુ સામાન્ય રીતે તમારે રીપોઝીટરીમાં નવીનતમ કોડ ફેરફારોને આગળ ધપાવતા પહેલા તમામ પરીક્ષણો "ગ્રીન" (એટલે ​​​​કે ભૂલ-મુક્ત) છે તેની ખાતરી કરવાની જરૂર છે.

પછી, તમે તમારા કાર્ય પર સ્થાનિક રીતે કામ કરો છો, અને જ્યારે તમને લાગે કે તમે પૂર્ણ કરી લીધું છે, ત્યારે તમે કંઈપણ તોડ્યું નથી તેની ખાતરી કરવા માટે કેટલાક પરીક્ષણો ચલાવો. યાદ રાખો, તમારો કોડ ફક્ત તમારા તર્કમાં જ ભૂલો પેદા કરી શકે છે પરંતુ અજાણતા ઘણા સમય પહેલા લખેલા કોઈ બીજાના કોડમાં અન્ય વર્તનને તોડી શકે છે.

જો આપણે તેને એક પગલું આગળ લઈએ, તો તે સ્વયંસંચાલિત કરવું શક્ય છે પીગળવું વસ્તુઓ વિવિધ CI/CD ટૂલ્સ સાથે, તમે જ્યારે પણ કોઈ ચોક્કસ ગિટ બ્રાન્ચમાં અથવા કોડને પ્રોડક્શન બ્રાન્ચમાં મર્જ કરતાં પહેલાં કોઈ ફેરફાર કરે ત્યારે ચલાવવા માટે તમે ટેસ્ટનો ઉલ્લેખ કરી શકો છો. સૌથી સરળ વર્કફ્લો ગીથબ ક્રિયાઓનો ઉપયોગ કરવાનો છે, મારી પાસે છે એક અલગ વિડિઓ જે તેને સાબિત કરે છે.

તમારે શું પરીક્ષણ કરવું જોઈએ?

કહેવાતા "ટેસ્ટ કવરેજ" કેટલું મોટું હોવું જોઈએ તેના પર જુદા જુદા મંતવ્યો છે: દરેક સંભવિત ઑપરેશન અને દરેક પૃષ્ઠ પરના કેસનો પ્રયાસ કરો, અથવા કાર્યને સૌથી મહત્વપૂર્ણ ભાગો સુધી મર્યાદિત કરો.

વાસ્તવમાં, આ તે છે જ્યાં હું એવા લોકો સાથે સંમત છું જેઓ સ્વયંસંચાલિત પરીક્ષણને વાસ્તવિક લાભ આપવા કરતાં વધુ સમય લેવાનો આક્ષેપ કરે છે. જો તમે દરેક વિગત માટે પરીક્ષણો લખો તો આ થઈ શકે છે. તેણે કહ્યું, તે તમારા પ્રોજેક્ટ માટે જરૂરી હોઈ શકે છે: મુખ્ય પ્રશ્ન એ છે કે "સંભવિત ભૂલની કિંમત શું છે".

બીજા શબ્દોમાં કહીએ તો, તમારે પ્રશ્ન પૂછીને તમારા પરીક્ષણ પ્રયાસોને પ્રાથમિકતા આપવાની જરૂર છે "જો આ કોડ નિષ્ફળ જાય તો શું થશે?" જો તમારી ચુકવણી સિસ્ટમમાં ભૂલો છે, તો તેની સીધી અસર વ્યવસાય પર પડશે. તેથી જો તમારી ભૂમિકાઓ/પરવાનગીઓની કાર્યક્ષમતા તૂટી ગઈ હોય, તો આ એક વિશાળ સુરક્ષા સમસ્યા છે.

મને ગમે છે કે મેટ સ્ટેફરે એક કોન્ફરન્સમાં તે કેવી રીતે મૂક્યું: "તમારે પહેલા તે વસ્તુઓનું પરીક્ષણ કરવું પડશે કે, જો તેઓ નિષ્ફળ જાય, તો તમને તમારી નોકરીમાંથી કાઢી મૂકવામાં આવશે." અલબત્ત તે અતિશયોક્તિ છે, પરંતુ તમને વિચાર આવે છે: પ્રથમ મહત્વપૂર્ણ સામગ્રીનો પ્રયાસ કરો. અને પછી અન્ય સુવિધાઓ, જો તમારી પાસે સમય હોય.

PEST: PHPUnit માટે નવો વિકલ્પ

ઉપરોક્ત તમામ ઉદાહરણો Laravel પ્રી ટેસ્ટિંગ ટૂલ પર આધારિત છેdefiરાત્રિ: પીએચપીયુનિટ . પરંતુ વર્ષોથી ઇકોસિસ્ટમમાં અન્ય સાધનો દેખાયા છે અને એક નવીનતમ લોકપ્રિય છે પી.એસ.ટી. . સત્તાવાર Laravel કર્મચારી દ્વારા બનાવેલ નુનો માદુરો , વાક્યરચના સરળ બનાવવાનું લક્ષ્ય રાખે છે, પરીક્ષણો માટે કોડ લખવાનું વધુ ઝડપી બનાવે છે.

હૂડ હેઠળ, તે ચાલે છે su PHPUnit, વધારાના સ્તર તરીકે, ફક્ત કેટલાક પૂર્વ-પુનરાવર્તિત ભાગોને ઘટાડવાનો પ્રયાસ કરી રહ્યાં છેdefiPHPUnit કોડની રાત.

ચાલો એક ઉદાહરણ જોઈએ. પ્રી ફીચર ટેસ્ટ ક્લાસ યાદ રાખોdefiલારાવેલમાં નાઈટેડ? હું તમને યાદ અપાવીશ:

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 લારાવેલ વિકાસકર્તાઓમાં ખૂબ જ લોકપ્રિય છે, પરંતુ આ વધારાના સાધનનો ઉપયોગ કરવો અને તેની વાક્યરચના, તેમજ PHPUnit નોંધ શીખવી કે કેમ તે તમારી વ્યક્તિગત પસંદગી છે.

BlogInnovazione.it