Prueba de funciones frente a prueba unitaria y adición de respuestas a los hilos

Estamos avanzando muy bien con nuestro desarrollo basado en pruebas del foro. En este tutorial comenzaremos a abordar el concepto de agregar respuestas a los hilos. Continuaremos desarrollando el caso de prueba primero, pensando en el pseudocódigo y luego agregando el código real a la aplicación para que todo funcione. También aprovecharemos el concepto de pruebas de funciones frente a pruebas unitarias. Básicamente, cuando probamos a nivel de Característica, estamos probando desde un nivel alto de manera externa. Por primera vez en esta serie, también implementaremos una prueba unitaria que es un nivel de prueba más granular y básico. La razón de esto es que cuando falla una prueba de características, puede ser difícil encontrar el error. Si una prueba unitaria falla, generalmente es más fácil detectar el problema. Empecemos.

Refactorización de pruebas de características existentes

Podemos comenzar haciendo un poco de refactorización en nuestra clase Thread Tests existente. Vamos a cambiar el nombre de la clase a ReadThreadsTest y también implementaremos un método setUp () en la clase para secar un poco el código.

Refactorización en PHP Storm para cambiar el nombre de un archivo y una clase a la vez.
cambiar el nombre a través de refactor en phpstorm

Refactorizar el código de prueba para agregar una prueba y secar el código.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<?php
 
namespace TestsFeature;
 
use TestsTestCase;
use IlluminateFoundationTestingRefreshDatabase;
use IlluminateFoundationTestingDatabaseMigrations;
 
class ReadThreadsTest extends TestCase
{
    use DatabaseMigrations;
    
    public function setUp()
    {
        parent::setUp();
 
        $this->thread = factory('AppThread')->create();
    }
 
    public function test_a_user_can_browse_threads()
    {
        $response = $this->get('/threads');
        $response->assertSee($this->thread->title);
        $response->assertStatus(200);
    }
 
    public function test_a_user_can_read_a_single_thread()
    {
        $response = $this->get('/threads/' . $this->thread->id);
        $response->assertSee($this->thread->title);
        $response->assertStatus(200);
    }
 
    public function test_a_user_can_see_replies_that_are_associated_with_a_thread()
    {
 
    }
}

En el fragmento anterior, intentamos resaltar algunos de los cambios importantes. En primer lugar, notará que ahora tenemos una función setUp (), y esto se hace para que no necesitemos hacer una llamada a la fábrica ('AppThread') -> create () dentro de cada función de prueba. Ahora, lo llamamos una vez, lo asignamos al objeto y luego lo usamos según sea necesario. A continuación, podemos ver que necesitamos hacer algunas ediciones rápidas en el código en las funciones de prueba existentes para hacer uso de $ this-> thread en lugar de solo $ thread . Finalmente, agregamos la nueva prueba de test_a_user_can_see_replies_that_are_associated_with_a_thread () y la dejamos en blanco por el momento. Sigamos adelante y ejecutemos las pruebas solo para ver dónde estamos.

vagabundo @ homestead: ~ / Código / forumio $ phpunit
PHPUnit 6.5.2 por Sebastian Bergmann y colaboradores.

..R. 4/4 (100%)

Tiempo: 1,08 segundos, memoria: 8,00 MB

Hubo 1 prueba arriesgada:

1) TestsFeatureReadThreadsTest :: test_a_user_can_see_replies_that_are_associated_with_a_thread
Esta prueba no realizó ninguna afirmación.

¡Bien, pero pruebas incompletas, omitidas o arriesgadas!
Pruebas: 4, afirmaciones: 5, riesgosas: 1.

Interesante. Parece que las pruebas existentes están pasando, pero esa nueva prueba que agregamos se etiquetará como arriesgada. Es solo una prueba vacía, así que esto tiene sentido. Ahora, consideremos qué queremos que haga esta nueva prueba. El pseudocódigo podría verse así:

Dado que hay un hilo
Dado que este hilo tenía respuestas
Cuando un usuario visita la página del hilo
El usuario debería ver las respuestas

Traducir ese pseudocódigo en código de prueba real podría verse así:

