Vous apprendre à maîtriser les méthodes de test Laravel

La colonne tutorielle suivante de Laravel vous présentera la méthode de test pour maîtriser Laravel. J'espère qu'elle sera utile aux amis dans le besoin !

Maîtrisez les méthodes de test de Laravel

Que vous l'admettiez ou non, vous développez a Lorsqu'il s'agit de produits, les tests logiciels revêtent une grande importance pour le projet, mais nous les ignorons souvent. Dans cet article nous étudions principalement les méthodes de tests du framework Laravel.

Peut-être que vous ne le savez pas encore, le noyau Laravel a déjà hérité du composant de tests unitaires PHPUnit. PHPUnit est l'un des frameworks de test les plus utilisés et les plus populaires dans la communauté PHP. PHPUnit prend en charge les fonctionnalités de « tests unitaires » et de « tests fonctionnels ».

Nous présenterons brièvement l'utilisation de base des "tests unitaires" et des "tests fonctionnels" de PHPUnit. Expliquez ensuite comment créer des cas d'utilisation de « tests unitaires » et de « tests fonctionnels » dans les projets Laravel. Cependant, dans cet article, nous supposons que vous avez déjà une compréhension de base du framework de test PHPUnit, concentrons-nous donc sur le sujet de l'utilisation de PHPUnit pour les tests dans Laravel.

Tests unitaires et tests fonctionnels

Si vous êtes entré en contact avec le framework PHPUnit, sachez qu'il prend en charge deux types de fonctionnalités : les "tests unitaires" et "Tests fonctionnels".

Le but des "tests unitaires" est de tester l'exactitude des fonctions ou des méthodes. Plus important encore, nous pouvons facilement obtenir l'exactitude de la logique du code.

Si vous constatez au cours du processus de développement qu'une certaine fonction contient plusieurs traitements logiques, il est préférable de diviser chaque logique de traitement en différentes méthodes pour garantir que les méthodes individuelles et les blocs de code sont testables.

Nous jetons un coup d'œil aux mystères des tests unitaires de manière idéale.

<?php
public function getNameAttribute($value)
{
    return ucfirst($value);
}

Comme vous pouvez le voir, cette méthode ne gère qu'une seule logique métier. La fonction ucfirst est utilisée à l'intérieur de la méthode pour convertir les caractères au format majuscule.

Les tests unitaires visent à garantir l'exactitude du code de chaque unité indépendante ; les tests fonctionnels visent à garantir l'exactitude d'une fonction. En un mot, il s'agit de simuler le comportement des utilisateurs accédant à l'application à travers des cas de tests spécifiques pour vérifier l'exactitude du système.

Par exemple, nous pouvons implémenter un cas de test fonctionnel pour la fonction de connexion qui comprend les étapes suivantes :

• Lancer une requête GET pour accéder à la page de connexion ; <🎜 ; >

• Déterminer si nous sommes sur la page de connexion

• Générer les données de connexion pour la connexion à l'aide de la requête POST ;

  Déterminez si les données de session de connexion ont été créées avec succès.

• C'est le secret pour créer des cas d'utilisation de « tests fonctionnels ». Ensuite, nous créerons des cas de test spécifiques pour expliquer comment utiliser les « tests unitaires » et les « tests fonctionnels » dans Laravel.

Créer un environnement de test

Créer un modèle de test

Avant de commencer à créer des cas de test, nous devons le construire pour tester les dépendances du projet. Exécutez d'abord la commande artisanale suivante pour créer un modèle Post et son fichier de migration correspondant.

$ php artisan make:model Post --migration

La commande ci-dessus créera pour nous une classe de modèle Post et un fichier de migration de base de données.

Le code du modèle Post est le suivant :

<?php
// app/Post.php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Post extends Model
{
    //
}

Le fichier de migration de base de données AAAA_MM_JJ_HHMMSS_create_posts_table.php sera créé dans le répertoire base de données/migrations.

