Tests\Unit\Services\Messengers\Clients\Base\BaseClientTest

Complexity

Total Complexity

3

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	hp$0 ➔ publicGetMessageFormatter()	0	3	1
	testMessageFormatterIsReturnedCorrectly()	0	21	?
A	hp$0 ➔ __construct()	0	3	1
	testNotifableEntityIsReturnedCorrectly()	0	21	?
A	hp$0 ➔ testMessageFormatterIsReturnedCorrectly()	0	21	1
A	hp$2 ➔ publicGetNotification()	0	3	1
A	hp$1 ➔ testNotifableEntityIsReturnedCorrectly()	0	21	1
	testNotificationIsReturnedCorrectly()	0	21	?
A	hp$1 ➔ __construct()	0	3	1
A	hp$1 ➔ publicGetNotifableEntity()	0	3	1
A	hp$2 ➔ __construct()	0	3	1
A	hp$2 ➔ testNotificationIsReturnedCorrectly()	0	21	1

<?php

namespace Tests\Unit\Services\Messengers\Clients\Base;

use Illuminate\Notifications\Notification;
use PHPUnit\Framework\TestCase;
use Skater4\LaravelSentryNotifications\Notifications\Factories\NotificationEntityFactory;
use Skater4\LaravelSentryNotifications\Notifications\Factories\NotificationFactory;
use Skater4\LaravelSentryNotifications\Notifications\Interfaces\NotifableEntityInterface;
use Skater4\LaravelSentryNotifications\Services\Messengers\Clients\Base\BaseClient;
use Skater4\LaravelSentryNotifications\Services\Messengers\Factories\MessageFormatterFactory;
use Skater4\LaravelSentryNotifications\Services\Messengers\Interfaces\MessageFormatterInterface;

class BaseClientTest extends TestCase
{
    /**
     * @return void
     */
    public function testMessageFormatterIsReturnedCorrectly()
    {
        $formatterFactoryMock = $this->createMock(MessageFormatterFactory::class);

        $formatterMock = $this->createMock(MessageFormatterInterface::class);

        $formatterFactoryMock->method('create')->willReturn($formatterMock);

        $client = new class($formatterFactoryMock) extends BaseClient {
            public function __construct($messageFormatterFactory)
            {
                $this->messageFormatter = $messageFormatterFactory->create();
            }

            public function publicGetMessageFormatter(): MessageFormatterInterface
            {
                return $this->getMessageFormatter();
            }
        };

        $this->assertInstanceOf(MessageFormatterInterface::class, $client->publicGetMessageFormatter());
    }

    /**
     * @return void
     */
    public function testNotifableEntityIsReturnedCorrectly()
    {
        $notifableEntityFactoryMock = $this->createMock(NotificationEntityFactory::class);

        $notifableEntityMock = $this->createMock(NotifableEntityInterface::class);

        $notifableEntityFactoryMock->method('create')->willReturn($notifableEntityMock);

        $client = new class($notifableEntityFactoryMock) extends BaseClient {
            public function __construct($notifableEntityFactory)
            {
                $this->notifableEntity = $notifableEntityFactory->create();
            }

            public function publicGetNotifableEntity(): NotifableEntityInterface
            {
                return $this->getNotifableEntity();
            }
        };

        $this->assertInstanceOf(NotifableEntityInterface::class, $client->publicGetNotifableEntity());
    }

    /**
     * @return void
     */
    public function testNotificationIsReturnedCorrectly()
    {
        $notificationFactoryMock = $this->createMock(NotificationFactory::class);

        $notificationMock = $this->createMock(Notification::class);

        $notificationFactoryMock->method('create')->willReturn($notificationMock);

        $client = new class($notificationFactoryMock) extends BaseClient {
            public function __construct($notificationFactory)
            {
                $this->notificationClass = $notificationFactory->create();
            }

            public function publicGetNotification(): Notification
            {
                return $this->getNotificationClass();
            }
        };

        $this->assertInstanceOf(Notification::class, $client->publicGetNotification());
    }
}