Company name
Company name
Quay lại

Laravel Testing Và Cách Hoạt Động Của Từng Loại Chuyên mục PHP và Laravel    2024-05-22    14 Lượt xem    13 Lượt thích    comment-3 Created with Sketch Beta. 0 Bình luận

Laravel Testing Và Cách Hoạt Động Của Từng Loại

Như các bạn biết việc viết Unit test sẽ đảm bảo tính đúng đắn và tin cậy của ứng dụng của chúng ta, với mình hầu như các dự án làm với thị trường Nhật mình sẽ phải viết Unit test, hôm nay mình sẽ tóm tắt lại có những loại Unit test nào trong Laravel, cách thức hoạt động của từng loại. Ok chúng ta cùng bắt đầu thôi!

Các loại test chính trong Laravel bao gồm:

  • HTTP Tests
  • Console Tests
  • Browser Tests
  • Database
  • Mocking

Thực tế, Laravel hỗ trợ cho việc kiểm thử đó là sử dụng Pest và PHPUnit đã được tích hợp sẵn, và một tệp phpunit.xml dùng để cấu hình loại cơ sở dữ liệu nào sẽ được dùng để test, ENV...

Đối với Pest test này mình cũng đã viết một bài khá lâu rồi bạn nào muốn biết thêm về nó thì có thể xem qua bài Cách sử dụng Pest để viết unit test trong Laravel - (2023). Với bài ngày hôm nay chúng ta chỉ tập chung vào PHPUnit.

Theo mặc định, thư mục tests của ứng dụng của bạn chứa hai thư mục: Feature và Unit.

Unit Test:

  • Unit Test là các bài test tập trung vào việc kiểm tra các thành phần nhỏ nhất của ứng dụng như các phương thức của class hoặc các hàm độc lập. Các bài test này giúp đảm bảo rằng từng thành phần hoạt động đúng như mong đợi.
  • Ví dụ: 
    • use Tests\TestCase;
use App\Models\User;

class UserTest extends TestCase
{
    public function testUserFullName()
    {
        $user = new User();
        $user->first_name = 'John';
        $user->last_name = 'Doe';

        $this->assertEquals('John Doe', $user->full_name);
    }
}
    • Trong ví dụ này, chúng ta kiểm tra phương thức full_name của Model User để đảm bảo rằng nó trả về đúng tên đầy đủ.

Feature Test:

  • Feature Test (còn gọi là Integration Test) kiểm tra sự tương tác của nhiều thành phần trong ứng dụng. Nó kiểm tra các tuyến (routes), middleware, controllers và views, HTTP request... để đảm bảo rằng chúng hoạt động đúng khi kết hợp với nhau.
  • Ví dụ: 
    • use Tests\TestCase;
use Illuminate\Foundation\Testing\RefreshDatabase;
use App\Models\User;

class UserFeatureTest extends TestCase
{
    use RefreshDatabase;

    public function testUserCanBeCreated()
    {
        $response = $this->post('/users', [
            'name' => 'John Doe',
            'email' => 'john@example.com',
            'password' => 'password',
        ]);

        $response->assertStatus(201);
        $this->assertDatabaseHas('users', [
            'email' => 'john@example.com',
        ]);
    }
}
    • Trong ví dụ này, chúng ta kiểm tra xem người dùng có thể được tạo thành công và lưu trữ trong cơ sở dữ liệu.

Bên trên là ý nghĩa của việc sử dụng Feature và Unit, bây giờ chúng ta sẽ cùng nhau sang các loại test được sử dụng trong laravel.

HTTP Tests

Như các bạn biết thường thì khi chúng ta test sẽ là tính năng của một ứng dụng ví dụ như xoá, update, hoặc một logic nào đó liên quan đến routes, middleware, controllers và views, chính vì thế việc mà viết một HTTP test sẽ được sử dụng trong Feature test.

HTTP Tests giúp chúng ta kiểm tra các yêu cầu HTTP gửi đến ứng dụng Laravel. Các bài kiểm thử này mô phỏng các yêu cầu như GET, POST, PUT, DELETE và kiểm tra các response từ ứng dụng. Laravel cung cấp nhiều helper methods để dễ dàng kiểm tra phản hồi của ứng dụng.

Mình đưa ra một ví dụ như thế này:

Giả sử chúng ta có một API endpoint cho phép tạo mới một user. Chúng ta sẽ viết một HTTP test để kiểm tra endpoint này.

