DebuggerTest::testIgnoreByHeader() - Code Metrics - Inspection of "Debug commands" - yiisoft/yii-debug - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#216)

unknown

created 2023-06-05 09:04 UTC

DebuggerTest::testIgnoreByHeader() A

↳ Parent: DebuggerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	8
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	11
rs	10

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Debug\Tests\Unit;

use Nyholm\Psr7\ServerRequest;
use PHPUnit\Framework\TestCase;
use stdClass;
use Yiisoft\Yii\Console\Event\ApplicationStartup;
use Yiisoft\Yii\Debug\Collector\CollectorInterface;
use Yiisoft\Yii\Debug\Debugger;
use Yiisoft\Yii\Debug\DebuggerIdGenerator;
use Yiisoft\Yii\Debug\Storage\MemoryStorage;
use Yiisoft\Yii\Debug\Storage\StorageInterface;
use Yiisoft\Yii\Http\Event\BeforeRequest;

final class DebuggerTest extends TestCase
{
    public function testStartup(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->once())->method('startup');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->once())->method('addCollector');

        $debugger = new Debugger($idGenerator, $storage, [$collector]);
        $debugger->startup(new stdClass());
    }

    public function testStartupWithSkipCollect(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->once())->method('startup');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->once())->method('addCollector');

        $debugger = new Debugger($idGenerator, $storage, [$collector], ['/test']);
        $debugger->startup(new BeforeRequest(new ServerRequest('GET', '/debug')));
    }

    public function testGetId(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $debugger = new Debugger($idGenerator, new MemoryStorage($idGenerator), []);

        $this->assertEquals($idGenerator->getId(), $debugger->getId());
    }

    public function testWithIgnoredRequests(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $debugger1 = new Debugger($idGenerator, new MemoryStorage($idGenerator), []);
        $debugger2 = $debugger1->withIgnoredRequests(['/test']);

        $this->assertNotSame($debugger1, $debugger2);
    }

    public function testIgnoreByHeader(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->once())->method('shutdown');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->never())->method('flush');

        $debugger = new Debugger($idGenerator, $storage, [$collector], []);
        $debugger->startup(new BeforeRequest(new ServerRequest('GET', '/test', ['X-Debug-Ignore' => 'true'])));
        $debugger->shutdown();
    }

    public function testWithIgnoredCommands(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $debugger1 = new Debugger($idGenerator, new MemoryStorage($idGenerator), []);
        $debugger2 = $debugger1->withIgnoredCommands(['command/test']);

        $this->assertNotSame($debugger1, $debugger2);
    }

    public function testIgnoreByEnv(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->once())->method('shutdown');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->never())->method('flush');

        $_ENV['YII_DEBUG_IGNORE'] = 'true';
        $debugger = new Debugger($idGenerator, $storage, [$collector], []);
        $debugger->startup(new ApplicationStartup(''));
        $debugger->shutdown();
    }

    public function testShutdown(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->once())->method('shutdown');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->once())->method('flush');

        $debugger = new Debugger($idGenerator, $storage, [$collector]);
        $debugger->startup(new BeforeRequest(new ServerRequest('GET', '/test')));
        $debugger->shutdown();
        $debugger->shutdown();
        $debugger->shutdown();
    }

    public function testShutdownWithSkipRequestCollect(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->once())->method('shutdown');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->never())->method('flush');

        $debugger = new Debugger($idGenerator, $storage, [$collector], ['/test']);
        $debugger->startup(new BeforeRequest(new ServerRequest('GET', '/test')));
        $debugger->shutdown();
    }

    /**
     * @dataProvider dataShutdownWithSkipCommandCollect
     */
    public function testShutdownWithSkipCommandCollect(array $ignoredCommands, ?string $ignoredCommand): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->never())->method('startup');
        $collector->expects($this->once())->method('shutdown');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->never())->method('addCollector');
        $storage->expects($this->never())->method('flush');

        $debugger = new Debugger($idGenerator, $storage, [$collector], [], $ignoredCommands);
        $debugger->startup(new ApplicationStartup($ignoredCommand));
        $debugger->shutdown();
    }

    public static function dataShutdownWithSkipCommandCollect(): iterable
    {
        yield [
            ['app:ignored-command'],
            'app:ignored-command',
        ];
        yield [
            ['app:ignored-command1', 'app:ignored-command2'],
            'app:ignored-command2',
        ];
        yield [
            ['app:ignored-command'],
            null,
        ];
        yield [
            ['app:ignored-command'],
            '',
        ];
    }

    /**
     * @dataProvider dataShutdownWithoutSkipCommandCollect
     */
    public function testShutdownWithoutSkipCommandCollect(array $ignoredCommands, ?string $ignoredCommand): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->once())->method('startup');
        $collector->expects($this->once())->method('shutdown');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->once())->method('addCollector');
        $storage->expects($this->once())->method('flush');

        $debugger = new Debugger($idGenerator, $storage, [$collector], [], $ignoredCommands);
        $debugger->startup(new ApplicationStartup($ignoredCommand));
        $debugger->shutdown();
    }

    public static function dataShutdownWithoutSkipCommandCollect(): iterable
    {
        yield [
            [],
            'app:not-ignored-command',
        ];
        yield [
            ['app:ignored-command'],
            'app:not-ignored-command',
        ];
    }

    public function testStopSkipped(): void
    {
        $idGenerator = new DebuggerIdGenerator();
        $collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
        $collector->expects($this->once())->method('shutdown');
        $storage = $this->getMockBuilder(StorageInterface::class)->getMock();
        $storage->expects($this->never())->method('clear');
        $storage->expects($this->never())->method('flush');

        $debugger = new Debugger($idGenerator, $storage, [$collector]);
        $debugger->startup(new BeforeRequest(new ServerRequest('GET', '/test')));
        $debugger->stop();
        $debugger->stop();
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Yiisoft\Yii\Debug\Tests\Unit;
6
7			use Nyholm\Psr7\ServerRequest;
8			use PHPUnit\Framework\TestCase;
9			use stdClass;
10			use Yiisoft\Yii\Console\Event\ApplicationStartup;
11			use Yiisoft\Yii\Debug\Collector\CollectorInterface;
12			use Yiisoft\Yii\Debug\Debugger;
13			use Yiisoft\Yii\Debug\DebuggerIdGenerator;
14			use Yiisoft\Yii\Debug\Storage\MemoryStorage;
15			use Yiisoft\Yii\Debug\Storage\StorageInterface;
16			use Yiisoft\Yii\Http\Event\BeforeRequest;
17
18			final class DebuggerTest extends TestCase
19			{
20			public function testStartup(): void
21			{
22			$idGenerator = new DebuggerIdGenerator();
23			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
24			$collector->expects($this->once())->method('startup');
25			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
26			$storage->expects($this->once())->method('addCollector');
27
28			$debugger = new Debugger($idGenerator, $storage, [$collector]);
29			$debugger->startup(new stdClass());
30			}
31
32			public function testStartupWithSkipCollect(): void
33			{
34			$idGenerator = new DebuggerIdGenerator();
35			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
36			$collector->expects($this->once())->method('startup');
37			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
38			$storage->expects($this->once())->method('addCollector');
39
40			$debugger = new Debugger($idGenerator, $storage, [$collector], ['/test']);
41			$debugger->startup(new BeforeRequest(new ServerRequest('GET', '/debug')));
42			}
43
44			public function testGetId(): void
45			{
46			$idGenerator = new DebuggerIdGenerator();
47			$debugger = new Debugger($idGenerator, new MemoryStorage($idGenerator), []);
48
49			$this->assertEquals($idGenerator->getId(), $debugger->getId());
50			}
51
52			public function testWithIgnoredRequests(): void
53			{
54			$idGenerator = new DebuggerIdGenerator();
55			$debugger1 = new Debugger($idGenerator, new MemoryStorage($idGenerator), []);
56			$debugger2 = $debugger1->withIgnoredRequests(['/test']);
57
58			$this->assertNotSame($debugger1, $debugger2);
59			}
60
61			public function testIgnoreByHeader(): void
62			{
63			$idGenerator = new DebuggerIdGenerator();
64			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
65			$collector->expects($this->once())->method('shutdown');
66			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
67			$storage->expects($this->never())->method('flush');
68
69			$debugger = new Debugger($idGenerator, $storage, [$collector], []);
70			$debugger->startup(new BeforeRequest(new ServerRequest('GET', '/test', ['X-Debug-Ignore' => 'true'])));
71			$debugger->shutdown();
72			}
73
74			public function testWithIgnoredCommands(): void
75			{
76			$idGenerator = new DebuggerIdGenerator();
77			$debugger1 = new Debugger($idGenerator, new MemoryStorage($idGenerator), []);
78			$debugger2 = $debugger1->withIgnoredCommands(['command/test']);
79
80			$this->assertNotSame($debugger1, $debugger2);
81			}
82
83			public function testIgnoreByEnv(): void
84			{
85			$idGenerator = new DebuggerIdGenerator();
86			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
87			$collector->expects($this->once())->method('shutdown');
88			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
89			$storage->expects($this->never())->method('flush');
90
91			$_ENV['YII_DEBUG_IGNORE'] = 'true';
92			$debugger = new Debugger($idGenerator, $storage, [$collector], []);
93			$debugger->startup(new ApplicationStartup(''));
94			$debugger->shutdown();
95			}
96
97			public function testShutdown(): void
98			{
99			$idGenerator = new DebuggerIdGenerator();
100			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
101			$collector->expects($this->once())->method('shutdown');
102			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
103			$storage->expects($this->once())->method('flush');
104
105			$debugger = new Debugger($idGenerator, $storage, [$collector]);
106			$debugger->startup(new BeforeRequest(new ServerRequest('GET', '/test')));
107			$debugger->shutdown();
108			$debugger->shutdown();
109			$debugger->shutdown();
110			}
111
112			public function testShutdownWithSkipRequestCollect(): void
113			{
114			$idGenerator = new DebuggerIdGenerator();
115			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
116			$collector->expects($this->once())->method('shutdown');
117			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
118			$storage->expects($this->never())->method('flush');
119
120			$debugger = new Debugger($idGenerator, $storage, [$collector], ['/test']);
121			$debugger->startup(new BeforeRequest(new ServerRequest('GET', '/test')));
122			$debugger->shutdown();
123			}
124
125			/**
126			* @dataProvider dataShutdownWithSkipCommandCollect
127			*/
128			public function testShutdownWithSkipCommandCollect(array $ignoredCommands, ?string $ignoredCommand): void
129			{
130			$idGenerator = new DebuggerIdGenerator();
131			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
132			$collector->expects($this->never())->method('startup');
133			$collector->expects($this->once())->method('shutdown');
134			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
135			$storage->expects($this->never())->method('addCollector');
136			$storage->expects($this->never())->method('flush');
137
138			$debugger = new Debugger($idGenerator, $storage, [$collector], [], $ignoredCommands);
139			$debugger->startup(new ApplicationStartup($ignoredCommand));
140			$debugger->shutdown();
141			}
142
143			public static function dataShutdownWithSkipCommandCollect(): iterable
144			{
145			yield [
146			['app:ignored-command'],
147			'app:ignored-command',
148			];
149			yield [
150			['app:ignored-command1', 'app:ignored-command2'],
151			'app:ignored-command2',
152			];
153			yield [
154			['app:ignored-command'],
155			null,
156			];
157			yield [
158			['app:ignored-command'],
159			'',
160			];
161			}
162
163			/**
164			* @dataProvider dataShutdownWithoutSkipCommandCollect
165			*/
166			public function testShutdownWithoutSkipCommandCollect(array $ignoredCommands, ?string $ignoredCommand): void
167			{
168			$idGenerator = new DebuggerIdGenerator();
169			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
170			$collector->expects($this->once())->method('startup');
171			$collector->expects($this->once())->method('shutdown');
172			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
173			$storage->expects($this->once())->method('addCollector');
174			$storage->expects($this->once())->method('flush');
175
176			$debugger = new Debugger($idGenerator, $storage, [$collector], [], $ignoredCommands);
177			$debugger->startup(new ApplicationStartup($ignoredCommand));
178			$debugger->shutdown();
179			}
180
181			public static function dataShutdownWithoutSkipCommandCollect(): iterable
182			{
183			yield [
184			[],
185			'app:not-ignored-command',
186			];
187			yield [
188			['app:ignored-command'],
189			'app:not-ignored-command',
190			];
191			}
192
193			public function testStopSkipped(): void
194			{
195			$idGenerator = new DebuggerIdGenerator();
196			$collector = $this->getMockBuilder(CollectorInterface::class)->getMock();
197			$collector->expects($this->once())->method('shutdown');
198			$storage = $this->getMockBuilder(StorageInterface::class)->getMock();
199			$storage->expects($this->never())->method('clear');
200			$storage->expects($this->never())->method('flush');
201
202			$debugger = new Debugger($idGenerator, $storage, [$collector]);
203			$debugger->startup(new BeforeRequest(new ServerRequest('GET', '/test')));
204			$debugger->stop();
205			$debugger->stop();
206			}
207			}
208

yiisoft / yii-debug

Pull Request — master (#216)

DebuggerTest::testIgnoreByHeader() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like