Test\EventTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	testIncorrectEventObjectFromNoneExistingClass()	0	11	1
A	clearLog()	0	6	2
A	testCreateEventInstanceFromIncorrectObject()	0	11	1
A	createLogObject()	0	9	1
B	testCallEvent()	0	33	1
B	testCallEventWithLog()	0	28	1
B	testCreateEventObject()	0	24	1
A	testIncorrectEventObject()	0	11	1

<?php

namespace Test;

use PHPUnit\Framework\TestCase;
use BlueEvent\Event\Base\EventDispatcher;
use BlueRegister\Events\Event;
use BlueRegister\Events\RegisterEvent;
use BlueRegister\Log;
use SimpleLog\Log as SimpleLog;

class EventTest extends TestCase
{
    /**
     * name of test event log file
     */
    const REGISTER_LOG_NAME = '/debug.log';

    /**
     * @expectedException \LogicException
     */
    public function testIncorrectEventObject()
    {
        $logPath = __DIR__ . '/log';
        $this->clearLog($logPath);

        new Event(
            [
                'event_object' => TestClass\SimpleClass::class,
                'event_config' => [],
            ],
            $this->createLogObject()
        );
    }

    /**
     * @expectedException \LogicException
     * @expectedExceptionMessage Class don't exists: SomeClass
     */
    public function testIncorrectEventObjectFromNoneExistingClass()
    {
        $logPath = __DIR__ . '/log';
        $this->clearLog($logPath);

        new Event(
            [
                'event_object' => 'SomeClass',
                'event_config' => [],
            ],
            $this->createLogObject()
        );
    }

    /**
     * @expectedException \LogicException
     * @expectedExceptionMessage Cannot create Event instance: Test\TestClass\SimpleClass
     */
    public function testCreateEventInstanceFromIncorrectObject()
    {
        $logPath = __DIR__ . '/log';
        $this->clearLog($logPath);

        new Event(
            [
                'event_object' => new \Test\TestClass\SimpleClass,
                'event_config' => [],
            ],
            $this->createLogObject()
        );
    }

    public function testCreateEventObject()
    {
        $logPath = __DIR__ . '/log';
        $this->clearLog($logPath);
        $log = $this->createLogObject();

        $event1 = new Event(
            [
                'event_object' => new EventDispatcher(),
                'event_config' => [],
            ],
            $log
        );
        $event2 = new Event(
            [
                'event_object' => EventDispatcher::class,
                'event_config' => [],
            ],
            $log
        );

        $this->assertInstanceOf(Event::class, $event1);
        $this->assertInstanceOf(Event::class, $event2);
        $this->clearLog($logPath);
    }

    public function testCallEvent()
    {
        $logPath = __DIR__ . '/log';
        $testData = [];
        $eventConfig = [
            'register_before_create' => [
                'object' => RegisterEvent::class,
                'listeners' => [
                    function ($event) use (&$testData) {
                        /** @var $event \BlueRegister\Events\RegisterEvent */
                        $testData['register_before_create'] = $event->getEventParameters();
                    }
                ]
            ]
        ];

        $log = $this->createLogObject();

        $event = new Event(
            [
                'event_object' => new EventDispatcher(['events' => $eventConfig]),
                'event_config' => [],
            ],
            $log
        );

        $this->assertEmpty($testData);
        $event->callEvent('register_before_create', []);

        $this->assertNotEmpty($testData);
        $this->assertInstanceOf(EventDispatcher::class, $testData['register_before_create'][0]['event_object']);

        $this->clearLog($logPath);
    }

    public function testCallEventWithLog()
    {
        $logPath = __DIR__ . '/log';
        $eventConfig = [
            'register_before_create' => [
                'object' => RegisterEvent::class,
                'listeners' => []
            ]
        ];

        $this->clearLog($logPath);

        $log = $this->createLogObject();

        $event = new Event(
            [
                'event_object' => new EventDispatcher(['events' => $eventConfig]),
                'event_config' => [],
            ],
            $log
        );

        $this->assertFileNotExists($logPath . self::REGISTER_LOG_NAME);

        $event->callEvent('register_before_create', []);

        $this->assertFileExists($logPath . self::REGISTER_LOG_NAME);
        $this->clearLog($logPath);
    }

    protected function clearLog($logPath)
    {
        $logFile = $logPath . self::REGISTER_LOG_NAME;

        if (file_exists($logFile)) {
            unlink($logFile);
        }
    }

    /**
     * @return Log
     */
    protected function createLogObject()
    {
        $logPath = __DIR__ . '/log';

        $simpleLog = new SimpleLog;
        $simpleLog->setOption('log_path', $logPath)
            ->setOption('level', 'debug');

        return new Log($simpleLog);
    }
}