ContainerInterfaceProxyTest::testGetWithoutConfig() - Code Metrics - Inspection of "Fixed tests windows." - yiisoft/yii-debug - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#156)

by Wilmer

created 2022-10-31 14:33 UTC

testGetWithoutConfig() A

↳ Parent: ContainerInterfaceProxyTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	13
dl	0
loc	20
rs	9.8333
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Debug\Tests\Collector;

use PHPUnit\Framework\TestCase;
use Psr\Container\ContainerExceptionInterface;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\EventDispatcher\ListenerProviderInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use stdClass;
use Yiisoft\Di\Container;
use Yiisoft\Di\ContainerConfig;
use Yiisoft\EventDispatcher\Dispatcher\Dispatcher;
use Yiisoft\EventDispatcher\Provider\Provider;
use Yiisoft\Files\FileHelper;
use Yiisoft\Yii\Debug\Collector\CollectorInterface;
use Yiisoft\Yii\Debug\Collector\EventCollector;
use Yiisoft\Yii\Debug\Collector\LogCollector;
use Yiisoft\Yii\Debug\Collector\ServiceCollector;
use Yiisoft\Yii\Debug\Collector\ContainerInterfaceProxy;
use Yiisoft\Yii\Debug\Collector\ContainerProxyConfig;
use Yiisoft\Yii\Debug\Collector\EventDispatcherInterfaceProxy;
use Yiisoft\Yii\Debug\Collector\LoggerInterfaceProxy;

class ContainerInterfaceProxyTest extends TestCase
{
    private string $path = 'tests/container-proxy';

    protected function tearDown(): void
    {
        parent::tearDown();
        FileHelper::removeDirectory($this->path);
    }

    public function testImmutability(): void
    {
        $containerProxy = new ContainerInterfaceProxy(new Container(ContainerConfig::create()), new ContainerProxyConfig());

        $this->assertNotSame(
            $containerProxy,
            $containerProxy->withDecoratedServices(
                [
                    LoggerInterface::class => [LoggerInterfaceProxy::class, LogCollector::class],
                ]
            )
        );
    }

    public function testGetAndHas(): void
    {
        $containerProxy = new ContainerInterfaceProxy($this->getContainer(), $this->getConfig());

        $this->assertTrue($containerProxy->isActive());
        $this->assertTrue($containerProxy->has(LoggerInterface::class));
        $this->assertInstanceOf(LoggerInterfaceProxy::class, $containerProxy->get(LoggerInterface::class));
    }

    public function testGetAndHasWithCallableServices(): void
    {
        $dispatcherMock = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();
        $config = new ContainerProxyConfig(
            true,
            [
                LoggerInterface::class => fn (Container $container) => $container->get(LoggerInterfaceProxy::class),
                EventDispatcherInterface::class => [
                    EventDispatcherInterfaceProxy::class,
                    EventCollector::class,
                ],
            ],
            $dispatcherMock,
            new ServiceCollector(),
            $this->path,
            1
        );
        $containerProxy = new ContainerInterfaceProxy($this->getContainer(), $config);

        $this->assertTrue($containerProxy->isActive());
        $this->assertTrue($containerProxy->has(LoggerInterface::class));

        $containerProxy->get(LogCollector::class)->startup();
        $containerProxy->get(LoggerInterface::class)->log('test', 'test message');
        $this->assertNotEmpty($containerProxy->get(LogCollector::class)->getCollected());
    }

    public function testGetWithArrayConfigWithStringKeys(): void
    {
        $dispatcherMock = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();
        $serviceCollector = new ServiceCollector();
        $serviceCollector->startup(); // activate collector

        $config = new ContainerProxyConfig(
            true,
            [
                LoggerInterface::class => ['logger' => LoggerInterfaceProxy::class],
                EventDispatcherInterface::class => [
                    EventDispatcherInterfaceProxy::class,
                    EventCollector::class,
                ],
            ],
            $dispatcherMock,
            $serviceCollector,
            $this->path,
            1
        );
        $container = $this->getContainer();
        $containerProxy = new ContainerInterfaceProxy($container, $config);

        $this->assertTrue($containerProxy->isActive());
        $this->assertInstanceOf(LoggerInterface::class, $containerProxy->get(LoggerInterface::class));

        $containerProxy->get(LoggerInterface::class)->log('test', 'test message');
        $this->assertInstanceOf(LoggerInterface::class, $containerProxy->get(LoggerInterface::class));
        $this->assertNotEmpty($config->getCollector()->getCollected());
    }

    public function testGetWithoutConfig(): void
    {
        $dispatcherMock = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();
        $config = new ContainerProxyConfig(
            true,
            [
                LoggerInterface::class => [LoggerInterfaceProxy::class, LogCollector::class],
                EventDispatcherInterface::class,
            ],
            $dispatcherMock,
            new ServiceCollector(),
            $this->path,
            1
        );
        $containerProxy = new ContainerInterfaceProxy($this->getContainer(), $config);

        $this->assertInstanceOf(EventDispatcherInterface::class, $containerProxy->get(EventDispatcherInterface::class));
        $this->assertInstanceOf(
            stdClass::class,
            $containerProxy->get(EventDispatcherInterface::class)->dispatch(new stdClass())
        );
    }