La table de données Post stocke le titre d'un article. Le code du fichier de migration de la base de données Post modifié est le suivant :

<?php
use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
class CreatePostsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create(&#39;posts&#39;, function (Blueprint $table) {
            $table->increments(&#39;id&#39;);
            $table->string(&#39;name&#39;);
            $table->timestamps();
        });
    }
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists(&#39;posts&#39;);
    }
}

Comme vous pouvez le voir, nous stockons le titre de l'article via le nouveau $table->string('name'). Ensuite, exécutez la commande de migration de base de données pour créer la table de données correspondante dans la base de données.

$ php artisan migrate

Après avoir créé la table de données, nous devons ajouter le code suivant à la classe du modèle Post

<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Post extends Model
{
    /**
     * Get the post title.
     *
     * @param  string  $value
     * @return string
     */
    public function getNameAttribute($value)
    {
        return ucfirst($value);
    }
}

Nous venons d'ajouter la méthode accesseur, sa fonction est de modifier le titre de l'article, ce qui est exactement ce que nous voulons tester dans le cas de test unitaire. Ce qui précède est ce qui doit être modifié dans le modèle Post.

Créer un contrôleur de test

Ensuite, nous devons créer un contrôleur avec le nom de fichier app/Http/Controllers/AccessorController.php qui sera utilisé pour le suivi fonctionnel essai.

<?php
// app/Http/Controllers/AccessorController.php
namespace App\Http\Controllers;
use App\Post;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
class AccessorController extends Controller
{
    public function index(Request $request)
    {
        // get the post-id from request params
        $post_id = $request->get("id", 0);
        // load the requested post
        $post = Post::find($post_id);
        // check the name property
        return $post->name;
    }
}

Dans la méthode index, nous interrogeons un article du modèle Post via le paramètre id dans la requête.

Enfin, définissez les routes pertinentes dans le fichier de configuration de routage routes/web.php.

