Registrar la actividad del usuario en la base de datos

Los feeds de actividades son una característica realmente interesante que se ve en muchos sitios web diferentes. La idea es que hay una línea de tiempo, por así decirlo, de las cosas que un usuario ha hecho en la aplicación, y luego ese usuario u otros usuarios pueden ver el registro histórico de varias acciones tomadas. En esta pequeña aplicación de foro, podemos configurar una nueva actividad cuando un usuario crea un nuevo hilo. También podríamos configurar una nueva actividad para cuando un usuario crea una nueva respuesta a un hilo. El primer paso para que funcione una fuente de actividad es almacenar correctamente estas acciones en la base de datos a medida que ocurren. Usaremos eventos de modelo y una nueva clase de actividad para ayudarnos a crear esta característica.

Agregar una nueva clase ActivityTest

Continúe y cree una nueva clase de prueba llamada ActivityTest y colóquela en la carpeta Prueba unitaria. Aquí creamos el nuevo archivo y eliminamos el texto estándar de prueba.
código repetitivo de la clase de prueba

Ahora vamos a modificar el método de prueba para que sea test_it_records_activity_when_a_thread_is_created (). Lo que esta prueba va a confirmar es que cuando un usuario crea un hilo, al mismo tiempo también se generará una actividad y se insertará en la base de datos. Aquí está la primera puñalada a ese objetivo.

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
<?php
 
namespace TestsFeature;
 
use IlluminateFoundationTestingDatabaseMigrations;
use TestsTestCase;
use IlluminateFoundationTestingWithFaker;
use IlluminateFoundationTestingRefreshDatabase;
 
class ActivityTest extends TestCase
{
    use DatabaseMigrations;
 
    public function test_it_records_activity_when_a_thread_is_created()
    {
        $this->signIn();
 
        $thread = create('AppThread');
 
        $this->assertDatabaseHas('activities', [
            'type' => 'created_thread',
            'user_id' => auth()->id(),
            'subject_id' => $thread->id,
            'subject_type' => 'AppThread'
        ]);
    }
}

Ahora, para comenzar, ejecutemos la prueba. Sabemos que fallará, pero los errores nos impulsarán a dar el siguiente paso.

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_it_records_activity_when_a_thread_is_createdPHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

E 1/1 (100%)

Tiempo: 796 ms, memoria: 8,00 MB

Hubo 1 error:

1) TestsFeatureActivityTest :: test_it_records_activity_when_a_thread_is_created
IlluminateDatabaseQueryException: SQLSTATE [HY000]: Error general: 1 no existe tal tabla: actividades (SQL: seleccione el recuento (*) como agregado de "actividades" donde ("tipo" = created_thread y "user_id" = 1 y "subject_id" = 1 y "subject_type" = AppThread))

De buenas a primeras recibimos el error de que la tabla con la que estamos tratando de trabajar en la base de datos no existe. Arreglemos eso.

Crear modelo de actividad y migración

Utilizando artesano podemos hacer un modelo de Actividad y generarnos una migración al mismo tiempo.

vagrant @ homestead: ~ / Code / forumio $ php artisan make: model Activity -m
Modelo creado con éxito.
Migración creada: 2018_01_30_164752_create_activities_table

La tabla ahora está creada, por lo que el primer error debería corregirse. Ejecute la prueba de nuevo y vea qué sigue.

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_it_records_activity_when_a_thread_is_createdPHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

F 1/1 (100%)

Tiempo: 2,44 segundos, memoria: 8,00 MB

Hubo 1 falla:

1) TestsFeatureActivityTest :: test_it_records_activity_when_a_thread_is_created
No se pudo afirmar que una fila en la tabla [actividades] coincide con los atributos {
    "type": "created_thread",
    "user_id": 1,
    "subject_id": 1,
    "subject_type": "Aplicación \ Tema"
}.

La mesa está vacía.