    public function testGetAndHasWithWrongId(): void
    {
        $this->expectException(ContainerExceptionInterface::class);
        $this->expectExceptionMessage(
            sprintf(
                'No definition or class found or resolvable for "%s" while building "%s".',
                CollectorInterface::class,
                CollectorInterface::class
            )
        );

        $containerProxy = new ContainerInterfaceProxy($this->getContainer(), $this->getConfig());

        $containerProxy->has(CollectorInterface::class);
        $containerProxy->get(CollectorInterface::class);
    }

    public function testGetAndHasWithNotService(): void
    {
        $containerProxy = new ContainerInterfaceProxy($this->getContainer(), $this->getConfig());

        $this->assertTrue($containerProxy->has(ListenerProviderInterface::class));
        $this->assertNotNull($containerProxy->get(ListenerProviderInterface::class));
        $this->assertInstanceOf(
            ListenerProviderInterface::class,
            $containerProxy->get(ListenerProviderInterface::class)
        );
    }

    private function getConfig(): ContainerProxyConfig
    {
        $dispatcherMock = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();

        return new ContainerProxyConfig(
            true,
            [
                LoggerInterface::class => [LoggerInterfaceProxy::class, LogCollector::class],
                EventDispatcherInterface::class => [
                    EventDispatcherInterfaceProxy::class,
                    EventCollector::class,
                ],
            ],
            $dispatcherMock,
            new ServiceCollector(),
            $this->path,
            1
        );
    }