1. Tạo Route và Controller

Route (trong routes/web.php hoặc routes/api.php):

use App\Http\Controllers\UserController;

Route::post('/users', [UserController::class, 'store']);​

Controller (trong app/Http/Controllers/UserController.php):

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\User;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;

class UserController extends Controller
{
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'name' => 'required|string|max:255',
            'email' => 'required|string|email|max:255|unique:users',
            'password' => 'required|string|min:8',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 422);
        }

        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => Hash::make($request->password),
        ]);

        return response()->json(['user' => $user], 201);
    }
}​

2. Tạo HTTP Test

Sử dụng lệnh Artisan để tạo một HTTP test:

php artisan make:test UserTest​

Test File (trong tests/Feature/UserTest.php):

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
use App\Models\User;

class UserTest extends TestCase
{
    use RefreshDatabase;

    /** @test */
    public function it_can_create_a_user()
    {
        $response = $this->postJson('/users', [
            'name' => 'John Doe',
            'email' => 'john@example.com',
            'password' => 'password123',
        ]);

        $response->assertStatus(201)
                 ->assertJson([
                     'user' => [
                         'name' => 'John Doe',
                         'email' => 'john@example.com',
                     ],
                 ]);

        $this->assertDatabaseHas('users', [
            'email' => 'john@example.com',
        ]);
    }

    /** @test */
    public function it_requires_a_name()
    {
        $response = $this->postJson('/users', [
            'email' => 'john@example.com',
            'password' => 'password123',
        ]);

        $response->assertStatus(422)
                 ->assertJsonValidationErrors('name');
    }

    /** @test */
    public function it_requires_a_valid_email()
    {
        $response = $this->postJson('/users', [
            'name' => 'John Doe',
            'email' => 'not-an-email',
            'password' => 'password123',
        ]);

        $response->assertStatus(422)
                 ->assertJsonValidationErrors('email');
    }

    /** @test */
    public function it_requires_a_unique_email()
    {
        User::factory()->create([
            'email' => 'john@example.com',
        ]);

        $response = $this->postJson('/users', [
            'name' => 'John Doe',
            'email' => 'john@example.com',
            'password' => 'password123',
        ]);

        $response->assertStatus(422)
                 ->assertJsonValidationErrors('email');
    }

    /** @test */
    public function it_requires_a_password_with_min_length()
    {
        $response = $this->postJson('/users', [
            'name' => 'John Doe',
            'email' => 'john@example.com',
            'password' => 'short',
        ]);

        $response->assertStatus(422)
                 ->assertJsonValidationErrors('password');
    }
}

Giải Thích Các Phần Của HTTP Test:

  1. Setup and Refresh Database:
    • use RefreshDatabase;: Đảm bảo rằng mỗi bài test bắt đầu với một cơ sở dữ liệu mới.
  2. Test Methods:
    • it_can_create_a_user(): Kiểm tra việc tạo mới một người dùng và xác nhận rằng phản hồi trả về đúng trạng thái HTTP 201 và dữ liệu JSON chứa thông tin người dùng mới. Nó cũng kiểm tra rằng người dùng đã được lưu vào cơ sở dữ liệu.
    • it_requires_a_name(): Kiểm tra rằng việc tạo người dùng mà không có tên sẽ trả về lỗi xác thực với trạng thái HTTP 422.
    • it_requires_a_valid_email(): Kiểm tra rằng email phải có định dạng hợp lệ.
    • it_requires_a_unique_email(): Kiểm tra rằng email phải là duy nhất.
    • it_requires_a_password_with_min_length(): Kiểm tra rằng mật khẩu phải có độ dài tối thiểu.
Sử dụng trong những trường hợp nào:
  • Kiểm Tra API
  • Kiểm Tra Xác Thực và Phân Quyền 
    • public function test_unauthenticated_user_cannot_access_profile()
{
    $response = $this->get('/profile');

    $response->assertRedirect('/login');
}

public function test_authenticated_user_can_access_profile()
{
    $user = User::factory()->create();

    $response = $this->actingAs($user)->get('/profile');

    $response->assertStatus(200)
             ->assertSee('Profile');
}
  • Kiểm Tra Form Submission 
    • public function test_form_submission()
{
    $response = $this->post('/form-submit', [
        'name' => 'John Doe',
        'email' => 'johndoe@example.com',
    ]);

    $response->assertRedirect('/form-success')
             ->assertSessionHas('message', 'Form submitted successfully.');
}
  • Kiểm Tra Chuyển Hướng 
    • public function test_redirect_after_login()
{
    $user = User::factory()->create();

    $response = $this->post('/login', [
        'email' => $user->email,
        'password' => 'password',
    ]);

    $response->assertRedirect('/home');
}
  • Kiểm Tra Nội Dung Trang 
    • public function test_homepage_content()
{
    $response = $this->get('/');

    $response->assertStatus(200)
             ->assertSee('Welcome to our website');
}

