Disce facere probationes in Laravel cum exemplis simplicibus, utendo PHPUnit et PEST

Cum ad automated probationes vel unitatem probationes in qualibet lingua programmandi perveniunt, duae sunt sententiae contrariae;

• Perditio tempus
• Non potes facere sine eo

Hoc igitur articulo priori persuadere conabimur, praesertim demonstrando quam facile sit incipiendum ab automated experimento in Laravel.

Primum fama "quare", et quomodo exempla videamus.

Quare opus est probatione automated

Automated probationes partes codicis currunt et errores aliquos referunt. Simplicissima via est illa describere. Finge volvere novam plumam in app, et tunc adiutorem robot personalem iret et manually novam plumam probaret, cum etiam probaret num novum codicem nullum veteris notae infringeret.

Hoc est praecipuum commodum: omnia lineamenta statim testificans. Hoc quasi extra opus videri posset, sed si non indicas "robot" facere, e contrario illud manuale facere debemus, recte? 

Vel novas notas emitti posse sine probatione num operantur, sperans utentes cimices nuntiaturos esse.

Automated probationes varia commoda nobis dare possunt;

• Salvum manuale tentationis tempus;
• Permittunt te ut tempus conserves tam in novo effectu quam in functionibus solidatis, regressionem vitando;
• Multiplica hoc beneficium omnibus novis notis omnibusque iam effectis;
• Tria priora ad omnem novam versionem pertinent;
• ...

Conare applicationem tuam fingere in anno vel altero, cum novis machinis in quadrigis, qui codicem superioribus annis scriptum non noverunt, vel etiam probare. 

Primum probat automated

Ad primum praestare automated probatio in Laravel, codice aliquo scribere non debes. Imo id jus legisti. Omnia iam configurantur et praeparantur in praevia institutionedefinita de Laravel , inter ipsa primum exemplum.

Potes experiri consilium inaugurari in Laravel et primas probationes statim currere:

laravel new project
cd project
php artisan test

Hoc evenire debet in tuo console:

Si vide predefinite de Laravel /testsduo fasciculi habemus:

probat/Feature/ExampleTest.php :

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

Non opus est ut aliquam syntaxin scias ad intellegendum quid hic agatur: paginam onerare et deprime si status codicis HTTP e '200 OK".

Etiam quae modum nominis test_the_application_returns_a_successful_response() fit textus lectibilis cum eventum testium spectas, simpliciter cum spatio symbolum underline reponens.

probat/Unit/ExampleTest.php :

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

Frustra videtur aliquantulum, si hoc inspiciendo verum est? 

In specie de unitate loquemur paulo post probat. Nunc enim intelligere debes, quid in unaquaque experientia plerumque eveniat.

• Quisque test file in folder /tests est PHP genus, quod se extendit TestCase of PHPUnit
• In unoquoque genere, multiplices modos creare potes, unam fere methodum pro condicione experiendi
• In unaquaque methodo tres actiones sunt: ​​praeparatio condicionis, deinde actio faciendi et comprobatio (affirmans) utrum eventus ita sit ut exspectatur.

Omnino, quod omnia scire debes, reliqua omnia ex exactis quae vis experiri pendere.

Ad generandum inane experimentum classis, simpliciter currite hoc mandatum;

php artisan make:test HomepageTest

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

Nunc videamus quid acciderit si nota codicis in Laravel deficit

Nunc videamus quid acciderit si assertiones probatae eventus exspectatos non reddant.

Ad hoc exemplum transeamus:

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

Et nunc, si curramus mandatum php artisan test iterum:

 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

Duae sunt probationes incassum, sicut DEFICIO notatae, cum explicationibus infra et sagittae indicantibus ad rectam testium quae incassum sunt. Errores hoc modo indicantur.

Exemplum: Testis adnotatione forma codice in Laravel

Formam habemus, et varios casus experiri oportet: refutamus si deficit notitia invalida, reprimimus si succedit cum initus recto, etc.

Officialis starter ornamentum by Laravel Aura includit i * probaret functionality in eo. Exempla inde inspiciamus:

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