    private function getContainer(): Container
    {
        $config = ContainerConfig::create()
            ->withDefinitions([
                EventDispatcherInterface::class => Dispatcher::class,
                ListenerProviderInterface::class => Provider::class,
                LoggerInterface::class => NullLogger::class,
                LogCollector::class => LogCollector::class,
                EventCollector::class => EventCollector::class,
            ]);
        return new Container($config);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Yii\Debug\Tests\Collector;
6
7			use PHPUnit\Framework\TestCase;
8			use Psr\Container\ContainerExceptionInterface;
9			use Psr\EventDispatcher\EventDispatcherInterface;
10			use Psr\EventDispatcher\ListenerProviderInterface;
11			use Psr\Log\LoggerInterface;
12			use Psr\Log\NullLogger;
13			use stdClass;
14			use Yiisoft\Di\Container;
15			use Yiisoft\Di\ContainerConfig;
16			use Yiisoft\EventDispatcher\Dispatcher\Dispatcher;
17			use Yiisoft\EventDispatcher\Provider\Provider;
18			use Yiisoft\Files\FileHelper;
19			use Yiisoft\Yii\Debug\Collector\CollectorInterface;
20			use Yiisoft\Yii\Debug\Collector\EventCollector;
21			use Yiisoft\Yii\Debug\Collector\LogCollector;
22			use Yiisoft\Yii\Debug\Collector\ServiceCollector;
23			use Yiisoft\Yii\Debug\Collector\ContainerInterfaceProxy;
24			use Yiisoft\Yii\Debug\Collector\ContainerProxyConfig;
25			use Yiisoft\Yii\Debug\Collector\EventDispatcherInterfaceProxy;
26			use Yiisoft\Yii\Debug\Collector\LoggerInterfaceProxy;
27
28			class ContainerInterfaceProxyTest extends TestCase
29			{
30			private string $path = 'tests/container-proxy';
31
32			protected function tearDown(): void
33			{
34			parent::tearDown();
35			FileHelper::removeDirectory($this->path);
36			}
37
38			public function testImmutability(): void
39			{
40			$containerProxy = new ContainerInterfaceProxy(new Container(ContainerConfig::create()), new ContainerProxyConfig());
41
42			$this->assertNotSame(
43			$containerProxy,
44			$containerProxy->withDecoratedServices(
45			[
46			LoggerInterface::class => [LoggerInterfaceProxy::class, LogCollector::class],
47			]
48			)
49			);
50			}
51
52			public function testGetAndHas(): void
53			{
54			$containerProxy = new ContainerInterfaceProxy($this->getContainer(), $this->getConfig());
55
56			$this->assertTrue($containerProxy->isActive());
57			$this->assertTrue($containerProxy->has(LoggerInterface::class));
58			$this->assertInstanceOf(LoggerInterfaceProxy::class, $containerProxy->get(LoggerInterface::class));
59			}
60
61			public function testGetAndHasWithCallableServices(): void
62			{
63			$dispatcherMock = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();
64			$config = new ContainerProxyConfig(
65			true,
66			[
67			LoggerInterface::class => fn (Container $container) => $container->get(LoggerInterfaceProxy::class),
68			EventDispatcherInterface::class => [
69			EventDispatcherInterfaceProxy::class,
70			EventCollector::class,
71			],
72			],
73			$dispatcherMock,
74			new ServiceCollector(),
75			$this->path,
76			1
77			);
78			$containerProxy = new ContainerInterfaceProxy($this->getContainer(), $config);
79
80			$this->assertTrue($containerProxy->isActive());
81			$this->assertTrue($containerProxy->has(LoggerInterface::class));
82
83			$containerProxy->get(LogCollector::class)->startup();
84			$containerProxy->get(LoggerInterface::class)->log('test', 'test message');
85			$this->assertNotEmpty($containerProxy->get(LogCollector::class)->getCollected());
86			}
87
88			public function testGetWithArrayConfigWithStringKeys(): void
89			{
90			$dispatcherMock = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();
91			$serviceCollector = new ServiceCollector();
92			$serviceCollector->startup(); // activate collector
93
94			$config = new ContainerProxyConfig(
95			true,
96			[
97			LoggerInterface::class => ['logger' => LoggerInterfaceProxy::class],
98			EventDispatcherInterface::class => [
99			EventDispatcherInterfaceProxy::class,
100			EventCollector::class,
101			],
102			],
103			$dispatcherMock,
104			$serviceCollector,
105			$this->path,
106			1
107			);
108			$container = $this->getContainer();
109			$containerProxy = new ContainerInterfaceProxy($container, $config);
110
111			$this->assertTrue($containerProxy->isActive());
112			$this->assertInstanceOf(LoggerInterface::class, $containerProxy->get(LoggerInterface::class));
113
114			$containerProxy->get(LoggerInterface::class)->log('test', 'test message');
115			$this->assertInstanceOf(LoggerInterface::class, $containerProxy->get(LoggerInterface::class));
116			$this->assertNotEmpty($config->getCollector()->getCollected());
117			}
118
119			public function testGetWithoutConfig(): void
120			{
121			$dispatcherMock = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();
122			$config = new ContainerProxyConfig(
123			true,
124			[
125			LoggerInterface::class => [LoggerInterfaceProxy::class, LogCollector::class],
126			EventDispatcherInterface::class,
127			],
128			$dispatcherMock,
129			new ServiceCollector(),
130			$this->path,
131			1
132			);
133			$containerProxy = new ContainerInterfaceProxy($this->getContainer(), $config);
134
135			$this->assertInstanceOf(EventDispatcherInterface::class, $containerProxy->get(EventDispatcherInterface::class));
136			$this->assertInstanceOf(
137			stdClass::class,
138			$containerProxy->get(EventDispatcherInterface::class)->dispatch(new stdClass())
139			);
140			}
141
142			public function testGetAndHasWithWrongId(): void
143			{
144			$this->expectException(ContainerExceptionInterface::class);
145			$this->expectExceptionMessage(
146			sprintf(
147			'No definition or class found or resolvable for "%s" while building "%s".',
148			CollectorInterface::class,
149			CollectorInterface::class
150			)
151			);
152
153			$containerProxy = new ContainerInterfaceProxy($this->getContainer(), $this->getConfig());
154
155			$containerProxy->has(CollectorInterface::class);
156			$containerProxy->get(CollectorInterface::class);
157			}
158
159			public function testGetAndHasWithNotService(): void
160			{
161			$containerProxy = new ContainerInterfaceProxy($this->getContainer(), $this->getConfig());
162
163			$this->assertTrue($containerProxy->has(ListenerProviderInterface::class));
164			$this->assertNotNull($containerProxy->get(ListenerProviderInterface::class));
165			$this->assertInstanceOf(
166			ListenerProviderInterface::class,
167			$containerProxy->get(ListenerProviderInterface::class)
168			);
169			}
170
171			private function getConfig(): ContainerProxyConfig
172			{
173			$dispatcherMock = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();
174
175			return new ContainerProxyConfig(
176			true,
177			[
178			LoggerInterface::class => [LoggerInterfaceProxy::class, LogCollector::class],
179			EventDispatcherInterface::class => [
180			EventDispatcherInterfaceProxy::class,
181			EventCollector::class,
182			],
183			],
184			$dispatcherMock,
185			new ServiceCollector(),
186			$this->path,
187			1
188			);
189			}
190
191			private function getContainer(): Container
192			{
193			$config = ContainerConfig::create()
194			->withDefinitions([
195			EventDispatcherInterface::class => Dispatcher::class,
196			ListenerProviderInterface::class => Provider::class,
197			LoggerInterface::class => NullLogger::class,
198			LogCollector::class => LogCollector::class,
199			EventCollector::class => EventCollector::class,
200			]);
201			return new Container($config);
202			}
203			}
204

yiisoft / yii-debug

Pull Request — master (#156)

testGetWithoutConfig() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like