Console Tests

Trong Laravel, Console Tests giúp bạn kiểm tra các lệnh Artisan, bao gồm cả các lệnh tùy chỉnh mà bạn tạo ra. Laravel cung cấp các phương thức để mô phỏng việc gọi các lệnh Artisan từ dòng lệnh và kiểm tra kết quả trả về, đầu ra của lệnh.

Cách Thức Hoạt Động

Console Tests thường được viết trong các tệp test nằm trong thư mục tests/Feature của dự án Laravel. Bạn có thể sử dụng các phương thức của Laravel để mô phỏng việc gọi lệnh và kiểm tra kết quả.

Ví Dụ

Giả sử bạn có một lệnh Artisan tùy chỉnh để tạo người dùng mới. Lệnh này có tên là create:user.

Tạo Lệnh Artisan

Trước tiên, hãy tạo một lệnh Artisan bằng cách sử dụng lệnh Artisan trong terminal:

php artisan make:command CreateUser​

Điều này sẽ tạo ra một tệp lệnh tại app/Console/Commands/CreateUser.php. Giả sử lệnh của bạn trông như sau:

namespace App\Console\Commands;

use Illuminate\Console\Command;
use App\Models\User;

class CreateUser extends Command
{
    protected $signature = 'create:user {name} {email} {password}';
    protected $description = 'Create a new user';

    public function handle()
    {
        $user = User::create([
            'name' => $this->argument('name'),
            'email' => $this->argument('email'),
            'password' => bcrypt($this->argument('password')),
        ]);

        $this->info('User created successfully.');
    }
}​

Viết Console Test

Bây giờ, hãy viết một bài kiểm thử cho lệnh này. Tạo một tệp test trong thư mục tests/Feature nếu chưa có, ví dụ: tests/Feature/CreateUserCommandTest.php.

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
use App\Models\User;

class CreateUserCommandTest extends TestCase
{
    use RefreshDatabase;

    public function test_create_user_command()
    {
        $this->artisan('create:user', [
            'name' => 'John Doe',
            'email' => 'johndoe@example.com',
            'password' => 'secret'
        ])
        ->expectsOutput('User created successfully.')
        ->assertExitCode(0);

        $this->assertDatabaseHas('users', [
            'name' => 'John Doe',
            'email' => 'johndoe@example.com',
        ]);
    }
}​
Giải Thích
  • use RefreshDatabase;: Sử dụng trait này để đảm bảo cơ sở dữ liệu được làm mới khi test, đảm bảo môi trường kiểm thử clean.
  • $this->artisan('create:user', [...]): Gọi lệnh Artisan với các tham số cần thiết.
  • ->expectsOutput('User created successfully.'): Kiểm tra đầu ra của lệnh có chứa chuỗi cụ thể.
  • ->assertExitCode(0);: Kiểm tra mã thoát (exit code) của lệnh là 0, cho biết lệnh đã chạy thành công.
  • $this->assertDatabaseHas('users', [...]): Kiểm tra cơ sở dữ liệu để đảm bảo người dùng đã được tạo với thông tin đúng.
Khi Nào Sử Dụng Console Tests
  • Khi bạn có các lệnh Artisan tùy chỉnh và muốn đảm bảo chúng hoạt động đúng.
  • Khi bạn cần kiểm tra các tương tác của lệnh với cơ sở dữ liệu hoặc các dịch vụ khác.
  • Khi bạn muốn đảm bảo rằng các lệnh Artisan xử lý đầu vào và đầu ra một cách chính xác.

Console Tests là một phần quan trọng trong việc kiểm thử ứng dụng Laravel, đảm bảo rằng các lệnh Artisan của bạn hoạt động đúng như mong đợi và giúp duy trì chất lượng mã nguồn của bạn.

Browser Tests