Hic habemus duas probationes in uno genere, cum utrumque referatur ad formam adnotationem: unum compescit si forma recte oneratur, et altera sistit si obsequium bene operatur.

Adsuescamus nobis duobus modis plures ad effectum comprobandum, duae plures assertiones: $this->assertAuthenticated()e $response->assertRedirect(). Potes reprehendo omnes assertiones in documentis officialis PHPUnit e LaravelResponse . Nota quod aliquae assertiones generales occurrunt in subiecto $thisdum alii specifica $responseab itinere vocatus.

Alius magni momenti est use RefreshDatabase;editio, ictu, supra classi inserta. Necessarium est cum actus testium datorum afficere possunt, sicut in hoc exemplo, colligatio novum in introitum adiungit usersdatabase mensam. Hoc, singulare test database quod renovabitur cum php artisan migrate:freshomni tempore probat currunt.

Duas optiones habes: physice separatum database vel utere database in memoria SQLite. Utrumque in tabella configuratur phpunit.xmlprovisum est per defaultdefinita cum Laravel. Speciatim hac parte opus est:

<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>

Vide the DB_CONNECTIONe DB_DATABASEquae sunt commentati? Si SQLite in servo tuo, simplicissima actio simpliciter incomitata est illas lineas et tentationes tuae in database memoriae incurrentes.

In hoc experimento dicimus usorem feliciter authenticum et ad rectam paginam redirectum esse, sed etiam ipsas notitias in datorum instrumentis probare possumus.

Adde hunc codicem:

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

Etiam uti possumus in database test assertionibus et fac sicut hoc:

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

Exemplum paginae Login

Nunc aliud exemplum videamus paginae login cum Aura Laravel

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

De forma login est. Similis est ratio adnotatione, vox? Sed tres modi pro duobus, ut hoc est exemplum probationis missionum tam bonorum quam malorum. Communis ergo logica est ut vtrosque probes: quando bene et quando deficiunt.

Item, quod vides in hoc testi usu esse Database Factories : Laravel user gignit fake ( iterum in vestri database test updated " ) ac deinde inire conatur, cum documentorum rectam vel falsam.

Iterum, Laravel officinas pre . generatdefiper falsa nita notitia ad * Userexemplar, extra pyxidem.

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

Vides, quam multa ab ipso Laravel praeparata sint, ut facile nobis sit tentare?

Itaque si feceritis php artisan testpostquam Aura Laravel insertis, aliquid simile hoc videre debemus:

 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

Examinationes functiones comparatae cum unitate probat et aliis

Te vidi subfolders tests/Feature e tests/Unit ?. 

Quid intersit? 

Globally, extra ecosystem Laravel/PHP, plura sunt genera probationis automated. Verba similia invenire potes:

• Unitas probat
• Pluma temptationis
• Integration probat
• Eget probat
• Finis-ad-finem temptationis
• Acceptatio probat
• fumus probat
• etc.

Sonat multiplex, et differentiae actuales inter has species testium interdum turbatae sunt. Quam ob rem Laravel omnia haec verba confundens simpliciores fecit easque in duas partes: unitas/pluma conglobavit.

Simpliciter, pluma probationes experiri conantur functiones actuales applicationum tuarum exsequi: Domicilium obtine, API voca, mores exactos imitare sicut formam implens. Pluma probationes easdem vel similes operationes exercere solent ac utentis projecti quivis in vita reali, manually facturum.

Unitas probat duas significationes habere. In genere, invenias quod omnis probatio automated "unitatis probatio" dicitur et totum processum "unitatis probatio" dici potest. Sed in contextu functionis versus unitatem, hic processus tentat certam unitatem codicis non-publicam, separatim. Exempli gratia, genus habes Laravel cum methodo quae aliquid calculat, sicut pretium totius ordinis cum parametris. Ideo probatio unitatis declararet utrum rectae eventus ab illo methodo (codice unit) cum diversis parametris reddantur.

Unitas test ad generandum, vexillum addere debes:

php artisan make:test OrderPriceTest --unit

Generatum codice idem est ac pre unitatis testdefiSystema Laravel:

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

Ut videre potes, non est RefreshDatabaseet hoc unum est deficommunissimarum unitatis experimentorum definitiones: datorum non attingit, "arcam nigram" operatur, a applicatione currenti segregatus.

Imitari conantur exemplum, de quo antea diximus, cogitemus nos habere servitium classis OrderPrice.

app/Services/OrderPriceService.php:

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

Deinde, unitas experimentalis aliquid simile hoc spectare potuit;

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
}

