Bringen Sie Ihnen bei, wie Sie die Laravel-Testmethoden beherrschen

Die folgende Tutorial-Kolumne von Laravel wird Ihnen die Testmethode zur Beherrschung von Laravel vorstellen. Ich hoffe, dass sie Freunden in Not hilfreich sein wird!

Meistern Sie die Testmethoden von Laravel

Ob Sie es zugeben oder nicht, Sie entwickeln sich weiter a Wenn es um Produkte geht, sind Softwaretests von großer Bedeutung für das Projekt, aber Tests werden von uns oft ignoriert. In diesem Artikel untersuchen wir hauptsächlich die Testmethoden des Laravel-Frameworks.

Vielleicht wissen Sie es noch nicht, der Laravel-Kernel hat die Unit-Testing-Komponente PHPUnit bereits geerbt. PHPUnit ist eines der am weitesten verbreiteten und beliebtesten Test-Frameworks in der PHP-Community. PHPUnit unterstützt sowohl „Unit-Tests“- als auch „Funktionstests“-Funktionen.

Wir werden kurz die grundlegende Verwendung von PHPUnit „Unit Testing“ und „Functional Testing“ vorstellen. Erklären Sie anschließend, wie Sie Anwendungsfälle für „Unit-Tests“ und „Funktionstests“ in Laravel-Projekten erstellen. In diesem Artikel gehen wir jedoch davon aus, dass Sie bereits über ein grundlegendes Verständnis des PHPUnit-Testframeworks verfügen. Konzentrieren wir uns daher auf das Thema der Verwendung von PHPUnit zum Testen in Laravel.

Unit-Tests und Funktionstests

Wenn Sie mit dem PHPUnit-Framework in Berührung gekommen sind, sollten Sie wissen, dass es zwei Arten von Funktionen unterstützt – „Unit-Tests“. und „Funktionstest“.

Der Zweck von „Unit Testing“ besteht darin, die Korrektheit von Funktionen oder Methoden zu testen. Noch wichtiger ist, dass wir leicht die Richtigkeit der Codelogik erreichen können.

Wenn Sie während des Entwicklungsprozesses feststellen, dass eine bestimmte Funktion mehrere Logikverarbeitungen enthält, ist es am besten, jede Verarbeitungslogik in verschiedene Methoden aufzuteilen, um sicherzustellen, dass einzelne Methoden und Codeblöcke testbar sind.

Wir werfen auf ideale Weise einen Blick in die Geheimnisse des Unit-Tests.

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

Wie Sie sehen, verarbeitet diese Methode nur eine Geschäftslogik. Die Funktion ucfirst wird innerhalb der Methode verwendet, um Zeichen in das Großbuchstabenformat umzuwandeln.

Unit-Tests sollen die Korrektheit des Codes jeder unabhängigen Einheit sicherstellen; Funktionstests sollen die Korrektheit einer Funktion sicherstellen. Kurz gesagt geht es darum, die Korrektheit des Systems durch spezifische Testfälle zu überprüfen, um das Verhalten von Benutzern zu simulieren, die auf die Anwendung zugreifen.

Zum Beispiel können wir einen Funktionstestfall für die Anmeldefunktion implementieren, der die folgenden Schritte umfasst:

• Initiieren Sie eine GET-Anfrage, um auf die Anmeldeseite zuzugreifen

• Bestimmen Sie, ob wir uns auf der Anmeldeseite befinden

• Anmeldedaten für die Anmeldung per POST-Anfrage generieren;

  Stellen Sie fest, ob die Anmeldesitzungsdaten erfolgreich erstellt wurden.

• Das ist das Geheimnis, wie man Anwendungsfälle für „funktionale Tests“ erstellt. Als Nächstes erstellen wir spezifische Testfälle, um zu erklären, wie „Unit-Tests“ und „Funktionstests“ in Laravel verwendet werden.

Erstellen Sie eine Testumgebung

Erstellen Sie ein Testmodell

Bevor wir mit der Erstellung von Testfällen beginnen, müssen wir es erstellen zum Testen von Projektabhängigkeiten.

Führen Sie zunächst den folgenden handwerklichen Befehl aus, um ein Post-Modell und die entsprechende Migrationsdatei zu erstellen.

$ php artisan make:model Post --migration

Der obige Befehl erstellt für uns eine Post-Modellklassen- und Datenbankmigrationsdatei.

Der Post-Modellcode lautet wie folgt:

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

Die Datenbankmigrationsdatei YYYY_MM_DD_HHMMSS_create_posts_table.php wird im Verzeichnis „database/migrations“ erstellt.

In der Post-Datentabelle wird der Titel eines Artikels gespeichert. Der geänderte Code der Post-Datenbankmigrationsdatei lautet wie folgt:

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

Wie Sie sehen können, speichern wir den Titel des Artikels über den neuen $table->string('name'). Führen Sie als Nächstes den Datenbankmigrationsbefehl aus, um die entsprechende Datentabelle in der Datenbank zu erstellen.

$ php artisan migrate

Nachdem wir die Datentabelle erstellt haben, müssen wir den folgenden Code zur Post-Modellklasse hinzufügen

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

Wir haben gerade die Zugriffsmethode hinzugefügt, deren Funktion darin besteht, den Titel des Artikels zu ändern. Das ist genau das, was wir im Unit-Testfall testen wollen. Das Obige muss im Post-Modell geändert werden.

Test-Controller erstellen

Als nächstes müssen wir einen Controller mit dem Dateinamen app/Http/Controllers/AccessorController.php erstellen, der als Folgefunktion verwendet wird Testen.

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

Bei der Indexmethode fragen wir einen Artikel aus dem Post-Modell über den ID-Parameter in der Anfrage ab.

Abschließend definieren Sie relevante Routen in der Routing-Konfigurationsdatei „routes/web.php“.

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

Nachdem Sie die Route eingerichtet haben, können Sie über http://your-laravel-site.com/accessor/index darauf zugreifen, um zu sehen, ob auf die Route normal zugegriffen werden kann.

Unit-Tests

Im vorherigen Abschnitt haben wir eine Umgebung zum Testen eingerichtet. In diesem Abschnitt werden wir Unit-Testfälle in Laravel schreiben, um das Post-Modell zu testen.

Glücklicherweise stellt uns Laravel auch ein Befehlstool zum Erstellen von Testfall-Vorlagendateien zur Verfügung.

Erstellen Sie die Unit-Testfallklasse AccessorTest, indem Sie den folgenden Befehl in der Befehlszeile ausführen. Beachten Sie, dass wir die Parameteroption --unit übergeben müssen, um anzugeben, dass dieser Befehl einen Unit-Testfall erstellt. Unit-Testfalldateien werden im Verzeichnis Tests/Unit erstellt.

$ 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

Das obige ist der detaillierte Inhalt vonBringen Sie Ihnen bei, wie Sie die Laravel-Testmethoden beherrschen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!