Ujian Unit dalam Laravel dengan Sanctum

Apa khabar anak-anak saya, saya harap anda bergembira dan menikmati minggu yang hebat, malah bulan yang lebih baik. Saya menulis siaran ini dalam thedevgang.com dan saya berkongsinya di sini supaya ia mempunyai lebih banyak penglibatan dengan anda semua. Saya harap awak suka :3

Ia sudah menjadi pencapaian terakhir tahun 2024 dan perkara lain, yang tidak patut dibincangkan pada masa ini. Nah, dalam catatan blog sebelum ini kami memindahkan perpustakaan pengesahan Pasport ke Sanctum, namun, sekarang, saya ingin menyelidiki ujian unit beberapa titik akhir dan dengan itu dapat melaksanakannya dalam saluran penyepaduan berterusan seperti Github Actions

Sebelum ini, saya telah menulis tentang cara melakukan ujian unit dengan Pasport dalam dev.to, siaran ini boleh didapati di sini, di mana saya juga menerangkan apakah ujian unit dan aspek asas tentang pelaksanaannya dalam Laravel. Dalam siaran ini, kami akan membincangkan perkara berikut:

• Ujian unit sudah pun dengan Sanctum dilaksanakan
• Menguji beberapa titik akhir

Ujian unit dengan Sanctum dilaksanakan

Dalam kes siaran ini, saya mempunyai beberapa titik akhir yang saya susun untuk projek alternatif yang telah saya bangunkan selama beberapa bulan. Projek ini mempunyai ciri-ciri berikut dari segi rangka kerja dan lain-lain:

• Laravel 11 dengan Sanctum 4
• PHPUnit 10
• Laravel Sail sebagai persekitaran pembangunan

Dalam kes ini, kami akan menguji tiga titik akhir yang kami sediakan untuk proses pengesahan aplikasi ini, mula-mula kami akan melakukan perkara yang sesuai dengan kaedah berikut:

public function login(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'email' => 'required|email',
            'password' => 'required',
            'device_id' => 'required',
        ]);

        if ($validator->fails()) {
            return response()->json(['success' => false, 'error' => $validator->errors()], $this->badRequestStatus);
        }

        $result = $this->getToken(request('email'), request('password'), request('device_id'));

        if ($result['success'] == true) {
            return response()->json($result, $this->successStatus);
        } else {
            return response()->json(['success' => false, 'error' => 'Unauthorized'], $this->unauthorizedStatus);
        }
    }

Kaedah ini ialah kaedah yang menguruskan sepenuhnya proses log masuk apl kami, namun pendaftaran tidak disertakan dalam coretan ini, itu akan menjadi yang seterusnya untuk diuji. Dalam kes ini, kami telah mengesahkannya dan ia nampaknya berfungsi dengan betul, tetapi untuk memastikan perkara ini, kami akan menyediakan ujian masing-masing.

Mula-mula dengan terminal masukkan arahan ini:

php artisan make:test UserTest --unit

Ini akan mencipta fail UserTest dalam folder tests/Unit, yang akan menjadi "kosong" sepenuhnya, seperti berikut:

<?php

namespace Tests\Unit;

use PHPUnit\Framework\TestCase;

class ExampleTest extends TestCase
{
    /**
     * A basic test example.
     */
    public function test_basic_test(): void
    {
        $this->assertTrue(true);
    }
}

Padamkan kaedah test_basic_test(), kami tidak memerlukannya. Dalam kes ini saya katakan bahawa ia adalah kosong kerana ia hanya olok-olok ujian unit kami dan untuk kali ini ia akan menjadi yang kami gunakan untuk kaedah yang disebutkan di atas. Sekarang, sebelum mula menjadualkan ujian, kami perlu memastikan kes penggunaan yang akan kami laksanakan dan ujian, oleh itu kami mempunyai kes penggunaan berikut untuk diuji:

1. Log masuk dengan betul.
2. Log masuk tidak sah memasukkan semua data.
3. Pendaftaran yang betul.
4. Pendaftaran profil yang betul.
5. Pendaftaran profil salah kerana tidak memasukkan data.
6. Profil tidak ditemui.
7. Pendaftaran profil yang betul dan maklum balasnya.