<?php
Route::get(&#39;accessor/index&#39;, &#39;AccessorController@index&#39;);

Après avoir configuré l'itinéraire, vous pouvez y accéder via http://your-laravel-site.com/accessor/index pour voir si l'itinéraire est accessible normalement.

Tests unitaires

Dans la section précédente, nous avons mis en place un environnement pour les tests. Dans cette section, nous allons écrire des cas de tests unitaires dans Laravel pour tester le modèle Post. Heureusement, Laravel nous fournit également un outil de commande pour créer des fichiers modèles de cas de test.

Créez la classe de cas de test unitaire AccessorTest en exécutant la commande suivante sur la ligne de commande. Notez que nous devons passer l'option de paramètre --unit pour indiquer que cette commande crée un scénario de test unitaire. Les fichiers de cas de tests unitaires sont créés dans le répertoire tests/Unit.

$ php artisan make:test --unit

执行上面创建测试用例命令会创建文件名为 tests/Unit/AccessorTest.php 文件。

<?php
// tests/Unit/AccessorTest.php
namespace Tests\Unit;
use Tests\TestCase;
use Illuminate\Foundation\Testing\DatabaseMigrations;
use Illuminate\Foundation\Testing\DatabaseTransactions;
class AccessorTest extends TestCase
{
    /**
     * A basic test example.
     *
     * @return void
     */
    public function testExample()
    {
        $this->assertTrue(true);
    }
}

将 testExample 方法替换成更有实际意义的方法：

<?php
// tests/Unit/AccessorTest.php
namespace Tests\Unit;
use Tests\TestCase;
use Illuminate\Foundation\Testing\DatabaseMigrations;
use Illuminate\Foundation\Testing\DatabaseTransactions;
class AccessorTest extends TestCase
{
    /**
     * Test accessor method
     *
     * @return void
     */  
    public function testAccessorTest()
    {
        $db_post = DB::select(&#39;select * from posts where id = 1&#39;);
        $db_post_title = ucfirst($db_post[0]->title);
        $model_post = Post::find(1);
        $model_post_title = $model_post->title;
        $this->assertEquals($db_post_title, $model_post_title);
    }
}

我们可以看到更新后的代码和 Laravel 代码编码风格完全一致。在类的开始我们引入了相关依赖类文件。在 testAccessorTest 方法里，我们希望验证定义在 Post 模型里面的 getNameAttribute 方法的正确性。

为了实现这样的测试功能，我们通过 DB 类使用原生 SQL 查询到一篇文章，并将文章的标题赋值给 $db_post_title 变量。

之后，我们通过 Post 模型获取经过 getNameAttribute 方法处理过后的同一篇文章的标题赋值给 $model_post_title。

最后，通过 assertEquals 方法比较两个变量是否相等。

以上就是如何在 Laravel 中使用单元测试的使用方法。

功能测试

这一节我们将学习如何创建功能测试用例来对先前创建的控制器进行「功能测试」。

通过下面给出的命令，我们将创建一个名为 AccessorTest 的功能测试用例。注意这边我们没有使用 --unit 命令行选项，所以命令会在 tests/Feature 目录下创建一个「功能测试」用例。

$ php artisan make:test AccessorTest

命令会创建文件名为 tests/Feature/AccessorTest.php 的测试类。

<?php
// tests/Feature/AccessorTest.php
namespace Tests\Feature;
use Tests\TestCase;
use Illuminate\Foundation\Testing\WithoutMiddleware;
use Illuminate\Foundation\Testing\DatabaseMigrations;
use Illuminate\Foundation\Testing\DatabaseTransactions;
class AccessorTest extends TestCase
{
    /**
     * A basic test example.
     *
     * @return void
     */
    public function testExample()
    {
        $this->assertTrue(true);
    }
}

同样我们替换掉 testExample 方法。

<?php
// tests/Feature/AccessorTest.php
namespace Tests\Feature;
use Tests\TestCase;
use Illuminate\Foundation\Testing\WithoutMiddleware;
use Illuminate\Foundation\Testing\DatabaseMigrations;
use Illuminate\Foundation\Testing\DatabaseTransactions;
class AccessorTest extends TestCase
{
    /**
     * A basic test example.
     *
     * @return void
     */
    public function testBasicTest()
    {
        $db_post = DB::select(&#39;select * from posts where id = 1&#39;);
        $db_post_title = ucfirst($db_post[0]->name);
        $response = $this->get(&#39;/accessor/index?id=1&#39;);
        $response->assertStatus(200);
        $response->assertSeeText($db_post_title);
    }
}

熟悉功能测试的朋友应该对上面的代码不会太陌生。

首先，我们还是通过 DB 类使用原生 SQL 查询到一篇文章，并将文章的标题赋值给 $db_post_title 变量。接着我们模拟一个访问 /accessor/index?id=1 URI 的 GET 请求，并通过 $response 变量接收响应。

然后，我们去匹配请求响应的状态码是否为 200。在我们的测试用例中的这个 GET 请求响应状态码应该是 200。此外，测试后还将获取到一个首字母大写的标题，判断标题是否与 $db_post_title 相对的方法是 assertSeeText。

编写完成所有的测试用例后。接下来需要去执行这些测试用例。在 Laravel 项目中运行 PHPUnit 测试用例，仅需在项目更目录执行下面的命令。

$ phpunit

这个命令会运行项目中的所有测试用例。测试中的断言会以标准的 PHPUnit 输出显示在控制台。

总结

今天，我们探讨了 Laravel 内置测试组件 PHPUnit 的测试用例实现方法。本文仅涉及 PHPUnit 「单元测试」和「功能测试」的基础知识，工作中我们还需要结合实际出发，对 PHPUnit 测试进行深入研究才行。

此外，我们还学习了通过使用 artisan 命令行工具创建分别创建了用于单元测试和功能测试的测试用例的方法。

原文地址：https://learnku.com/laravel/t/33394

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!