Browser Tests trong Laravel, thường được thực hiện bằng Laravel Dusk, là cách kiểm thử tự động hóa trình duyệt để mô phỏng các tương tác của người dùng với ứng dụng web. Laravel Dusk cung cấp API mạnh mẽ để thực hiện các hành động như nhấp chuột, điền vào biểu mẫu, và điều hướng qua các trang web, cho phép bạn kiểm tra ứng dụng một cách chi tiết.

Thiết Lập Laravel Dusk

Trước khi viết các Browser Tests, bạn cần cài đặt Laravel Dusk:

  1. Cài đặt Laravel Dusk:

    composer require --dev laravel/dusk​

  2. Đăng ký Dusk Service Provider: Thêm Laravel\Dusk\DuskServiceProvider::class vào mảng providers trong tệp config/app.php, chỉ khi ứng dụng đang không chạy trong môi trường sản xuất.

  3. Cấu hình ENV 
    • APP_URL=http://staging.example.com

  4. Khởi tạo Dusk:

    php artisan dusk:install​
Viết Browser Tests

Tạo một tệp test mới cho Browser Tests. Ví dụ, tạo tệp LoginTest.php trong thư mục tests/Browser.

php artisan dusk:make LoginTest​

Tệp kiểm thử sẽ nằm trong tests/Browser/LoginTest.php. Dưới đây là một ví dụ về kiểm thử đăng nhập:

namespace Tests\Browser;

use Laravel\Dusk\Browser;
use Tests\DuskTestCase;
use App\Models\User;
use Illuminate\Foundation\Testing\DatabaseMigrations;

class LoginTest extends DuskTestCase
{
    use DatabaseMigrations;

    /**
     * A basic browser test example.
     *
     * @return void
     */
    public function test_user_can_login()
    {
        // Tạo người dùng để kiểm thử
        $user = User::factory()->create([
            'email' => 'johndoe@example.com',
            'password' => bcrypt('password'),
        ]);

        $this->browse(function (Browser $browser) use ($user) {
            $browser->visit('/login')
                    ->type('email', 'johndoe@example.com')
                    ->type('password', 'password')
                    ->press('Login')
                    ->assertPathIs('/home')
                    ->assertSee('Dashboard');
        });
    }
}​
Giải Thích
  • Tạo người dùng kiểm thử: User::factory()->create([...]) tạo một người dùng mới trong cơ sở dữ liệu để sử dụng trong kiểm thử.
  • Khởi tạo trình duyệt: $this->browse(function (Browser $browser) use ($user) {...}); sử dụng callback để thực hiện các hành động với trình duyệt.
  • Truy cập trang đăng nhập: visit('/login') điều hướng đến trang đăng nhập.
  • Điền vào biểu mẫu: type('email', 'johndoe@example.com') và type('password', 'password') điền vào các trường biểu mẫu.
  • Nhấp vào nút đăng nhập: press('Login') mô phỏng việc nhấp vào nút đăng nhập.
  • Kiểm tra điều hướng: assertPathIs('/home') kiểm tra xem người dùng đã được điều hướng đến trang /home.
  • Kiểm tra nội dung trang: assertSee('Dashboard') kiểm tra xem trang có chứa văn bản "Dashboard" hay không.
Chạy Browser Tests

Sau khi viết các bài kiểm thử, bạn có thể chạy chúng bằng cách sử dụng lệnh:

php artisan dusk​
Khi Nào Nên Sử Dụng Browser Tests
  • Kiểm tra giao diện người dùng (UI): Đảm bảo rằng giao diện người dùng hoạt động đúng như mong đợi.
  • Kiểm tra luồng người dùng: Mô phỏng các hành động của người dùng để kiểm tra toàn bộ luồng từ đầu đến cuối (end-to-end testing).
  • Kiểm tra JavaScript: Kiểm tra các tương tác và chức năng JavaScript phức tạp.
  • Kiểm tra trải nghiệm người dùng: Đảm bảo rằng người dùng có thể tương tác với ứng dụng mà không gặp lỗi.

Browser Tests với Laravel Dusk cung cấp một cách mạnh mẽ để kiểm thử ứng dụng của bạn từ góc nhìn của người dùng, đảm bảo rằng tất cả các phần của giao diện người dùng hoạt động đúng như mong đợi.

Database testing

Database testing trong Laravel là quá trình kiểm tra sự tương tác giữa mã của bạn và cơ sở dữ liệu để đảm bảo rằng các truy vấn, các hoạt động CRUD (tạo, đọc, cập nhật, xóa), và các mối quan hệ hoạt động chính xác. Laravel cung cấp nhiều công cụ và phương pháp để thực hiện các bài kiểm tra cơ sở dữ liệu, chẳng hạn như sử dụng RefreshDatabase và các phương thức hỗ trợ kiểm tra.