Apabila kes penggunaan telah disenaraikan, kami mengambil kira bahawa kes yang diliputi oleh kaedah yang dinyatakan di atas dalam kes ini ialah kes 1 dan 2, jadi kami akan meneruskannya.

Persediaan ujian

Sekarang, sebelum mula mengodkan ujian, kita perlu mengkonfigurasinya supaya ia boleh dilaksanakan dengan betul, kita akan mencipta kaedah setUp dalam fail UserTest, yang melaksanakan arahan sebelum melaksanakan ujian unit. . Di sinilah kita boleh memberitahu sistem bahawa ia mesti menjalankan migrasi dan dapat memulakannya jika data diperlukan, serta penetapan nilai dalam pembolehubah. Kaedah setUp yang akan kami buat adalah berstruktur seperti ini:

public function setUp(): void
    {
        parent::setUp();
        $this->faker = \Faker\Factory::create();

        $this->name = $this->faker->name();
        $this->password = 'password';
        $this->email = 'valid@test.com';
        $this->deviceId = $this->faker->uuid();

        Artisan::call('migrate:fresh', ['-vvv' => true]);
    }

Persediaan akan melakukan perkara berikut:

• Buat contoh Faker, perpustakaan untuk mensimulasikan kemasukan data pelbagai jenis pembolehubah.
• Kami mencipta nama rekaan
• Kami menetapkan kata laluan dan e-mel kepada nilai lalai.
• Kami memberikan ID peranti rekaan juga dengan pemalsu.
• Akan menjalankan migrasi pangkalan data

Di atas kaedah ini, isytiharkan pembolehubah global yang akan kami gunakan untuk semua ujian kami:

public $faker;
public $name;
public $email;
public $password;
public $deviceId;

Pembangunan ujian unit

Untuk ujian 1, kami perlu memastikan log masuk adalah betul dengan menggunakan titik akhir yang akan kami panggil dalam apl kami. Kami akan mencipta kaedah test_login_success dan ia akan kelihatan seperti ini:

public function test_login_success()
    {
        Artisan::call('db:seed', ['-vvv' => true]);

        $body = [
            'email' => $this->email,
            'password' => $this->password,
            'device_id' => $this->deviceId
        ];

        $this->json('POST', '/api/login', $body, ['Accept' => 'application/json'])
            ->assertStatus(200)->assertJson([
                "success" => true
            ]);
    }

Este método, primeramente alimentará la base de datos con los catálogos pertinentes para poder confirmar que los mismos existen sin problemas. Después asignará el body y enviará los datos por medio de un request POST, al enviarlo, revisará que el status que devuelva su llamada es 200 y que los datos sean conforme al arreglo solicitado para confirmar, en este caso [ “success” => true ]. Si todo sale bien y se cumplen las condiciones, se considera prueba satisfactoria, en caso contrario, se considerará fallida y es donde se tendrá que revisar nuevamente el código.

Ahora bien, haremos el caso de uso 2. Para ello crea un método llamado test_login_error_with_data_ok e ingresa el siguiente código:

public function test_login_error_with_data_ok()
    {
        Artisan::call('db:seed', ['-vvv' => true]);

        $body =  [
            'email' => 'invalid@test.com',
            'password' => 'password',
            'device_id' => $this->deviceId
        ];

        $this->json('POST', '/api/login', $body)
            ->assertStatus(401)->assertJson([
                "success" => false
            ]);
    }

A diferencia del anterior, en este caso, se le entregan datos erróneos y se solicita que confirme que el endpoint devuelva un error 401, así como un body [“success” => false ], esto con el fin de que se confirme que el sistema deniega el acceso a alguien que no tenga credenciales correctas.

Con esto, cubrimos el método presentado anteriormente y ya quedaría cubierto el método. Para poder probarlo, podemos ejecutar el siguiente comando bajo Sail:

docker compose exec laravel.test php artisan test

Te mostrará los siguientes resultados:

PASS  Tests\Unit\UserTest
  ✓ login error with data ok 0.08s  
  ✓ login success 0.16s

Si te sale todo bien como te lo he mostrado, tus unit tests han salido satisfactoriamente, pero estamos lejos de terminar. Ahora necesitamos probar el siguiente método:

public function register(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'email' => 'required|email|unique:users',
            'password' => 'required',
            'c_password' => 'required|same:password',
            'device_id' => 'required',
        ]);

        if ($validator->fails()) {
            return response()->json(['success' => false, 'error' => $validator->errors()], $this->badRequestStatus);
        }

        $password = $request->password;
        $input = $request->all();
        $input['password'] = bcrypt($password);
        $user = User::create($input);

        if (null !== $user) {
            $result = $this->getToken($user->email, $password, $request->device_id);

            if ($result['success'] == true) {
                return response()->json($result, $this->successStatus);
            } else {
                return response()->json(['success' => false, 'error' => 'Unauthorized'], $this->unauthorizedStatus);
            }
        }
    }

En este caso, realizaremos el caso de uso 3, el cual solicita confirmar que el registro sea correcto, para ello, crea el método test_register_success e ingresa el siguiente código:

public function test_register_success()
    {
        $body = [
            'name' => $this->name,
            'email' => $this->email,
            'password' => $this->password,
            'c_password' => $this->password,
            'device_id' => $this->deviceId
        ];

        $this->json('POST', '/api/register', $body)
            ->assertStatus(200)->assertJson([
                "success" => true
            ]);
    }

Al igual que con el login, solicitamos que nos confirme el sistema que se nos está entregando un código 200 así como el arreglo [“success” => true], si logramos eso, ya hemos terminado, pero si te das cuenta, nos hace falta la prueba en caso de que se equivoque el usuario. Ese método te lo dejo de tarea para que puedas corroborar tus conocimientos.

Ahora bien probaremos los siguientes métodos:

public function profile()
    {
        $user = Auth::user();
        $profile = Profile::find($user->id);

        if (null !== $profile) {
            return response()->json(["success" => true, "data" => $user], $this->successStatus);
        } else {
            return response()->json(['success' => false, 'message' => 'Usuario no encontrado.'], $this->notFoundStatus);
        }
    }

public function createProfile(Request $request)
    {
        try {
            $validator = Validator::make($request->all(), [
                'first_name' => 'required',
                'last_name' => 'required',
                'birth_date' => 'required|date',
                'bloodtype' => 'required|numeric',
                'phone' => 'required',
                'gender' => 'required|numeric',
                'country' => 'required|numeric',
                'state' => 'required|numeric',
            ]);

            if ($validator->fails()) {
                return response()->json(['success' => false, 'error' => $validator->errors()], $this->badRequestStatus);
            }

            $user = Auth::user();
            $profile = Profile::where(['user_id' => $user->id])->first();

            $data = [
                'user_id' => $user->id,
            ];

            $dataInsert = array_merge($data, $request->all());

            if (null !== $profile) {
                $profile = $profile->update($dataInsert);
            } else {
                $profile = Profile::create($dataInsert);
            }


            return response()->json(["success" => true, "message" => 'Perfil actualizado correctamente.'], $this->successStatus);
        } catch (QueryException $e) {
            return response()->json(["success" => false, "message" => 'Error al actualizar el perfil.'], $this->internalServerErrorStatus);
        }
    }

Este par de métodos son los referentes a la gestión del perfil del usuario y su retroalimentación, por lo que los casos de uso que debemos probar son del 4 al 7. Para el caso 4, debemos crear un nuevo método llamado test_register_profile_success y agregamos el siguiente código:

public function test_register_profile_success()
    {
        $body = [
            'first_name' => $this->faker->firstName,
            'last_name' => $this->faker->lastName,
            'birth_date' => '1987-10-10',
            'bloodtype' => 1,
            'phone' => $this->faker->phoneNumber,
            'gender' => 1,
            'country' => 1,
            'state' => 1,
        ];

        $user = User::factory()->create();
        $token = $user->createToken('TestToken')->plainTextToken;

        $response = $this->withHeaders([
            'Authorization' => 'Bearer ' . $token,
        ])->post('/api/user/profile', $body);

        $response->assertStatus(200);
    }

En esta ocasión, necesitamos declarar un arreglo que simule el contenido del cuerpo del request para que pueda ser enviado correctamente por el endpoint y una vez enviado, el confirmar que el request tiene una respuesta satisfactoria (200).