/home/vagrant/Code/forumio/vendor/laravel/framework/src/Illuminate/Foundation/Testing/Concerns/InteractsWithDatabase.php:22
/home/vagrant/Code/forumio/tests/Unit/ActivityTest.php:24

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

Ok, la tabla ahora existe, pero no se insertan datos durante la creación de un hilo. Necesitamos desarrollar esa función ahora.

Usando Eventos de Modelo en Thread.php

Este es un caso de uso perfecto para eventos modelo. En otras palabras, configuramos oyentes para cuando se ejecuta un modelo de Thread y luego tomamos una acción cada vez que ese modelo se activa. Podemos comenzar usando los eventos del modelo dentro del modelo Thread. Agregaremos otro evento de modelo en el método boot () como hemos visto en un tutorial anterior. Este código resaltado a continuación dice que cada vez que se crea un hilo en la base de datos, también se crea inmediatamente una actividad en la base de datos.

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
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
use TestsFeatureActivityTest;
 
class Thread extends Model
{
    protected $guarded = [];
 
    protected $with = ['creator', 'channel'];
 
    protected static function boot()
    {
        parent::boot();
 
        static::addGlobalScope('replyCount', function ($builder) {
            $builder->withCount('replies');
        });
 
        static::deleting(function ($thread) {
            $thread->replies()->delete();
        });
 
        static::created(function ($thread) {
            Activity::create([
                'type' => 'created_thread',
                'user_id' => auth()->id(),
                'subject_id' => $thread->id,
                'subject_type' => 'AppThread'
            ]);
        });
    }

¡Excelente! Se ve bien, así que podemos ejecutar la prueba nuevamente y ver cómo lo estamos haciendo.

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_it_records_activity_when_a_thread_is_createdPHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

E 1/1 (100%)

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

Hubo 1 error:

1) TestsFeatureActivityTest :: test_it_records_activity_when_a_thread_is_created
IlluminateDatabaseEloquentMassAssignmentException: tipo

¡Ups! Parece que estamos recibiendo una excepción de asignación masiva. Arreglo fácil entrante. Deshabilite la asignación masiva en el modelo de actividad así:

1
2
3
4
5
6
7
8
9
10
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
 
class Activity extends Model
{
    protected $guarded = [];
}

Ejecute la prueba nuevamente y observe que todavía recibimos errores.

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_it_records_activity_when_a_thread_is_createdPHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

E 1/1 (100%)

Tiempo: 798 ms, memoria: 8,00 MB

Hubo 1 error:

1) TestsFeatureActivityTest :: test_it_records_activity_when_a_thread_is_created
IlluminateDatabaseQueryException: SQLSTATE [HY000]: Error general: 1 tabla de actividades no tiene ningún tipo de columna con nombre (SQL: insertar en "actividades" ("tipo", "user_id", "subject_id", "subject_type", "updated_at", "created_at" ) valores (created_thread, 1, 1, AppThread, 2018-01-30 17:00:35, 2018-01-30 17:00:35))

Actualizar migración de actividad

¿Qué no hemos hecho todavía? Así es, no hemos definido los campos de la tabla real en el archivo de migración. Entonces, cuando las migraciones se ejecutan durante la ejecución de una prueba, la tabla se crea pero no hay campos de ningún tipo, por lo que las cosas no van a funcionar. No hay problema, creemos ahora el archivo de migración. Necesitamos incluir campos de base de datos para user_id, subject_id, subject_type y type.

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
<?php
 
use IlluminateSupportFacadesSchema;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateDatabaseMigrationsMigration;
 
class CreateActivitiesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('activities', function (Blueprint $table) {
            $table->increments('id');
            $table->unsignedInteger('user_id')->index();
            $table->unsignedInteger('subject_id')->index();
            $table->string('subject_type', 50);
            $table->string('type');
            $table->timestamps();
        });
    }
 
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('activities');
    }
}

Con la migración ahora en su lugar y todo el trabajo realizado hasta ahora, obtenemos nuestra primera prueba de aprobación. ¡Dulce!
prueba de actividad pasando