Dưới đây là cách thiết lập và thực hiện các bài kiểm tra cơ sở dữ liệu trong Laravel.

Thiết Lập

  1. Cấu hình .env cho testing: Trong tệp .env.testing, cấu hình kết nối cơ sở dữ liệu cho môi trường kiểm thử:

    • DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=test_database
DB_USERNAME=root
DB_PASSWORD=password

  2. Tạo migration và factory: Đảm bảo bạn đã tạo các migration và factory cho các model của bạn.

Sử Dụng RefreshDatabase

Sử dụng trait RefreshDatabase để tự động chạy migration trước mỗi bài kiểm tra, đảm bảo rằng cơ sở dữ liệu luôn ở trạng thái sạch.

Ví Dụ về Database Test

Dưới đây là ví dụ về kiểm tra CRUD cho model User.

  1. Tạo file test:

    php artisan make:test UserTest --unit​

  2. Viết bài kiểm tra:

    Mở tệp tests/Unit/UserTest.php và thêm nội dung sau:

    namespace Tests\Unit;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
use App\Models\User;

class UserTest extends TestCase
{
    use RefreshDatabase;

    /** @test */
    public function it_creates_a_user()
    {
        // Tạo người dùng bằng factory
        $user = User::factory()->create([
            'name' => 'John Doe',
            'email' => 'johndoe@example.com',
        ]);

        // Kiểm tra xem người dùng đã được tạo trong cơ sở dữ liệu
        $this->assertDatabaseHas('users', [
            'name' => 'John Doe',
            'email' => 'johndoe@example.com',
        ]);
    }

    /** @test */
    public function it_updates_a_user()
    {
        // Tạo người dùng bằng factory
        $user = User::factory()->create();

        // Cập nhật người dùng
        $user->update([
            'name' => 'Jane Doe',
        ]);

        // Kiểm tra xem thông tin người dùng đã được cập nhật trong cơ sở dữ liệu
        $this->assertDatabaseHas('users', [
            'id' => $user->id,
            'name' => 'Jane Doe',
        ]);
    }

    /** @test */
    public function it_deletes_a_user()
    {
        // Tạo người dùng bằng factory
        $user = User::factory()->create();

        // Xóa người dùng
        $user->delete();

        // Kiểm tra xem người dùng đã bị xóa khỏi cơ sở dữ liệu
        $this->assertDatabaseMissing('users', [
            'id' => $user->id,
        ]);
    }
}​
Giải Thích
  1. Tạo người dùng: Sử dụng User::factory()->create() để tạo người dùng mới trong cơ sở dữ liệu.
  2. Kiểm tra tạo người dùng: Sử dụng assertDatabaseHas để kiểm tra rằng người dùng đã được tạo trong cơ sở dữ liệu với các thuộc tính cụ thể.
  3. Cập nhật người dùng: Sử dụng phương thức update() của model để cập nhật thông tin người dùng.
  4. Kiểm tra cập nhật: Sử dụng assertDatabaseHas để kiểm tra rằng thông tin người dùng đã được cập nhật chính xác.
  5. Xóa người dùng: Sử dụng phương thức delete() của model để xóa người dùng.
  6. Kiểm tra xóa: Sử dụng assertDatabaseMissing để đảm bảo rằng người dùng đã bị xóa khỏi cơ sở dữ liệu.
Các Phương Thức Hỗ Trợ Kiểm Tra

Laravel cung cấp nhiều phương thức hữu ích để kiểm tra cơ sở dữ liệu:

  • assertDatabaseHas($table, array $data): Kiểm tra xem bảng có chứa dữ liệu không.
  • assertDatabaseMissing($table, array $data): Kiểm tra xem bảng không chứa dữ liệu.
  • assertSoftDeleted($table, array $data): Kiểm tra xem bản ghi đã bị soft delete hay chưa.
Kết Luận

Database testing trong Laravel giúp đảm bảo rằng các hoạt động tương tác với cơ sở dữ liệu của bạn hoạt động đúng như mong đợi. Sử dụng các phương pháp như RefreshDatabase và các phương thức kiểm tra có sẵn, bạn có thể viết các bài kiểm tra cơ sở dữ liệu mạnh mẽ và chính xác.

Mocking tests

