FactoryTest::testFinalizerShouldResetDefaultLogger()

Size

Total Lines	39
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

2 Methods

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

<?php

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

declare(strict_types=1);

namespace Spiral\Tests\Monolog;

use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
use Monolog\Handler\HandlerInterface;
use Monolog\Logger;
use Monolog\Processor\ProcessorInterface;
use Monolog\ResettableInterface;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Spiral\Boot\BootloadManager;
use Spiral\Boot\Finalizer;
use Spiral\Boot\FinalizerInterface;
use Spiral\Config\ConfigManager;
use Spiral\Config\ConfiguratorInterface;
use Spiral\Config\LoaderInterface;
use Spiral\Core\Container;
use Spiral\Logger\ListenerRegistry;
use Spiral\Logger\LogsInterface;
use Spiral\Monolog\Bootloader\MonologBootloader;
use Spiral\Monolog\Config\MonologConfig;
use Spiral\Monolog\LogFactory;

class FactoryTest extends TestCase
{
    use MockeryPHPUnitIntegration;

    public function testDefaultLogger(): void
    {
        $factory = new LogFactory(new MonologConfig([]), new ListenerRegistry(), new Container());
        $logger = $factory->getLogger();

        $this->assertNotEmpty($logger);
        $this->assertSame($logger, $factory->getLogger());
        $this->assertSame($logger, $factory->getLogger(LogFactory::DEFAULT));
    }

    public function testInjection(): void
    {
        $factory = new LogFactory(new MonologConfig([]), new ListenerRegistry(), new Container());
        $logger = $factory->getLogger();

        $container = new Container();
        $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 [];
                }
            }
        ));

        $container->bind(FinalizerInterface::class, $finalizer = \Mockery::mock(FinalizerInterface::class));

$finalizer = Mockery::mock(Spiral\Boot\FinalizerInterface::class) of type Mockery\LegacyMockInterface|Mockery\MockInterface is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $finalizer->shouldReceive('addFinalizer')->once();

        $container->get(BootloadManager::class)->bootload([MonologBootloader::class]);
        $container->bind(LogFactory::class, $factory);

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

        $this->assertSame($logger, $container->get(Logger::class));
        $this->assertSame($logger, $container->get(LoggerInterface::class));
    }

    public function testFinalizerShouldResetDefaultLogger()
    {
        $container = new Container();
        $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 [];
                }
            }
        ));

        $container->bind(FinalizerInterface::class, $finalizer = new Finalizer());

$finalizer = new Spiral\Boot\Finalizer() of type Spiral\Boot\Finalizer is incompatible with the type array|callable|string expected by parameter $resolver of Spiral\Core\Container::bind().

        $factory = new LogFactory(new MonologConfig([
            'handlers' => [
                'default' => [
                    $handler = \Mockery::mock(HandlerInterface::class, ResettableInterface::class)
                ]
            ],
            'processors' => [
                'default' => [
                    $processor = \Mockery::mock(ProcessorInterface::class, ResettableInterface::class)
                ]
            ]
        ]), new ListenerRegistry(), $container);

        $handler->shouldReceive('reset')->once();
        $processor->shouldReceive('reset')->once();

        $container->bind(LogFactory::class, $factory);

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

        $container->get(BootloadManager::class)->bootload([MonologBootloader::class]);
        $container->get(LogsInterface::class)->getLogger();
        $finalizer->finalize();
    }
}