Hilo de refactorización

En el nivel más básico, tenemos el registro de nueva actividad en la base de datos en funcionamiento. Sería bueno hacer ese código más general, de modo que no solo se puedan registrar los hilos como una actividad, sino también las respuestas como una actividad. Veamos cómo podemos abordar esto. Lo primero que notamos es que ahora mismo subject_type está codificado en 'AppThread'. ¿Qué tal si lo cambiamos por get_class ($ thread)? También podemos intercambiar created_thread por 'created_'. strtolower ((nuevo ReflectionClass ($ hilo)) -> getShortName ()). Esto usará la reflexión para observar la clase que se usa para insertar la actividad y completar la base de datos en consecuencia.

1
2
3
4
5
6
7
8
static::created(function ($thread) {
    Activity::create([
        'type' => 'created_' . strtolower((new ReflectionClass($thread))->getShortName()),
        'user_id' => auth()->id(),
        'subject_id' => $thread->id,
        'subject_type' => get_class($thread)
    ]);
});

También parece que la prueba de esta función sigue funcionando, por lo que es bueno.

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_it_records_activity_when_a_thread_is_createdPHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

. 1/1 (100%)

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

OK (1 prueba, 1 afirmación)

Extraer un método al objeto

Ahora lo que podemos hacer es extraer la lógica del evento modelo a un método protegido para que el código sea un poco más claro. Podemos agregar una función protegida llamada recordActivity () a la clase así:

1
2
3
4
5
6
7
8
9
protected function recordActivity($event)
{
    Activity::create([
        'type' => 'created_' . strtolower((new ReflectionClass($this))->getShortName()),
        'user_id' => auth()->id(),
        'subject_id' => $this->id,
        'subject_type' => get_class($this)
    ]);
}

Con eso en su lugar, el evento modelo se puede reducir a esta simple llamada.

1
2
3
static::created(function ($thread) {
    $thread->recordActivity('created');
});

Después de agregar un refactor final, ahora tenemos dos métodos protegidos y un evento modelo relacionado con la actividad de grabación. Estas secciones de código se destacan aquí.

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
use TestsFeatureActivityTest;
 
class Thread extends Model
{
    protected $guarded = [];
 
    protected $with = ['creator', 'channel'];
 
    protected static function boot()
    {
        parent::boot();
 
        static::addGlobalScope('replyCount', function ($builder) {
            $builder->withCount('replies');
        });
 
        static::deleting(function ($thread) {
            $thread->replies()->delete();
        });
 
        static::created(function ($thread) {
            $thread->recordActivity('created');
        });
    }
 
    protected function recordActivity($event)
    {
        Activity::create([
            'type' => $this->getActivityType($event),
            'user_id' => auth()->id(),
            'subject_id' => $this->id,
            'subject_type' => get_class($this)
        ]);
    }
 
    protected function getActivityType($event)
    {
        return 'created_' . strtolower((new ReflectionClass($this))->getShortName());
    }
 
    public function path()
    {
        return '/threads/' . $this->channel->slug . '/' . $this->id;
    }
 
    public function replies()
    {
        return $this->hasMany(Reply::class);
    }
 
    public function creator()
    {
        return $this->belongsTo(User::class, 'user_id');
    }
 
    public function channel()
    {
        return $this->belongsTo(Channel::class);
    }
 
    public function addReply($reply)
    {
        $this->replies()->create($reply);
    }
 
    public function scopeFilter($query, $filters)
    {
        return $filters->apply($query);
    }
}

Refactorización a un rasgo

A menudo tiene sentido mover el código reutilizable directamente a un rasgo si lo desea. Luego, puede usar ese código en cualquier clase que desee simplemente haciendo uso de una usedeclaración en la clase en particular. Veamos a qué nos referimos.

Paso 1: crear un nuevo archivo de características

crear una nueva clase de rasgo

1
2
3
4
5
6
7
8
9
<?php
 
namespace App;
 
 
trait RecordsActivity
{
 
}