1
2
3
4
5
6
7
    public function test_a_user_can_see_replies_that_are_associated_with_a_thread()
    {
        $reply = factory('AppReply')->create(['thread_id' => $this->thread->id]);
        $response = $this->get('/threads/' . $this->thread->id);
        $response->assertSee($reply->body);
        $response->assertStatus(200);
    }

Ejecutar la prueba nos da una falla esperada, ya que ni siquiera tenemos ese código para admitir la función todavía. Básicamente, lo siguiente nos muestra que no vemos el cuerpo de la respuesta en la página.

vagabundo @ homestead: ~ / Código / forumio $ phpunit
PHPUnit 6.5.2 por Sebastian Bergmann y colaboradores.

..F. 4/4 (100%)

Tiempo: 1,45 segundos, memoria: 10,00 MB

Hubo 1 falla:

1) TestsFeatureReadThreadsTest :: test_a_user_can_see_replies_that_are_associated_with_a_thread
No se afirma que (el html) contiene "Libero aliquam officiis id. Consequatur magni deserunt nesciunt ipsum. Iste ipsam voluptate unde est. Hic aspernatur corrupti iure sit."

¡Aproveche la prueba!

¡Mirad! Ahora debemos asumir nuestra tarea de aprobar la prueba. Veamos qué tenemos que hacer.

Primero, necesitamos mostrar las respuestas en la página de hilos. Abramos /resources/threads/show.blade.php y agreguemos el código así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@extends('layouts.app')
 
@section('content')
    <div class="container">
        <div class="row">
            <div class="col-md-8 col-md-offset-2">
                <div class="panel panel-default">
                    <div class="panel-heading">{{ $thread->title }}</div>
 
                    <div class="panel-body">
                        {{ $thread->body }}
                    </div>
                </div>
            </div>
        </div>
 
        <div class="row">
            <div class="col-md-8 col-md-offset-2">
                @foreach($thread->replies as $reply)
                    <div class="panel panel-default">
                        <div class="panel-body">
                            {{ $reply->body }}
                        </div>
                    </div>
                @endforeach
            </div>
        </div>
    </div>
@endsection

Ahora, así es como nos gustaría poder usar el marcado en esa página. Ni siquiera necesitamos ejecutar las pruebas para saber que va a fallar, ya que no tenemos un método de respuestas en el modelo Thread. En otras palabras, estamos tratando de hacer uso de una relación en el modelo que aún no se ha creado, así que agreguemos eso a nuestro Modelo ahora. Un hilo puede tener muchas respuestas, así que usaremos la relación hasMany () así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
 
class Thread extends Model
{
    public function path()
    {
        return '/threads/' . $this->id;
    }
 
    public function replies()
    {
        return $this->hasMany(Reply::class);
    }
}

Muy genial. Ahora, en teoría, todas nuestras pruebas deberían pasar. Ejecutarlos nos muestra que, de hecho, este es el caso.

vagabundo @ homestead: ~ / Código / forumio $ phpunit
PHPUnit 6.5.2 por Sebastian Bergmann y colaboradores.

.... 4/4 (100%)

Tiempo: 1,05 segundos, memoria: 8,00 MB

OK (4 pruebas, 7 afirmaciones)

Esto significa que si ahora visitamos un ID de hilo específico, también deberíamos ver todas las respuestas asociadas con él.
cada hilo ahora tiene respuestas

Hacer uso de una prueba unitaria

Todavía no hemos configurado la capacidad de ver al propietario de una respuesta en la página. Podemos hacerlo agregando el siguiente código a nuestro archivo de vista.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
@extends('layouts.app')
 
@section('content')
    <div class="container">
        <div class="row">
            <div class="col-md-8 col-md-offset-2">
                <div class="panel panel-default">
                    <div class="panel-heading">{{ $thread->title }}</div>
 
                    <div class="panel-body">
                        {{ $thread->body }}
                    </div>
                </div>
            </div>
        </div>
 
        <div class="row">
            <div class="col-md-8 col-md-offset-2">
                @foreach($thread->replies as $reply)
                    <div class="panel panel-default">
                        <div class="panel-body">
                            {{$reply->owner->name}} said {{ $reply->created_at->diffForHumans() }}
                        </div>
                        <div class="panel-body">
                            {{ $reply->body }}
                        </div>
                    </div>
                @endforeach
            </div>
        </div>
    </div>