Para el caso del perfil erróneo por no ingresar datos, necesitamos agregar un nuevo método que denominaremos test_register_profile_validation_failed, el cual implementaremos de la siguiente forma:

public function test_register_profile_validation_failed()
    {
        $user = User::factory()->create();
        $token = $user->createToken('TestToken')->plainTextToken;

        $response = $this->withHeaders([
            'Authorization' => 'Bearer ' . $token,
        ])->post('/api/user/profile', []);

        $response->assertStatus(400);
    }

En este caso, es prácticamente el mismo contenido de la prueba anterior, con la diferencia que ahora le enviamos un arreglo en blanco, para poder asegurarnos que si no se están enviando los datos correctamente, no permita la creación del perfil del usuario por medio de un Bad Request error (400).

El siguiente método probará que en caso de no encontrar el perfil de algún usuario, así lo indique con un código 404, por lo que creamos otro método denominado test_obtain_profile_not_found e ingresando el siguiente código.

public function test_obtain_profile_not_found()
    {
        $user = User::factory()->create();
        $token = $user->createToken('TestToken')->plainTextToken;

        $response = $this->withHeaders([
            'Authorization' => 'Bearer ' . $token,
        ])->get('/api/user/profile');

        $response->assertStatus(404);
    }

En el modelo de negocio, nosotros al registrarnos, creamos el usuario, mas no el perfil que tiene que ser ingresado posteriormente, por lo que al momento de ejecutar la prueba unitaria, al ejecutar el request para obtener el perfil, nos enviará un código 404, comportamiento que estamos buscando para esta prueba unitaria.

Finalmente para el último caso de uso, crearemos el método test_register_profile_and_obtain para confirmar que un mismo test pueda obtener dos comportamientos en un mismo flujo. Para este caso implementaremos el siguiente código:

public function test_register_profile_and_obtain()
    {
        $body = [
            'first_name' => $this->faker->firstName,
            'last_name' => $this->faker->lastName,
            'birth_date' => '1987-10-10',
            'bloodtype' => 1,
            'phone' => $this->faker->phoneNumber,
            'gender' => 1,
            'country' => 1,
            'state' => 1,
        ];

        $user = User::factory()->create();
        $token = $user->createToken('TestToken')->plainTextToken;

        $this->withHeaders([
            'Authorization' => 'Bearer ' . $token,
        ])->post('/api/user/profile', $body);

        $response = $this->withHeaders([
            'Authorization' => 'Bearer ' . $token,
        ])->get('/api/user/profile');

        $response->assertStatus(200);
    }

En este test, implementamos dos casos de uso realizados previamente, el primero es la creación del perfil y posteriormente, retroalimentamos el perfil, indicando a PHPUnit que deseamos confirmar que el response del endpoint que retroalimenta el perfil sea satisfactoria (código 200). Igualmente podríamos realizar el assert de la inserción de datos cambiando algunas líneas de código, pero por el momento es más que suficiente.

Ya terminando las pruebas unitarias, procedemos a ejecutar el comando docker compose exec laravel.test php artisan test y confirmamos el estatus de nuestras pruebas unitarias. Si nos salen de esta forma:

PASS  Tests\Unit\UserTest
  ✓ login error with data ok.                 0.10s  
  ✓ login success.                            0.15s  
  ✓ register success.                         0.20s  
  ✓ register profile success.                 0.10s  
  ✓ register profile validation failed.       0.09s  
  ✓ obtain profile not found.                 0.10s  
  ✓ register profile and obtain.              0.10s  

Las pruebas unitarias salieron satisfactorias. En caso contrario, checa lo siguiente:

• La méthode qui a eu des problèmes, vérifiez qu'il ne s'agit pas d'une situation de code.
• Vérifiez que la configuration de PHPUnit est appropriée, nous y reviendrons dans le prochain post.

De même, je vais vous expliquer comment configurer Github Actions pour y exécuter des tests unitaires et même pouvoir obtenir des rapports de couverture de code et un éventuel déploiement continu. J'espère que cet article, bien que long, servira à vous donner plus de contexte sur les tests unitaires et sur un processus d'intégration et de déploiement continu.

Bon codage !

Atas ialah kandungan terperinci Ujian Unit dalam Laravel dengan Sanctum. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!