In mea experientia personali cum inceptis Laravel, plurima pars testium sunt Features probationes, non probat Unitas. Primum, experiri debes utrum applicationis opera tua, qua vera populus utatur.

Deinde, si rationes vel logicas speciales habere potes definire ut unitas, cum parametris, creare potes unum experimentum specie pro illo.

Interdum scriptura probationes requirit ipsum codicem modificare ac reformare ut plus "testabilis" reddat: unitates separans in classes vel modos speciales.

Quando / probat quomodo praestare?

Quid est hoc ipsum usum php artisan testquando curris?

Diversi sunt accessus, prout in negotiatione tua operantur, sed plerumque opus est ut omnes probationes "viridis" (i.e. error-liberi) sint antequam recentissimas codicis mutationes ad repositorium impellat.

Deinde localiter in opere tuo laboras, et cum te fieri putas, aliquas probationes currite ut certe nihil fractum habeas. Memento, codicem tuum causare cimices non solum in propria logica, sed etiam praeter intentionem morum aliquos alios in alio codice iam pridem scriptos.

Si gradum ulterius accipiamus, automate fieri potest multi res. Cum variis CI/CD instrumentis specificare potes probationes ad currendum, quoties quis mutationes ad certum Git ramum impellit vel antequam in codicem mergens in ramum producendum. Simplicissimus workflow esset ut actiones Github habeo separatum video quod probat.

Quid tentatis?

Diversae sunt opiniones in quam magna sit, quae dicitur "teste coverage": experire quamlibet actionem possibilem et in singulis paginis casum, vel opus ad partes praecipuas coarctare.

Re quidem vera hoc ubi assentior iis qui accusant automated experimentum plus temporis capiendi quam utilem praebendi. Hoc fieri potest, si probationes scribes in omnibus et singulis. Quod dixit, requiri potest ex tuo consilio: summa quaestio est "quid sit pretium erroris potentiae".

Aliis verbis, debes prioritizare conatus tentationis quaerendo quaestionem « Quid futurum sit si hoc signum deficeret? Si ratio mercedem tuam habet bugs, negotium directe incursum. Si igitur munus tuum/permissionum functionis tuae fractum est, ingens res securitatis est.

Placet quomodo Matt Stauffer illud in colloquio posuit: "Tibi primum ea experiri debes quae, si defecerint, te ex officio tuo accendit". Nimirum id hyperbole est, sed notionem habes: experire primum gravem supellectilem. Ergo et cetera, si vacat.

PEST: novus alternative ad PHPUnit

Omnia exempla superiora in Laravel instrumentum probatum innitunturdefinita; PHPUnit . Sed per annos alia instrumenta in oecosystematis apparuerunt et una e proximis popularibus est PEST . Author officialis Larvel molestie Nuno Maduro tendit ut syntaxin simpliciorem redderet, scribensque codicem pro probationibus citius vel citius.

Sub cucullo fugit su PHPUnit, ut iacuit additus, modo conatur minuere aliquas partes pre-repetitasdefinite ex codice PHPUnit.

Intueamur exemplum. Memento pre test genus plumadefitinam in Laravel? commemorabo te:

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

Nostin' quid idem testi simile apud PEST?

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

Ita unus versus in codice ita est. Sic, PESTA meta est capitis tollere;

• Genera ac rationes ad omnia creandi;
• Casus extensio Test;
• Actionibus distinctis lineas ponendo: in PEST illas simul constringere potes.

Ad testam PESTIM generandam in Laravel, vexillum additum notare debes:

php artisan make:test HomepageTest --pest

Cum hoc scripto, PEST satis populare est apud Laravel tincidunt, sed praerogativa personalis est utrum hoc additamento utatur et syntaxin eius discat, sicut nota PHPUnit.

BlogInnovazione.it