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 ക്ലാസാണ് 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

പരാജയപ്പെട്ട രണ്ട് ടെസ്റ്റുകളുണ്ട്, FAIL എന്ന് അടയാളപ്പെടുത്തി, ചുവടെയുള്ള വിശദീകരണങ്ങളും പരാജയപ്പെട്ട ടെസ്റ്റുകളുടെ കൃത്യമായ വരിയിലേക്ക് അമ്പടയാളങ്ങളും ഉണ്ട്. പിശകുകൾ ഈ രീതിയിൽ സൂചിപ്പിച്ചിരിക്കുന്നു.

ഉദാഹരണം: 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എന്നതിന് തെറ്റായ ഡാറ്റയുമായി നിത 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 ഇക്കോസിസ്റ്റത്തിന് പുറത്ത്, നിരവധി തരം ഓട്ടോമേറ്റഡ് ടെസ്റ്റിംഗ് ഉണ്ട്. നിങ്ങൾക്ക് ഇതുപോലുള്ള നിബന്ധനകൾ കണ്ടെത്താനാകും:

• യൂണിറ്റ് ടെസ്റ്റുകൾ
• ഫീച്ചർ ടെസ്റ്റിംഗ്
• ഇന്റഗ്രേഷൻ ടെസ്റ്റുകൾ
• പ്രവർത്തനപരമായ പരിശോധനകൾ
• എൻഡ്-ടു-എൻഡ് ടെസ്റ്റിംഗ്
• സ്വീകാര്യത പരിശോധനകൾ
• പുകവലി പരിശോധനകൾ
• തുടങ്ങിയവ.

ഇത് സങ്കീർണ്ണമാണെന്ന് തോന്നുന്നു, ഇത്തരത്തിലുള്ള പരിശോധനകൾ തമ്മിലുള്ള യഥാർത്ഥ വ്യത്യാസങ്ങൾ ചിലപ്പോൾ മങ്ങുന്നു. അതുകൊണ്ടാണ് ലാറവെൽ ഈ ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന പദങ്ങളെല്ലാം ലളിതമാക്കുകയും അവയെ രണ്ടായി തരംതിരിക്കുകയും ചെയ്തത്: യൂണിറ്റ്/സവിശേഷത.

ലളിതമായി പറഞ്ഞാൽ, ഫീച്ചർ ടെസ്റ്റുകൾ നിങ്ങളുടെ ആപ്ലിക്കേഷനുകളുടെ യഥാർത്ഥ പ്രവർത്തനം നടപ്പിലാക്കാൻ ശ്രമിക്കുന്നു: 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 കോഡിന്റെ രാത്രി.

നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം. പ്രീ ഫീച്ചർ ടെസ്റ്റ് ക്ലാസ് ഓർക്കുക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

ഈ രചനയിൽ, Laravel ഡവലപ്പർമാർക്കിടയിൽ PEST വളരെ ജനപ്രിയമാണ്, എന്നാൽ ഈ അധിക ടൂൾ ഉപയോഗിക്കേണ്ടതും അതിന്റെ വാക്യഘടനയും അതുപോലെ ഒരു PHPUnit കുറിപ്പും പഠിക്കേണ്ടതും നിങ്ങളുടെ വ്യക്തിപരമായ മുൻഗണനയാണ്.

BlogInnovazione.it