This content originally appeared on DEV Community and was authored by Marco Ramírez
Qué hay, mis niños, espero que estén pasándola de maravilla y que estén teniendo una gran semana, e incluso un mejor mes. Este post lo escribí dentro de thedevgang.com y lo comparto por acá para que tenga más engagement con todos ustedes. Espero que les guste :3
Ya es el último jalón del 2024 y de otras cosas más, de las cuales no vale la pena platicar en este momento. Pues bien, en una publicación anterior del blog hicimos la migración de la librería de autenticación Passport a Sanctum, sin embargo, ahora, me gustaría ahondar en las pruebas unitarias de algunos endpoints y así poder ejecutarlas en algún pipeline de integración contínua como Github Actions.
Previamente, había escrito sobre cómo hacer pruebas unitarias con Passport en dev.to, este post lo puedes encontrar aquí , en donde expongo también qué son las pruebas unitarias y aspectos básicos sobre su implementación en Laravel. En este post, abarcaremos lo siguiente:
- Pruebas unitarias ya con Sanctum implementado
- Probando algunos endpoints
Pruebas unitarias con Sanctum implementado
Para el caso de este post, tengo algunos endpoints que armé para un proyecto alterno que he estado desarrollando desde hace unos meses. Este proyecto tiene las siguientes características en cuanto al framework y demás:
- Laravel 11 con Sanctum 4
- PHPUnit 10
- Laravel Sail como ambiente de desarrollo
Probaremos en este caso tres endpoints que armamos para el proceso de autenticación de esta app, primero haremos lo pertinente con el siguiente método:
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);
}
}
Este método es el que gestiona por completo el proceso de login de nuestra app, sin embargo el registro no se inclute en este snippet, ese será el próximo a probar. En este caso, lo hemos confirmado y al parecer funciona correctamente, pero para poder cerciorarnos de ello, armaremos sus respectivas pruebas.
Primeramente con terminal ingresa este comando:
php artisan make:test UserTest --unit
Esto te creará un archivo UserTest en la carpeta tests/Unit, el cual estará completamente “en blanco”, como el siguiente:
<?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);
}
}
Borra el método test_basic_test(), no lo necesitaremos. En este caso digo que está en blanco porque es únicamente el mock de nuestras pruebas unitarias y para esta ocasión será el que usemos para los métodos antes mencionados. Ahora bien, antes de comenzar a programar las pruebas, necesitamos asegurarnos de los casos de uso que estaremos ejecutando y probando, por lo tanto tenemos los siguientes casos de uso a probar:
- Login correcto.
- Login inválido ingresando todos los datos.
- Registro correcto.
- Registro del perfil correcto.
- Registro del perfil erróneo por no ingresar datos.
- Perfil no encontrado.
- Registro del perfil correcto y su retroalimentación.
Una vez enumerados los casos de uso, tenemos en cuenta de que los que cubren en este caso el método antes mencionado son los casos 1 y 2, por lo que procederemos con ellos.
Preparación de las pruebas
Ahora bien, antes de comenzar a codificar las pruebas, necesitamos configurar las mismas para que puedan ser ejecutadas correctamente, para ello crearemos dentro del archivo UserTest el método setUp, el cual realiza la ejecución de instrucciones previo a ejecutar las pruebas unitarias. Aquí es donde nosotros podemos indicarle al sistema que debe realizar las migraciones y poder comenzar con las mismas en caso de requerir datos, así como de asignación de valores en variables. El método setUp que crearemos está estructurado de esta manera:
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]);
}
El setUp hará lo siguiente:
- Crea una instancia de Faker, una librería para simular ingreso de datos de diversos tipos de variables.
- Creamos un nombre ficticio
- Asignamos el password y el correo electrónico a valores predeterminados.
- Asignamos un ID de dispositivo ficticio igualmente con el faker.
- Correrá las migraciones de la base de datos
Arriba de este método, declara las variables globales que usaremos para todas nuestras pruebas:
public $faker;
public $name;
public $email;
public $password;
public $deviceId;
Desarrollo de las pruebas unitarias
Para la prueba 1, necesitamos asegurarnos que el login es correcto invocando el endpoint al que llamaremos en nuestra app. Crearemos el método test_login_success y quedaría de la siguiente manera:
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:
- El método que haya tenido broncas, checa que no sea una situación de código.
- Checa que la configuración de PHPUnit sea la adecuada, ahondaremos en ello en el siguiente post.
Igualmente, voy a explicarles cómo configurar el Github Actions para ejecutar las pruebas unitarias en este y poder inclusive obtener reportes de cobertura de código y un posible despliegue contínuo. Espero que este post, aunque largo, sirva para que tengan más contexto sobre pruebas unitarias y sobre un proceso de integración y despliegue continuos.
Happy coding!
This content originally appeared on DEV Community and was authored by Marco Ramírez
Marco Ramírez | Sciencx (2024-09-07T00:11:49+00:00) Pruebas Unitarias en Laravel con Sanctum. Retrieved from https://www.scien.cx/2024/09/07/pruebas-unitarias-en-laravel-con-sanctum/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.