Mocking là một kỹ thuật quan trọng trong kiểm thử phần mềm, cho phép bạn tạo ra các objects giả để kiểm thử hành vi của các thành phần trong ứng dụng mà không cần phụ thuộc vào việc thực thi thực tế của các thành phần đó. Laravel cung cấp các công cụ mạnh mẽ để mocking thông qua việc sử dụng thư viện PHPUnit và các phương pháp tiện ích có sẵn.

Khi Nào Sử Dụng Mocking
  • Khi bạn muốn cô lập một phần của mã để kiểm thử: Điều này giúp kiểm tra các thành phần cụ thể mà không cần thực thi toàn bộ hệ thống.
  • Khi bạn muốn giảm thời gian chạy của các bài kiểm tra: Đặc biệt hữu ích khi các thành phần phụ thuộc vào các dịch vụ bên ngoài như API, cơ sở dữ liệu, hoặc hệ thống tệp.
  • Khi bạn muốn kiểm tra các hành vi cụ thể: Như kiểm tra xem một phương thức có được gọi đúng cách không.
Ví Dụ về Mocking trong Laravel

Giả sử bạn có một lớp PaymentService để xử lý thanh toán và bạn muốn kiểm tra lớp OrderController sử dụng PaymentService.

Bước 1: Tạo Lớp Dịch Vụ và Controller

PaymentService.php

namespace App\Services;

class PaymentService
{
    public function charge($amount, $token)
    {
        // Logic thực hiện thanh toán
    }
}
OrderController.php
namespace App\Http\Controllers;

use App\Services\PaymentService;
use Illuminate\Http\Request;

class OrderController extends Controller
{
    protected $paymentService;

    public function __construct(PaymentService $paymentService)
    {
        $this->paymentService = $paymentService;
    }

    public function store(Request $request)
    {
        $this->paymentService->charge($request->amount, $request->token);

        return response()->json(['status' => 'Order processed']);
    }
}​

Bước 2: Viết Bài Kiểm Tra với Mocking

OrderControllerTest.php

namespace Tests\Feature;

use Tests\TestCase;
use App\Services\PaymentService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Mockery;

class OrderControllerTest extends TestCase
{
    use RefreshDatabase;

    public function test_order_is_processed()
    {
        // Tạo mock cho PaymentService
        $paymentServiceMock = Mockery::mock(PaymentService::class);
        
        // Định nghĩa hành vi mong muốn cho phương thức charge
        $paymentServiceMock->shouldReceive('charge')
                           ->once()
                           ->with(100, 'test_token');

        // Bind mock vào service container
        $this->app->instance(PaymentService::class, $paymentServiceMock);

        // Gửi yêu cầu đến controller
        $response = $this->postJson('/orders', [
            'amount' => 100,
            'token' => 'test_token',
        ]);

        // Kiểm tra phản hồi
        $response->assertStatus(200)
                 ->assertJson(['status' => 'Order processed']);
    }
}​
Giải Thích
  1. Tạo mock cho PaymentService: Sử dụng Mockery::mock(PaymentService::class) để tạo một mock object.
  2. Định nghĩa hành vi mong muốn: Sử dụng shouldReceive để định nghĩa hành vi mong muốn cho phương thức charge, chỉ ra rằng phương thức này sẽ được gọi một lần với các tham số cụ thể.
  3. Bind mock vào service container: Sử dụng $this->app->instance(PaymentService::class, $paymentServiceMock) để bind mock object vào service container của Laravel, thay thế cho implementation thật.
  4. Gửi yêu cầu kiểm tra: Gửi một yêu cầu POST đến endpoint /orders với dữ liệu kiểm tra.
  5. Kiểm tra phản hồi: Sử dụng các phương thức assert của PHPUnit để kiểm tra phản hồi từ controller.
Tổng Kết

Mocking là một kỹ thuật hữu ích để kiểm thử các thành phần trong ứng dụng Laravel một cách cô lập và nhanh chóng. Bằng cách sử dụng Mockery và các công cụ tích hợp trong Laravel, bạn có thể kiểm thử các hành vi cụ thể mà không cần phụ thuộc vào các dịch vụ hoặc tài nguyên bên ngoài. Điều này giúp nâng cao chất lượng kiểm thử và đảm bảo rằng các thành phần trong ứng dụng của bạn hoạt động chính xác theo mong đợi.

Bình luận (0)

Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough
Michael Gough

Bài viết liên quan

Learning English Everyday