App\Tests\Modules\Comments\Integration\CommentsIT

Complexity

Total Complexity

7

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	createAndUpdatePost()	0	15	1
A	getCommentsApi()	0	3	1
A	deletePost()	0	7	1
A	shouldBaselineCommentsForPost()	0	30	1
A	shouldRenameUserForPost()	0	17	1
A	shouldCreateFetchAndDeleteCommentsForPost()	0	73	1
A	setupKernel()	0	9	1

<?php

namespace App\Tests\Modules\Comments\Integration;

use App\Modules\Comments\Api\Command\BaselineCommentsCommand;
use App\Modules\Comments\Api\Command\CreateCommentCommand;
use App\Modules\Comments\Api\CommentsApiInterface;
use App\Modules\Comments\Api\Event\Inbound\PostCreatedCommentsIEvent;
use App\Modules\Comments\Api\Event\Inbound\PostDeletedCommentsIEvent;
use App\Modules\Comments\Api\Event\Inbound\PostUpdatedCommentsIEvent;
use App\Modules\Comments\Api\Event\Inbound\UserRenamedCommentsIEvent;
use App\Modules\Comments\Api\Query\FindCommentsByPostIdQuery;
use App\Modules\Comments\Api\Query\FindCommentsPostHeadersQuery;
use App\Modules\Comments\Api\Query\FindLatestCommentsQuery;
use App\Modules\Comments\Api\Query\Response\FindLatestCommentsQueryResponse;
use App\Modules\Comments\Domain\Event\Outbound\CommentsBaselinedOEvent;
use App\Tests\Modules\Comments\Integration\Http\CommentsHttpTrait;
use App\Tests\TestUtils\Contracts\ApplicationEventContractLoader;
use App\Tests\TestUtils\Events\InMemoryEventPublisher;
use App\Tests\TestUtils\IntegrationTest;
use Symfony\Bundle\FrameworkBundle\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;
use Symfony\Component\Uid\Ulid;

class CommentsIT extends IntegrationTest
{
    use CommentsHttpTrait;
    use ApplicationEventContractLoader;

    /**
     * @test
     */
    public function shouldCreateFetchAndDeleteCommentsForPost()
    {
        //given: there was a Post Created
        $postId = $this->createAndUpdatePost();

        //and: someone authored a Comment for that Post
        $command = new CreateCommentCommand($postId, 'Parent Author', 'Parent Body', null);

        //and: comment is Created
        $parentCommentId = $this->createComment($command)->getId();

        //and: someone authored a Child Comment for that Post and Parent Comment
        $command = new CreateCommentCommand($postId, 'Author', 'Body', $parentCommentId);

        //and: Child Comment is Created
        $commentId = $this->createComment($command)->getId();

        //when: list of Comments for that Post is fetched
        $comments = $this->findCommentsForPost(new FindCommentsByPostIdQuery($postId));

        //then: the Post Comments are fetched correctly
        self::assertNotNull($comments);
        self::assertCount(2, $comments);
        self::assertTrue(isset($comments[0]));
        self::assertTrue(isset($comments[1]));

        self::assertEquals($parentCommentId, $comments[0]->getId());
        self::assertEquals('Parent Author', $comments[0]->getAuthor());
        self::assertEquals('Parent Body', $comments[0]->getBody());
        self::assertNotNull($comments[0]->getCreatedAt());
        self::assertNull($comments[0]->getParentId());

        self::assertEquals($commentId, $comments[1]->getId());
        self::assertEquals('Author', $comments[1]->getAuthor());
        self::assertEquals('Body', $comments[1]->getBody());
        self::assertNotNull($comments[1]->getCreatedAt());
        self::assertEquals($parentCommentId, $comments[1]->getParentId());

        //when: list of Comments for that Post is fetched
        $comments = $this->findLatestComments(new FindLatestCommentsQuery(1));

        //then: the Post Comments are fetched correctly
        self::assertNotNull($comments);
        self::assertCount(2, $comments->getData());
        self::assertEquals(2, $comments->getCount());
        self::assertTrue(isset($comments->getData()[0]));
        self::assertTrue(isset($comments->getData()[1]));

        $parentComment = $this->convert($comments->getData()[0], FindLatestCommentsQueryResponse::class);
        $comment = $this->convert($comments->getData()[1], FindLatestCommentsQueryResponse::class);

        self::assertEquals($parentCommentId, $parentComment->getId());
        self::assertEquals('Parent Author', $parentComment->getAuthor());
        self::assertEquals('Parent Body', $parentComment->getBody());
        self::assertNotNull($parentComment->getCreatedAt());
        self::assertNull($parentComment->getParentId());

        self::assertEquals($commentId, $comment->getId());
        self::assertEquals('Author', $comment->getAuthor());
        self::assertEquals('Body', $comment->getBody());
        self::assertNotNull($comment->getCreatedAt());
        self::assertEquals($parentCommentId, $comment->getParentId());

        //when: the Post was Deleted
        $this->deletePost($postId);

        //and: the list of Comments was fetched
        $comments = $this->findLatestComments(new FindLatestCommentsQuery(1));

        //then: there were no Comments left
        self::assertNotNull($comments);
        self::assertCount(0, $comments->getData());
        self::assertEquals(0, $comments->getCount());
    }

    /**
     * @test
     */
    public function shouldBaselineCommentsForPost()
    {
        //given: there was a Post Created
        $postId = $this->createAndUpdatePost();

        //and: someone authored a Comment for that Post
        $command = new CreateCommentCommand($postId, 'Parent Author', 'Parent Body', null);

        //and: comment is Created
        $parentCommentId = $this->createComment($command)->getId();

        //and: someone authored a Child Comment for that Post and Parent Comment
        $command = new CreateCommentCommand($postId, 'Author', 'Body', $parentCommentId);

        //and: Child Comment is Created
        $this->createComment($command)->getId();

        //when: Comments are baselined
        $application = $this->setupKernel();
        $command = $application->find('app:comments:baseline');
        $commandTester = new CommandTester($command);
        $commandTester->execute([]);
        $output = $commandTester->getDisplay();

        //then: Comments were baselined correctly
        self::assertStringStartsWith('Successfully base-lined all Comments', $output);
        $events = InMemoryEventPublisher::get(CommentsBaselinedOEvent::class);
        self::assertCount(1, $events);
        self::assertEquals($postId, $events[0]->getData()['postId']);
        self::assertCount(2, json_decode($events[0]->getData()['comments']));
    }

    /**
     * @test
     */
    public function shouldRenameUserForPost()
    {
        //given: there was a Post Created
        $postId = $this->createAndUpdatePost();

The assignment to $postId is dead and can be removed.

        //and: the Header was to be updated
        $event = new UserRenamedCommentsIEvent($this->getInboundEvent("Comments/UserRenamedCommentsIEvent"));

        //when: the Event was published
        $this->getCommentsApi()->onUserRenamed($event);

        //then: Post Header was created - no Exception was thrown
        $headers = $this->getCommentsApi()->findPostHeaders(new FindCommentsPostHeadersQuery());
        self::assertNotNull($headers);
        self::assertCount(1, $headers);
        self::assertTrue(isset($headers[0]));
        self::assertEquals($event->getNewLogin(), $headers[0]->getCreatedByName());
    }

    private function createAndUpdatePost(): Ulid
    {
        //given: there was a PostCreatedIEvent to be published
        $event = new PostCreatedCommentsIEvent($this->getInboundEvent("Comments/PostCreatedCommentsIEvent"));

        //and: the Event was already published
        $this->getCommentsApi()->onPostCreated($event);

        //and: the Header was to be updated
        $event = new PostUpdatedCommentsIEvent($this->getInboundEvent("Comments/PostUpdatedCommentsIEvent"));

        //and: the Event was published
        $this->getCommentsApi()->onPostUpdated($event);

        return $event->getId();
    }

    private function deletePost(Ulid $postId): void

The parameter $postId is not used and could be removed.

    {
        //and: the Header was to be updated
        $event = new PostDeletedCommentsIEvent($this->getInboundEvent("Comments/PostDeletedCommentsIEvent"));

        //and: the Event was published
        $this->getCommentsApi()->onPostDeleted($event);
    }

    private function getCommentsApi(): CommentsApiInterface
    {
        return $this->getContainer()->get(CommentsApiInterface::class);

The expression return $this->getContainer()->get(App\Modules\Comments\Api\CommentsApiInterface::class) could return the type null which is incompatible with the type-hinted return App\Modules\Comments\Api\CommentsApiInterface. Consider adding an additional type-check to rule them out.

    }

    /**
     * @return Application
     */
    protected function setupKernel(): Application
    {
        $kernel = static::createKernel();
        $kernel->boot();
        $application = new Application($kernel);
        $application->add(new BaselineCommentsCommand(
            $this->getContainer()->get(CommentsApiInterface::class)

It seems like $this->getContainer()->get(App\Modules\Comments\Api\CommentsApiInterface::class) can also be of type null; however, parameter $commentsApi of App\Modules\Comments\Api\Command\BaselineCommentsCommand::__construct() does only seem to accept App\Modules\Comments\Api\CommentsApiInterface, maybe add an additional type check?

        ));
        return $application;
    }
}