Paso 2: agregue una `use`declaración al modelo de hilo

1
2
3
4
5
6
7
8
9
10
11
12
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
use TestsFeatureActivityTest;
 
class Thread extends Model
{
    use RecordsActivity;
    
    protected $guarded = [];

Paso 3: Refactorice esto: levante los miembros

refactorizar los miembros

Una vez que se completen esos tres pasos, ahora tendrá un archivo de características que contiene el código siguiente, y los dos métodos que "sacamos" ya no son parte de la clase Thread Model. Muy genial.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
 
namespace App;
 
 
trait RecordsActivity
{
    protected function recordActivity($event)
    {
        Activity::create([
            'type' => $this->getActivityType($event),
            'user_id' => auth()->id(),
            'subject_id' => $this->id,
            'subject_type' => get_class($this)
        ]);
    }
 
    protected function getActivityType($event)
    {
        return 'created_' . strtolower((new ReflectionClass($this))->getShortName());
    }
}

Solo para estar seguros de que toda esta refactorización sigue funcionando bien, podemos ejecutar la prueba nuevamente y se ve bien.

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_it_records_activity_when_a_thread_is_createdPHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

. 1/1 (100%)

Tiempo: 794 ms, memoria: 8,00 MB

OK (1 prueba, 1 afirmación)

Refactorizar un evento modelo

En este momento todavía tenemos ese evento modelo en la clase Thread. PHP Storm no puede refactorizar este siguiente fragmento de código, ya que es una especie de truco específico de Laravel. Vamos a tomar el evento modelo de la clase Thread y moverlo a una función protegida en el Trait llamado boot (). Veamos cómo. En el rasgo, podemos agregar este código aquí:

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
 
namespace App;
 
 
trait RecordsActivity
{
    protected static function bootRecordsActivity()
    {
        static::created(function ($thread) {
            $thread->recordActivity('created');
        });
    }

La convención es nombrar la función comenzando con 'boot' seguido del nombre del Trait. Entonces, boot más RecordsActivity da como resultado bootRecordsActivity () en nuestro caso. Laravel puede detectar esta convención y activar el evento del modelo de la misma forma que si se hubiera creado en el modelo original. Lo que es realmente interesante aquí es que el modelo de subprocesos ahora está de vuelta a donde estaba al principio de este tutorial. La única diferencia es que ahora tiene una línea use RecordsActivity;que básicamente activa la grabación de actividad para el modelo de hilo. ¡Resbaloso!

Prueba de actividad de refactorización

Pensaste que habíamos terminado. ¡No somos! También podemos hacer que el Rasgo sea más limpio. Aquí hay una versión más limpia del método getActivityType ().

1
2
3
4
5
protected function getActivityType($event)
{
    $type = strtolower((new ReflectionClass($this))->getShortName());
    return "{$event}_{$type}";
}

Refactor polimórfico

Ahora completaremos una refactorización para hacer uso de una relación Polimórfica Muchos. Usamos el método morphMany () para configurar esto. Al proporcionar también el prefijo de 'sujeto', Laravel puede averiguar dinámicamente el subject_id y subject_type correctos para cada actividad.

1
2
3
4
5
6
7
8
9
10
11
12
protected function recordActivity($event)
{
    $this->activity()->create([
        'type' => $this->getActivityType($event),
        'user_id' => auth()->id(),
    ]);
}
 
public function activity()
{
    return $this->morphMany('AppActivity', 'subject');
}

Clarificación adicional del caso de prueba

La adición a la prueba a continuación establece que la relación de sujeto debe ser válida. En otras palabras, si existe un Modelo de Actividad y solicita el tema de esta actividad, debe ser el hilo.

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
<?php
 
namespace TestsFeature;
 
use IlluminateFoundationTestingDatabaseMigrations;
use TestsTestCase;
use IlluminateFoundationTestingWithFaker;
use IlluminateFoundationTestingRefreshDatabase;
 
class ActivityTest extends TestCase
{
    use DatabaseMigrations;
 
    public function test_it_records_activity_when_a_thread_is_created()
    {
        $this->signIn();
 
        $thread = create('AppThread');
 
        $this->assertDatabaseHas('activities', [
            'type' => 'created_thread',
            'user_id' => auth()->id(),
            'subject_id' => $thread->id,
            'subject_type' => 'AppThread'
        ]);
 
        $activity = Activity::first();
        $this->assertEquals($activity->subject->id, $thread->id);
    }
}

Añadiendo el método morphTo ()

La prueba anterior no funcionará todavía, porque estamos tratando de usar un método de relación que aún no existe, es decir, sujeto (). Ese método debe agregarse al modelo de actividad de la siguiente manera:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
 
class Activity extends Model
{
    protected $guarded = [];
 
    public function subject()
    {
        return $this->morphTo();
    }
}

Prueba para grabar actividades de respuesta

No solo queremos que se registre una actividad si un usuario crea un hilo, sino que pasa cuando crea una respuesta. Seguramente queremos incluir respuestas como parte del feed de actividades, así que configurémoslo también.

Primero tenemos la prueba. Cuando se crea una respuesta con la fábrica de modelos, también se crea un hilo base. ¿Entonces que significa eso? Eso significa que debe haber 2 registros de actividad en la base de datos. Este marcado de prueba refleja eso.

1
2
3
4
5
6
7
8
public function test_it_records_activity_when_a_reply_is_created()
{
    $this->signIn();
 
    $reply = create('AppReply');
 
    $this->assertEquals(2, Activity::count());
}

Está bien. Entonces podemos ejecutar la prueba.

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_it_records_activity_when_a_reply_is_created
PHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

F 1/1 (100%)

Tiempo: 801 ms, memoria: 8,00 MB

Hubo 1 falla:

1) TestsFeatureActivityTest :: test_it_records_activity_when_a_reply_is_created
No se pudo afirmar que 1 coincide con lo esperado 2.

/home/vagrant/Code/forumio/tests/Unit/ActivityTest.php:38

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

Bueno, eso nos está dando un gran fracaso. En realidad, todavía no estamos generando registros de actividad para las respuestas. Oh, hombre, ¿eso significa que ahora tenemos que construir el proceso de grabación de actividades de nuevo? Bien adivina que. Dado que usó un rasgo, y dado que ese rasgo aprovecha las relaciones polimórficas, se sorprenderá de lo fácil que es comenzar a registrar actividades en las respuestas. Agregue una palabra a su modelo de respuesta y listo. Echale un vistazo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
 
class Reply extends Model
{
    use Favoriteable, RecordsActivity;
 
    protected $guarded = [];
 
    protected $with = ['owner', 'favorites'];
 
    public function owner()
    {
        return $this->belongsTo(User::class, 'user_id');
    }
}

Todo lo que hicimos aquí fue simplemente decirle al modelo que use RecordsActivity. Con ese simple cambio, ¡la prueba pasa! También agregaremos favoritos al feed de actividades con este rasgo pronto.

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_it_records_activity_when_a_reply_is_created
PHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

. 1/1 (100%)

Tiempo: 779 ms, memoria: 8,00 MB

OK (1 prueba, 1 afirmación)

Agregar un método getActivitiesToRecord ()

Para agregar la capacidad de rastrear algunos eventos pero no otros en sus modelos, podemos agregar un nuevo método para manejar esto. Una vez que el nuevo método está en su lugar, el método bootRecordsActivity () también se puede actualizar para reflejar este cambio.

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
39
40
<?php
 
namespace App;
 
 
trait RecordsActivity
{
    protected static function bootRecordsActivity()
    {
        foreach (static::getActivitiesToRecord() as $event) {
            static::$event(function ($model) use ($event) {
                $model->recordActivity($event);
            });
        }
    }
 
    protected static function getActivitiesToRecord()
    {
        return ['created'];
    }
 