@endsection

Esto presenta un buen momento para configurar una prueba unitaria . Podemos hacerlo con el comando:

vagrant @ homestead: ~ / Code / forumio $ php artisan make: test ReplyTest --unit
Prueba creada con éxito.

Ahora lo que queremos hacer con esta prueba unitaria es simplemente confirmar que tiene un propietario. En otras palabras, estamos probando que la relación entre la respuesta de un hilo y el propietario sea válida. El código en la prueba para esto podría verse así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
 
namespace TestsUnit;
 
use IlluminateFoundationTestingDatabaseMigrations;
use TestsTestCase;
use IlluminateFoundationTestingRefreshDatabase;
 
class ReplyTest extends TestCase
{
    use DatabaseMigrations;
    
    public function test_it_has_an_owner()
    {
        $reply = factory('AppReply')->create();
 
        $this->assertInstanceOf('AppUser', $reply->owner);
    }
}

Intentemos ejecutar la prueba.

vagrant @ homestead: ~ / Code / forumio $ phpunit tests / Unit / ReplyTest
PHPUnit 6.5.2 por Sebastian Bergmann y colaboradores.

F 1/1 (100%)

Tiempo: 675 ms, memoria: 8,00 MB

Hubo 1 falla:

1) TestsUnitReplyTest :: test_it_has_an_owner
No se pudo afirmar que null es una instancia de la clase "AppUser".

/home/vagrant/Code/forumio/tests/Unit/ReplyTest.php:17

¡FALLOS!
Pruebas: 1, afirmaciones: 1, fallos: 1.

La prueba falla pero es agradable y concisa. Sabemos exactamente qué salió mal aquí. Todavía no tenemos el método para nuestra relación en el modelo Responder. ¡Podemos arreglar eso ahora!

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
 
class Reply extends Model
{
    public function owner()
    {
        return $this->belongsTo(User::class, 'user_id');
    }
}

Aquí agregamos la relación familiar pertenece a. Un modelo de respuesta pertenece a un propietario. También tenga en cuenta que, dado que nombramos la función owner () en lugar de user (), debemos indicar explícitamente que la identificación externa es user_id como segundo argumento en el método containsTo (). Bien, estamos listos para ejecutar nuestra prueba unitaria nuevamente. Aquí vamos:

vagrant @ homestead: ~ / Code / forumio $ phpunit tests / Unit / ReplyTest
PHPUnit 6.5.2 por Sebastian Bergmann y colaboradores.

. 1/1 (100%)

Tiempo: 643 ms, memoria: 8,00 MB

OK (1 prueba, 1 afirmación)

¡Excelente! Nuestra prueba unitaria está pasando. Observe cómo estamos ejecutando solo una prueba aquí con la sintaxis de phpunit tests / Unit / ReplyTest. Podemos hacer esto para cualquier prueba que queramos. Podemos especificar qué prueba queremos ejecutar. Esto es útil cuando realmente no necesita ejecutar todo el conjunto de pruebas que puede haber creado en la aplicación. Dado que nuestra prueba aquí ha pasado, esto significa que también debería funcionar en el navegador. Aquí visitamos un hilo específico en el navegador y vemos que las respuestas ahora tienen un propietario.
La respuesta también funciona en el navegador.

Prueba de funciones vs prueba unitaria y adición de respuestas a los subprocesos Resumen

Nuestra pequeña aplicación avanza bastante bien. Hasta ahora tenemos tres pruebas de funciones de test_a_user_can_browse_threads (), test_a_user_can_read_a_single_thread () y test_a_user_can_see_replies_that_are_associated_with_a_thread (). Además de estos, tenemos una prueba unitaria de test_it_has_an_owner () que simplemente confirma que una respuesta de hilo tiene un propietario. Ya sea que ejecutemos el conjunto completo de pruebas o cualquiera de las pruebas individualmente, todas están pasando. ¡Agradable!

Header Ads Widget

Prueba de funciones frente a prueba unitaria y adición de respuestas a los hilos

Refactorización de pruebas de características existentes

¡Aproveche la prueba!

Hacer uso de una prueba unitaria

Prueba de funciones vs prueba unitaria y adición de respuestas a los subprocesos Resumen

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget