Spiral\Tests\Monolog\HandlersTest::setUp()

Size

Total Lines	18
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	HandlersTest.php$0 ➔ has()	0	3	1
A	HandlersTest.php$0 ➔ load()	0	3	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Tests\Monolog;

use Monolog\Handler\NullHandler;
use Monolog\Logger;
use PHPUnit\Framework\TestCase;
use Spiral\Boot\BootloadManager;
use Spiral\Config\ConfigManager;
use Spiral\Config\ConfiguratorInterface;
use Spiral\Config\LoaderInterface;
use Spiral\Core\Container;
use Spiral\Logger\ListenerRegistry;
use Spiral\Logger\ListenerRegistryInterface;
use Spiral\Logger\LogsInterface;
use Spiral\Monolog\Bootloader\MonologBootloader;
use Spiral\Monolog\Config\MonologConfig;
use Spiral\Monolog\Exception\ConfigException;

class HandlersTest extends TestCase
{
    /** @var Container */
    private $container;

    public function setUp(): void
    {
        $this->container = new Container();
        $this->container->bind(ConfiguratorInterface::class, new ConfigManager(

new Spiral\Config\ConfigManager(new ClassNode()) of type Spiral\Config\ConfigManager is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

            new class() implements LoaderInterface {
                public function has(string $section): bool
                {
                    return false;
                }

                public function load(string $section): array
                {
                    return [];
                }
            }
        ));
        $this->container->bindSingleton(ListenerRegistryInterface::class, new ListenerRegistry());

new Spiral\Logger\ListenerRegistry() of type Spiral\Logger\ListenerRegistry is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bindSingleton().

        $this->container->get(BootloadManager::class)->bootload([MonologBootloader::class]);
    }

    public function testNoHandlers(): void
    {
        $this->container->bind(MonologConfig::class, new MonologConfig());

new Spiral\Monolog\Config\MonologConfig() of type Spiral\Monolog\Config\MonologConfig is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $logger = $this->getLogger();
        $this->assertSame('test', $logger->getName());
        $this->assertCount(1, $logger->getHandlers());
    }

    public function testDefaultHandler(): void
    {
        $this->container->bind(MonologConfig::class, new MonologConfig([

new Spiral\Monolog\Config\MonologConfig(array('globalHandler' => Monolog\Logger::DEBUG)) of type Spiral\Monolog\Config\MonologConfig is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

            'globalHandler' => Logger::DEBUG
        ]));

        $logger = $this->getLogger();
        $this->assertSame('test', $logger->getName());
        $this->assertCount(1, $logger->getHandlers());
    }

    public function testInvalidHandler(): void
    {
        $this->expectException(ConfigException::class);

        $this->container->bind(MonologConfig::class, new MonologConfig([

new Spiral\Monolog\Config\MonologConfig(array('globalHandler' => Monolog\Logger::DEBUG, 'handlers' => array('test' => array(array('what?'))))) of type Spiral\Monolog\Config\MonologConfig is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

            'globalHandler' => Logger::DEBUG,
            'handlers'      => [
                'test' => [
                    ['what?']
                ]
            ]
        ]));

        $this->getLogger();
    }

    public function testHandlerObject(): void
    {
        $this->container->bind(MonologConfig::class, new MonologConfig([

new Spiral\Monolog\Config\MonologConfig(array('handlers' => array('test' => array(new Spiral\Core\Container\Autowire(Monolog\Handler\NullHandler::class))))) of type Spiral\Monolog\Config\MonologConfig is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

            'handlers' => [
                'test' => [
                    new Container\Autowire(NullHandler::class)
                ]
            ]
        ]));

        $logger = $this->getLogger();

        $this->assertCount(2, $logger->getHandlers());
        $this->assertInstanceOf(NullHandler::class, $logger->getHandlers()[0]);
    }

    public function testBindedHandler(): void
    {
        $this->container->bind('nullHandler', new NullHandler());

new Monolog\Handler\NullHandler() of type Monolog\Handler\NullHandler is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $this->container->bind(MonologConfig::class, new MonologConfig([

new Spiral\Monolog\Config\MonologConfig(array('handlers' => array('test' => array('nullHandler')))) of type Spiral\Monolog\Config\MonologConfig is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

            'handlers' => [
                'test' => [
                    'nullHandler'
                ]
            ]
        ]));

        $logger = $this->getLogger();

        $this->assertCount(2, $logger->getHandlers());
        $this->assertInstanceOf(NullHandler::class, $logger->getHandlers()[0]);
        $this->assertSame($this->container->get('nullHandler'), $logger->getHandlers()[0]);
    }

    public function testConstructHandler(): void
    {
        $this->container->bind(MonologConfig::class, new MonologConfig([

new Spiral\Monolog\Config\MonologConfig(array('handlers' => array('test' => array(array('class' => Monolog\Handler\NullHandler::class))))) of type Spiral\Monolog\Config\MonologConfig is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

            'handlers' => [
                'test' => [
                    [
                        'class' => NullHandler::class
                    ]
                ]
            ]
        ]));

        $logger = $this->getLogger();

        $this->assertCount(2, $logger->getHandlers());
        $this->assertInstanceOf(NullHandler::class, $logger->getHandlers()[0]);
    }

    public function testConstructWithOptionsHandler(): void
    {
        $this->container->bind(MonologConfig::class, new MonologConfig([

new Spiral\Monolog\Config\MonologConfig(array('handlers' => array('test' => array(array('class' => Monolog\Handler\NullHandler::class, 'options' => array('level' => Monolog\Logger::CRITICAL)))))) of type Spiral\Monolog\Config\MonologConfig is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

            'handlers' => [
                'test' => [
                    [
                        'class'   => NullHandler::class,
                        'options' => [
                            'level' => Logger::CRITICAL
                        ]
                    ]
                ]
            ]
        ]));

        $logger = $this->getLogger();

        $this->assertCount(2, $logger->getHandlers());
        $this->assertInstanceOf(NullHandler::class, $logger->getHandlers()[0]);
        $this->assertFalse($logger->getHandlers()[0]->isHandling(['level' => Logger::DEBUG]));
        $this->assertTrue($logger->getHandlers()[0]->isHandling(['level' => Logger::CRITICAL]));
    }

    protected function getLogger(): Logger
    {
        return $this->container->get(LogsInterface::class)->getLogger('test');
    }
}