    function recordActivity($event)
    {
        $this->activity()->create([
            'type' => $this->getActivityType($event),
            'user_id' => auth()->id(),
        ]);
    }
 
    public function activity()
    {
        return $this->morphMany('AppActivity', 'subject');
    }
 
    protected function getActivityType($event)
    {
        $type = strtolower((new ReflectionClass($this))->getShortName());
        return "{$event}_{$type}";
    }
}

Terminando ejecutando todas las pruebas.

Parece que ahora tenemos un problema al ejecutar todas las pruebas.

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

..... E ........ EEEEEEE..E.EEEEEE 31/31 (100%)

Tiempo: 3,69 segundos, memoria: 14,00 MB

Hubo 15 errores:

Quince errores. Ay. En el rasgo RecordsActivity, solo estamos registrando actividades sin tener en cuenta si un usuario está conectado o no. Bueno, la única vez que se debe registrar una actividad es si un usuario está conectado. Entonces podemos actualizar ese rasgo así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
 
namespace App;
 
 
trait RecordsActivity
{
    protected static function bootRecordsActivity()
    {
        if(auth()->guest()) return;
        
        foreach (static::getActivitiesToRecord() as $event) {
            static::$event(function ($model) use ($event) {
                $model->recordActivity($event);
            });
        }
    }

Ahora todas las pruebas pasan.

Eliminar actividades relacionadas

Lo último que debemos cubrir es si un usuario elimina un hilo, ¿eso también elimina alguna actividad asociada? En este momento eso no sucede, pero agregaremos código para asegurarnos de que esto funcione. Primero vamos a actualizar la prueba test_authorized_users_can_delete_threads () en la clase CreateThreadsTest.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public function test_authorized_users_can_delete_threads()
{
    $this->withoutExceptionHandling()->signIn();
 
    $thread = create('AppThread', ['user_id' => auth()->id()]);
    $reply = create('AppReply', ['thread_id' => $thread->id]);
 
    $response = $this->json('DELETE', $thread->path());
 
    $response->assertStatus(204);
 
    $this->assertDatabaseMissing('threads', ['id' => $thread->id]);
    $this->assertDatabaseMissing('replies', ['id' => $reply->id]);
    $this->assertDatabaseMissing('activities', [
        'subject_id' => $thread->id,
        'subject_type' => get_class($thread)
    ]);
}

Ejecuta la prueba ahora que la hemos modificado:

vagrant @ homestead: ~ / Code / forumio $ phpunit --filter test_authorized_users_can_delete_threads
PHPUnit 6.5.5 por Sebastian Bergmann y colaboradores.

F 1/1 (100%)

Tiempo: 887 ms, memoria: 10,00 MB

Hubo 1 falla:

1) TestsFeatureCreateThreadsTest :: test_authorized_users_can_delete_threads
No se pudo afirmar que una fila de la tabla [actividades] no coincide con los atributos {
    "subject_id": 1,
    "subject_type": "Aplicación \ Tema"
}.

Encontró: [
    {
        "id": "1",
        "user_id": "1",
        "subject_id": "1",
        "subject_type": "Aplicación \ Tema",
        "type": "created_thread",
        "created_at": "2018-01-30 21:15:04",
        "updated_at": "2018-01-30 21:15:04"
    },
    {
        "id": "2",
        "user_id": "1",
        "subject_id": "1",
        "subject_type": "Aplicación \ Responder",
        "type": "created_reply",
        "created_at": "2018-01-30 21:15:04",
        "updated_at": "2018-01-30 21:15:04"
    }
].

/home/vagrant/Code/forumio/vendor/laravel/framework/src/Illuminate/Foundation/Testing/Concerns/InteractsWithDatabase.php:42
/home/vagrant/Code/forumio/tests/Feature/CreateThreadsTest.php:80

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

¡Hagámoslo pasar!

Agregar un detector de eventos de eliminación en RecordsActivity

Lo primero que haremos es configurar un nuevo detector de eventos en el rasgo RecordsActivity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
 
namespace App;
 
 
trait RecordsActivity
{
    protected static function bootRecordsActivity()
    {
        if (auth()->guest()) return;
 
        foreach (static::getActivitiesToRecord() as $event) {
            static::$event(function ($model) use ($event) {
                $model->recordActivity($event);
            });
        }
 
        static::deleting(function ($model) {
            $model->activity()->delete();
        });
    }

Actualizar el detector de eventos de eliminación en el modelo de subproceso

Lo anterior se encarga de asegurarse de que se elimine una actividad para un hilo. Ahora también debemos asegurarnos de que la actividad para una respuesta también se elimine. Podemos usar mensajes de orden superior en Laravel Collections para ayudar.

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
<?php
 
namespace App;
 
use IlluminateDatabaseEloquentModel;
use TestsFeatureActivityTest;
 
class Thread extends Model
{
    use RecordsActivity;
 
