---
title: "Testovanie — Comments for Laravel | Roundly"
description: "Comments::fake() zaznamená každú zmenu a pritom ju vykoná, s aserciou pre každé sloveso — plus factory bez nastavovania a AssertsComments."
url: https://roundly-consulting.com/sk/open-source/navody/comments-for-laravel/testovanie
language: sk
---

[Všetky balíky](https://roundly-consulting.com/sk/open-source.md)

[Comments for Laravel](https://roundly-consulting.com/sk/open-source/navody/comments-for-laravel.md)

# Testovanie

Comments::fake() nasadí zaznamenávajúci CommentsFake — za fasádu aj do kontajnera, takže ho dostanú aj vložené CommentsManager. Každú operáciu stále vykoná — záznamy sa zapíšu, policy a zámky platia, udalosti sa odošlú — a zaznamená každú úspešnú zmenu bez ohľadu na to, odkiaľ prišla: z fasády, vloženého manažéra, buildera, hromadného moderovania v query, $user->writeComment() či $comment->lockReplies():

```php
use RoundlyConsulting\Comments\Facades\Comments;
use RoundlyConsulting\Comments\Models\Comment;

$fake = Comments::fake();

// ... run the code under test ...

$fake->assertPosted(fn (Comment $comment) => $comment->comment === 'Hi');
$fake->assertApproved($comment);
$fake->assertLocked($post);
$fake->assertThreadLocked();
$fake->assertNothingDeleted();
```

## Všetky asercie

Každá asercia prijme voliteľný model (porovnaný cez is()) alebo callback, ktorý pri zhode vráti true; bez argumentu prejde akékoľvek zaznamenané volanie. Po nasadení fake ich môžete volať aj staticky, napr. Comments::assertPosted():

| Zaznamená ho | Asercia | Asercia „nič“ |
| --- | --- | --- |
| `on()->post(), write(), writeComment()` | `assertPosted()` | `assertNothingPosted()` |
| `update()` | `assertUpdated()` | `assertNothingUpdated()` |
| `delete(), deleteAll()` | `assertDeleted()` | `assertNothingDeleted()` |
| `restore()` | `assertRestored()` | `assertNothingRestored()` |
| `approve(), approveAll()` | `assertApproved()` | `assertNothingApproved()` |
| `hide(), hideAll()` | `assertHidden()` | `assertNothingHidden()` |
| `lock($subject)` | `assertLocked()` | `assertNothingLocked()` |
| `unlock($subject)` | `assertUnlocked()` | `assertNothingUnlocked()` |
| `lockThread(), lockReplies()` | `assertThreadLocked()` | `assertNothingThreadLocked()` |
| `unlockThread(), unlockReplies()` | `assertThreadUnlocked()` | `assertNothingThreadUnlocked()` |
| `transfer($from, $to)` | `assertTransferred()` | `assertNothingTransferred()` |

```php
$fake = Comments::fake();

$user->writeComment($post, 'Hi');                  // recorded by the trait path too
Comments::update($comment, 'Edited');
Comments::for($post)->pending()->approveAll();     // one record per approved row
Comments::hide($spam);
Comments::delete($old);
Comments::restore($old);
Comments::lock($post);
Comments::unlock($post);
$comment->lockReplies();
$comment->unlockReplies();
Comments::transfer($duplicate, $original);

$fake->assertPosted(fn (Comment $c) => $c->comment === 'Hi');
$fake->assertUpdated($comment);
$fake->assertApproved();                           // any approval at all
$fake->assertHidden($spam);
$fake->assertDeleted($old);
$fake->assertRestored($old);
$fake->assertLocked($post);
$fake->assertUnlocked(fn ($subject) => $subject->is($post));
$fake->assertThreadLocked($comment);
$fake->assertThreadUnlocked($comment);
$fake->assertTransferred($duplicate, $original);

// In a test where nothing should change:
$fake->assertNothingPosted();
$fake->assertNothingUpdated();
$fake->assertNothingDeleted();
$fake->assertNothingRestored();
$fake->assertNothingApproved();
$fake->assertNothingHidden();
$fake->assertNothingLocked();
$fake->assertNothingUnlocked();
$fake->assertNothingThreadLocked();
$fake->assertNothingThreadUnlocked();
$fake->assertNothingTransferred();
```

Volanie, ktoré vyhodí výnimku, nezaznamená nič, a čítania — isLocked(), isThreadLocked(), blocklisted() a dotazy — sa nezaznamenávajú. Listener automatického skrytia moderuje v mene systému bez používateľa, preto manažér obchádza a nezaznamenáva sa — CommentHidden overte cez Event::fake().

## Asercie presunov

assertTransferred() porovná zdroj s prvým argumentom a, ak ho zadáte, cieľ s druhým — assertTransferred(to: $original) overí len cieľ. Callback dostane zdroj, cieľ a počet:

```php
use Illuminate\Database\Eloquent\Model;
use RoundlyConsulting\Comments\Facades\Comments;

$fake = Comments::fake();

Comments::transfer($duplicate, $original);

$fake->assertTransferred();                      // any transfer
$fake->assertTransferred($duplicate);            // from $duplicate, onto anything
$fake->assertTransferred($duplicate, $original); // from $duplicate onto $original
$fake->assertTransferred(to: $original);         // onto $original, from anything
$fake->assertTransferred(fn (Model $from, Model $to, int $count) => $count === 4);
```

## Factory

Balík obsahuje Comment::factory(), CommentMention::factory() a CommentLock::factory(), pričom Comment::factory() vytvára váš nastavený comments.model. Jej stavy pokrývajú každý typ komentára — on($subject), reply($parent), by($author), pending(), hidden(), locked() a meta($meta). Subjekt komentáru určíte cez on($subject), reply($parent) — ktorý prevezme subjekt rodiča — alebo for($subject, 'commentable') z Eloquentu:

```php
use RoundlyConsulting\Comments\Models\Comment;
use RoundlyConsulting\Comments\Models\CommentLock;
use RoundlyConsulting\Comments\Models\CommentMention;

$root = Comment::factory()->on($post)->create();

Comment::factory()->on($post)->pending()->create();
Comment::factory()->on($post)->hidden()->create();
Comment::factory()->on($post)->locked()->create();
Comment::factory()->on($post)->meta(['tickets' => ['internal' => true]])->create();
Comment::factory()->reply($root)->by($user)->create(); // inherits the root's subject
Comment::factory()->for($post, 'commentable')->create(); // the plain Eloquent form works too

Comment::factory()->create(); // no subject: written on a new user of your auth model

CommentMention::factory()->create(['comment_id' => Comment::factory()->on($post)]);
CommentLock::factory()->on($post)->create(); // Comments::isLocked($post) === true
```

Funguje aj komentár bez subjektu — holé Comment::factory()->create() aj komentár, ktorý CommentMention::factory()->create() vytvorí pre svoj comment\_id. Zapíše sa na nového používateľa vášho auth modelu (auth.providers.<provider>.model predvoleného guardu), vytvoreného cez vlastnú factory tohto modelu, takže bežná aplikácia s App\\Models\\User a jeho UserFactory nič nastavovať nemusí. Každý komentár dostane vlastného používateľa, pokiaľ jedného neodovzdáte cez recycle($user), a ako pri každej rodičovskej factory sa používateľ vytvorí aj pri make().

Ak predvolený guard nemá Eloquent model používateľa, tento model nemá factory alebo ho vynucovaná morph mapa vynecháva, factory vyhodí LogicException, ktorá vás odkáže na on($subject). Testbench sada je v takej situácii predvolene — jej auth model, Illuminate\\Foundation\\Auth\\User, factory nemá —, preto v auth.providers.users.model nastavte vlastný model používateľa alebo každému komentáru určte subjekt. CommentLock::factory() funguje rovnako: subjekt zamknete cez on($subject) alebo for($subject, 'lockable'); holý zámok sa umiestni na nového používateľa vášho auth modelu.

## Databázové asercie

V testovacej triede použite trait AssertsComments pre čitateľné očakávania:

```php
namespace Tests\Feature;

use App\Models\Post;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use RoundlyConsulting\Comments\Facades\Comments;
use RoundlyConsulting\Comments\Testing\AssertsComments;
use Tests\TestCase;

final class PostCommentsTest extends TestCase
{
    use AssertsComments;
    use RefreshDatabase;

    public function test_a_user_can_comment_on_a_post(): void
    {
        $post = Post::factory()->create();
        $user = User::factory()->create();

        Comments::on($post)->as($user)->body('expected body')->post();

        $this->assertCommented($post);
        $this->assertCommented($post, 'expected body');
        $this->assertCommentCount($post, 1);
    }

    public function test_a_new_post_has_no_comments(): void
    {
        $this->assertNotCommented(Post::factory()->create());
    }
}
```

Asercie počítajú každý nezmazaný komentár na subjekte bez ohľadu na jeho stav či hĺbku a dopytujú sa cez váš nastavený comments.model — vidia teda jeho tabuľku, pripojenie aj globálne scopy.

## Fake udalosti

```php
use Illuminate\Support\Facades\Event;
use RoundlyConsulting\Comments\Events\CommentApproved;
use RoundlyConsulting\Comments\Events\CommentCreated;
use RoundlyConsulting\Comments\Facades\Comments;

Event::fake([CommentCreated::class, CommentApproved::class]);

$comment = Comments::on($post)->as($user)->body('Hello')->post();
Comments::approve($comment);

Event::assertDispatched(CommentCreated::class, fn ($e) => $e->comment->is($comment));
Event::assertDispatched(CommentApproved::class);
```

Testy spúšťajte s publikovanými migráciami balíka — aj Likes, Reports, Approvals a Media Library — napríklad cez RefreshDatabase.

## Prejavte lásku k open source

Tento balík je zadarmo pod licenciou MIT. Ak vám šetrí čas, jednorazový príspevok alebo členstvo na Patreone nám pomôže ho ďalej udržiavať, testovať a dokumentovať.

[Ďalšie spôsoby podpory vrátane kryptomien](https://roundly-consulting.com/sk/podporte-nas.md)

Odoslaním daru súhlasíte s našimi [podmienkami prijímania darov](https://roundly-consulting.com/sk/podmienky-darov.md).

[Podporte našu open-source prácu (otvorí sa v novej karte)](https://donate.stripe.com/dRmeVe8FX5PF1Qd9pXcEw00) [Pridajte sa k nám na Patreone (otvorí sa v novej karte)](https://www.patreon.com/cw/roundly)

## Chcete to zabudovať do svojho produktu?

Naše balíky integrujeme do zákazkových Laravel a AI riešení. Napíšte nám, na čom pracujete, a ozveme sa do 48 hodín.

[Ponuka do 48 hodín](https://roundly-consulting.com/sk/kontakt.md) [Prezrieť všetky balíky](https://roundly-consulting.com/sk/open-source/navody/comments-for-laravel.md)