    protected $guarded = [];
 
    protected $with = ['creator', 'channel'];
 
    protected static function boot()
    {
        parent::boot();
 
        static::addGlobalScope('replyCount', function ($builder) {
            $builder->withCount('replies');
        });
 
        static::deleting(function ($thread) {
            $thread->replies->each->delete();
        });
    }

Y ahora, podemos ejecutar todas las pruebas en la suite y estar orgullosos de que todo funcione.

Registrar la actividad del usuario en el resumen de la base de datos

Gran trabajo si lo hizo hasta el final de este tutorial. Cubrimos un montón de funciones que puede usar al configurar el lado del backend de una función de alimentación de actividades para su aplicación. Pudimos ver cómo se podría usar un rasgo junto con eventos de modelo para rastrear la actividad del usuario en la base de datos para su uso posterior.

Header Ads Widget

Registrar la actividad del usuario en la base de datos

Agregar una nueva clase ActivityTest

Crear modelo de actividad y migración

Usando Eventos de Modelo en Thread.php

Actualizar migración de actividad

Hilo de refactorización

Extraer un método al objeto

Refactorización a un rasgo

Paso 1: crear un nuevo archivo de características

Paso 2: agregue una `use`declaración al modelo de hilo

Paso 3: Refactorice esto: levante los miembros

Refactorizar un evento modelo

Prueba de actividad de refactorización

Refactor polimórfico

Clarificación adicional del caso de prueba

Añadiendo el método morphTo ()

Prueba para grabar actividades de respuesta

Agregar un método getActivitiesToRecord ()

Terminando ejecutando todas las pruebas.

Eliminar actividades relacionadas

Agregar un detector de eventos de eliminación en RecordsActivity

Actualizar el detector de eventos de eliminación en el modelo de subproceso

Registrar la actividad del usuario en el resumen de la base de datos

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget

Header Ads Widget

Registrar la actividad del usuario en la base de datos

Agregar una nueva clase ActivityTest

Crear modelo de actividad y migración

Usando Eventos de Modelo en Thread.php

Actualizar migración de actividad

Hilo de refactorización

Extraer un método al objeto

Refactorización a un rasgo

Paso 1: crear un nuevo archivo de características

Paso 2: agregue una usedeclaración al modelo de hilo

Paso 3: Refactorice esto: levante los miembros

Refactorizar un evento modelo

Prueba de actividad de refactorización

Refactor polimórfico

Clarificación adicional del caso de prueba

Añadiendo el método morphTo ()

Prueba para grabar actividades de respuesta

Agregar un método getActivitiesToRecord ()

Terminando ejecutando todas las pruebas.

Eliminar actividades relacionadas

Agregar un detector de eventos de eliminación en RecordsActivity

Actualizar el detector de eventos de eliminación en el modelo de subproceso

Registrar la actividad del usuario en el resumen de la base de datos

Publicar un comentario

0 Comentarios

Random Posts

Información relevante

Colaboraciones

Menu Footer Widget

Paso 2: agregue una `use`declaración al modelo de hilo