LoggerTest::dataProviderParseMessage() - Code Metrics - Inspection of "Switch to GitHub actions (#30)" - yiisoft/log - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 61f3a0...6b4c98 )

by Alexander

created 2020-06-09 12:47 UTC

LoggerTest::dataProviderParseMessage() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	9
nc	1
nop	0
dl	0
loc	17
rs	9.9666
c	0
b	0
f	0

<?php

namespace Yiisoft\Log\Tests;

use Psr\Log\LogLevel;
use Yiisoft\Log\Logger;
use Yiisoft\Log\Target;

/**
 * @group log
 */
class LoggerTest extends TestCase
{
    /**
     * @var Logger|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $logger;

    protected function setUp(): void
    {
        $this->logger = $this->getMockBuilder(Logger::class)
            ->onlyMethods(['dispatch'])
            ->getMock();
    }

    /**
     * @covers \Yiisoft\Log\Logger::Log()
     */
    public function testLogWithTraceLevel(): void
    {
        $memory = memory_get_usage();
        $this->logger->setTraceLevel(3);
        $this->logger->log(LogLevel::INFO, 'test3');

        $messages = $this->getInaccessibleProperty($this->logger, 'messages');
        $this->assertCount(1, $messages);
        $this->assertEquals(LogLevel::INFO, $messages[0][0]);
        $this->assertEquals('test3', $messages[0][1]);
        $this->assertEquals('application', $messages[0][2]['category']);
        $this->assertEquals([
            'file' => __FILE__,
            'line' => 33,
            'function' => 'log',
            'class' => Logger::class,
            'type' => '->',
        ], $messages[0][2]['trace'][0]);
        $this->assertCount(3, $messages[0][2]['trace']);
        $this->assertGreaterThanOrEqual($memory, $messages[0][2]['memory']);
    }

    /**
     * @covers \Yiisoft\Log\Logger::Log()
     */
    public function testLog(): void
    {
        $memory = memory_get_usage();
        $this->logger->log(LogLevel::INFO, 'test1');

        $messages = $this->getInaccessibleProperty($this->logger, 'messages');
        $this->assertCount(1, $messages);
        $this->assertEquals(LogLevel::INFO, $messages[0][0]);
        $this->assertEquals('test1', $messages[0][1]);
        $this->assertEquals('application', $messages[0][2]['category']);
        $this->assertEquals([], $messages[0][2]['trace']);
        $this->assertGreaterThanOrEqual($memory, $messages[0][2]['memory']);

        $this->logger->log(LogLevel::ERROR, 'test2', ['category' => 'category']);

        $messages = $this->getInaccessibleProperty($this->logger, 'messages');
        $this->assertCount(2, $messages);
        $this->assertEquals(LogLevel::ERROR, $messages[1][0]);
        $this->assertEquals('test2', $messages[1][1]);
        $this->assertEquals('category', $messages[1][2]['category']);
        $this->assertEquals([], $messages[1][2]['trace']);
        $this->assertGreaterThanOrEqual($memory, $messages[1][2]['memory']);
    }

    public function testExcludedTracePaths(): void
    {
        $this->logger->setTraceLevel(20);

        $this->logger->info('info message');

        $messages = $this->getInaccessibleProperty($this->logger, 'messages');
        $this->assertEquals(__FILE__, $messages[0][2]['trace'][1]['file']);

        $this->logger->setExcludedTracePaths([__DIR__]);
        $this->logger->info('info message');
        $messages = $this->getInaccessibleProperty($this->logger, 'messages');
        foreach ($messages[1][2]['trace'] as $trace) {
            $this->assertNotEquals(__FILE__, $trace['file']);
        }
    }

    /**
     * @covers \Yiisoft\Log\Logger::Log()
     */
    public function testLogWithFlush(): void
    {
        /* @var $logger Logger|\PHPUnit_Framework_MockObject_MockObject */
        $logger = $this->getMockBuilder(Logger::class)
            ->onlyMethods(['flush'])
            ->getMock();
        $logger->setFlushInterval(1);
        $logger->expects($this->once())->method('flush');
        $logger->log(LogLevel::INFO, 'test1');
    }

    /**
     * @covers \Yiisoft\Log\Logger::Flush()
     */
    public function testFlushWithDispatch(): void
    {
        $message = ['anything'];
        $this->logger->expects($this->once())
            ->method('dispatch')->with($this->equalTo($message), $this->equalTo(false));

        $this->setInaccessibleProperty($this->logger, 'messages', $message);
        $this->logger->flush();
        $this->assertEmpty($this->getInaccessibleProperty($this->logger, 'messages'));
    }

    /**
     * @covers \Yiisoft\Log\Logger::Flush()
     */
    public function testFlushWithDispatchAndDefinedParam(): void
    {
        $message = ['anything'];
        $this->logger->expects($this->once())
            ->method('dispatch')->with($this->equalTo($message), $this->equalTo(true));

        $this->setInaccessibleProperty($this->logger, 'messages', $message);
        $this->logger->flush(true);
        $this->assertEmpty($this->getInaccessibleProperty($this->logger, 'messages'));
    }

    /**
     * @covers \Yiisoft\Log\Logger::getElapsedTime()
     */
    public function testGetElapsedTime(): void
    {
        $timeBefore = \microtime(true) - $_SERVER['REQUEST_TIME_FLOAT'];
        usleep(1);
        $actual = $this->logger->getElapsedTime();
        usleep(1);
        $timeAfter = \microtime(true) - $_SERVER['REQUEST_TIME_FLOAT'];

        $this->assertGreaterThan($timeBefore, $actual);
        $this->assertLessThan($timeAfter, $actual);
    }

    /**
     * @covers \Yiisoft\Log\Logger::getLevelName()
     */
    public function testGetLevelName(): void
    {
        $this->assertEquals('info', Logger::getLevelName(LogLevel::INFO));
        $this->assertEquals('error', Logger::getLevelName(LogLevel::ERROR));
        $this->assertEquals('warning', Logger::getLevelName(LogLevel::WARNING));
        $this->assertEquals('debug', Logger::getLevelName(LogLevel::DEBUG));
        $this->assertEquals('emergency', Logger::getLevelName(LogLevel::EMERGENCY));
        $this->assertEquals('alert', Logger::getLevelName(LogLevel::ALERT));
        $this->assertEquals('critical', Logger::getLevelName(LogLevel::CRITICAL));
        $this->assertEquals('unknown', Logger::getLevelName(0));
    }

    /**
     * @covers \Yiisoft\Log\Logger::setTargets()
     * @covers \Yiisoft\Log\Logger::getTargets()
     */
    public function testSetupTarget(): void
    {
        $logger = new Logger();

        $target = $this->getMockForAbstractClass(Target::class);
        $logger->setTargets([$target]);

        $this->assertEquals([$target], $logger->getTargets());
        $this->assertSame($target, $logger->getTargets()[0]);
    }

    /**
     * @depends testSetupTarget
     *
     * @covers \Yiisoft\Log\Logger::addTarget()
     */
    public function testAddTarget(): void
    {
        $logger = new Logger();

        $target = $this->getMockForAbstractClass(Target::class);
        $logger->setTargets([$target]);

        $namedTarget = $this->getMockForAbstractClass(Target::class);
        $logger->addTarget($namedTarget, 'test-target');

        $targets = $logger->getTargets();
        $this->assertCount(2, $targets);
        $this->assertTrue(isset($targets['test-target']));
        $this->assertSame($namedTarget, $targets['test-target']);

        $namelessTarget = $this->getMockForAbstractClass(Target::class);
        $logger->addTarget($namelessTarget);
        $targets = $logger->getTargets();
        $this->assertCount(3, $targets);
        $this->assertSame($namelessTarget, array_pop($targets));
    }

    /**
     * Data provider for [[testParseMessage()]]
     * @return array test data.
     */
    public function dataProviderParseMessage(): array
    {
        return [
            [
                'no placeholder',
                ['foo' => 'some'],
                'no placeholder',
            ],
            [
                'has {foo} placeholder',
                ['foo' => 'some'],
                'has some placeholder',
            ],
            [
                'has {foo} placeholder',
                [],
                'has {foo} placeholder',
            ],
        ];
    }

    /**
     * @depends testLog
     * @dataProvider dataProviderParseMessage
     *
     * @covers \Yiisoft\Log\Logger::parseMessage()
     *
     * @param string $message
     * @param array $context
     * @param string $expected
     */
    public function testParseMessage(string $message, array $context, string $expected): void
    {
        $this->logger->log(LogLevel::INFO, $message, $context);
        $messages = $this->getInaccessibleProperty($this->logger, 'messages');
        [, $message] = $messages[0];
        $this->assertEquals($expected, $message);
    }
}


1			<?php
2
3			namespace Yiisoft\Log\Tests;
4
5			use Psr\Log\LogLevel;
6			use Yiisoft\Log\Logger;
7			use Yiisoft\Log\Target;
8
9			/**
10			* @group log
11			*/
12			class LoggerTest extends TestCase
13			{
14			/**
15			* @var Logger\|\PHPUnit_Framework_MockObject_MockObject
16			*/
17			protected $logger;
18
19			protected function setUp(): void
20			{
21			$this->logger = $this->getMockBuilder(Logger::class)
22			->onlyMethods(['dispatch'])
23			->getMock();
24			}
25
26			/**
27			* @covers \Yiisoft\Log\Logger::Log()
28			*/
29			public function testLogWithTraceLevel(): void
30			{
31			$memory = memory_get_usage();
32			$this->logger->setTraceLevel(3);
33			$this->logger->log(LogLevel::INFO, 'test3');
34
35			$messages = $this->getInaccessibleProperty($this->logger, 'messages');
36			$this->assertCount(1, $messages);
37			$this->assertEquals(LogLevel::INFO, $messages[0][0]);
38			$this->assertEquals('test3', $messages[0][1]);
39			$this->assertEquals('application', $messages[0][2]['category']);
40			$this->assertEquals([
41			'file' => __FILE__,
42			'line' => 33,
43			'function' => 'log',
44			'class' => Logger::class,
45			'type' => '->',
46			], $messages[0][2]['trace'][0]);
47			$this->assertCount(3, $messages[0][2]['trace']);
48			$this->assertGreaterThanOrEqual($memory, $messages[0][2]['memory']);
49			}
50
51			/**
52			* @covers \Yiisoft\Log\Logger::Log()
53			*/
54			public function testLog(): void
55			{
56			$memory = memory_get_usage();
57			$this->logger->log(LogLevel::INFO, 'test1');
58
59			$messages = $this->getInaccessibleProperty($this->logger, 'messages');
60			$this->assertCount(1, $messages);
61			$this->assertEquals(LogLevel::INFO, $messages[0][0]);
62			$this->assertEquals('test1', $messages[0][1]);
63			$this->assertEquals('application', $messages[0][2]['category']);
64			$this->assertEquals([], $messages[0][2]['trace']);
65			$this->assertGreaterThanOrEqual($memory, $messages[0][2]['memory']);
66
67			$this->logger->log(LogLevel::ERROR, 'test2', ['category' => 'category']);
68
69			$messages = $this->getInaccessibleProperty($this->logger, 'messages');
70			$this->assertCount(2, $messages);
71			$this->assertEquals(LogLevel::ERROR, $messages[1][0]);
72			$this->assertEquals('test2', $messages[1][1]);
73			$this->assertEquals('category', $messages[1][2]['category']);
74			$this->assertEquals([], $messages[1][2]['trace']);
75			$this->assertGreaterThanOrEqual($memory, $messages[1][2]['memory']);
76			}
77
78			public function testExcludedTracePaths(): void
79			{
80			$this->logger->setTraceLevel(20);
81
82			$this->logger->info('info message');
83
84			$messages = $this->getInaccessibleProperty($this->logger, 'messages');
85			$this->assertEquals(__FILE__, $messages[0][2]['trace'][1]['file']);
86
87			$this->logger->setExcludedTracePaths([__DIR__]);
88			$this->logger->info('info message');
89			$messages = $this->getInaccessibleProperty($this->logger, 'messages');
90			foreach ($messages[1][2]['trace'] as $trace) {
91			$this->assertNotEquals(__FILE__, $trace['file']);
92			}
93			}
94
95			/**
96			* @covers \Yiisoft\Log\Logger::Log()
97			*/
98			public function testLogWithFlush(): void
99			{
100			/* @var $logger Logger\|\PHPUnit_Framework_MockObject_MockObject */
101			$logger = $this->getMockBuilder(Logger::class)
102			->onlyMethods(['flush'])
103			->getMock();
104			$logger->setFlushInterval(1);
105			$logger->expects($this->once())->method('flush');
106			$logger->log(LogLevel::INFO, 'test1');
107			}
108
109			/**
110			* @covers \Yiisoft\Log\Logger::Flush()
111			*/
112			public function testFlushWithDispatch(): void
113			{
114			$message = ['anything'];
115			$this->logger->expects($this->once())
116			->method('dispatch')->with($this->equalTo($message), $this->equalTo(false));
117
118			$this->setInaccessibleProperty($this->logger, 'messages', $message);
119			$this->logger->flush();
120			$this->assertEmpty($this->getInaccessibleProperty($this->logger, 'messages'));
121			}
122
123			/**
124			* @covers \Yiisoft\Log\Logger::Flush()
125			*/
126			public function testFlushWithDispatchAndDefinedParam(): void
127			{
128			$message = ['anything'];
129			$this->logger->expects($this->once())
130			->method('dispatch')->with($this->equalTo($message), $this->equalTo(true));
131
132			$this->setInaccessibleProperty($this->logger, 'messages', $message);
133			$this->logger->flush(true);
134			$this->assertEmpty($this->getInaccessibleProperty($this->logger, 'messages'));
135			}
136
137			/**
138			* @covers \Yiisoft\Log\Logger::getElapsedTime()
139			*/
140			public function testGetElapsedTime(): void
141			{
142			$timeBefore = \microtime(true) - $_SERVER['REQUEST_TIME_FLOAT'];
143			usleep(1);
144			$actual = $this->logger->getElapsedTime();
145			usleep(1);
146			$timeAfter = \microtime(true) - $_SERVER['REQUEST_TIME_FLOAT'];
147
148			$this->assertGreaterThan($timeBefore, $actual);
149			$this->assertLessThan($timeAfter, $actual);
150			}
151
152			/**
153			* @covers \Yiisoft\Log\Logger::getLevelName()
154			*/
155			public function testGetLevelName(): void
156			{
157			$this->assertEquals('info', Logger::getLevelName(LogLevel::INFO));
158			$this->assertEquals('error', Logger::getLevelName(LogLevel::ERROR));
159			$this->assertEquals('warning', Logger::getLevelName(LogLevel::WARNING));
160			$this->assertEquals('debug', Logger::getLevelName(LogLevel::DEBUG));
161			$this->assertEquals('emergency', Logger::getLevelName(LogLevel::EMERGENCY));
162			$this->assertEquals('alert', Logger::getLevelName(LogLevel::ALERT));
163			$this->assertEquals('critical', Logger::getLevelName(LogLevel::CRITICAL));
164			$this->assertEquals('unknown', Logger::getLevelName(0));
165			}
166
167			/**
168			* @covers \Yiisoft\Log\Logger::setTargets()
169			* @covers \Yiisoft\Log\Logger::getTargets()
170			*/
171			public function testSetupTarget(): void
172			{
173			$logger = new Logger();
174
175			$target = $this->getMockForAbstractClass(Target::class);
176			$logger->setTargets([$target]);
177
178			$this->assertEquals([$target], $logger->getTargets());
179			$this->assertSame($target, $logger->getTargets()[0]);
180			}
181
182			/**
183			* @depends testSetupTarget
184			*
185			* @covers \Yiisoft\Log\Logger::addTarget()
186			*/
187			public function testAddTarget(): void
188			{
189			$logger = new Logger();
190
191			$target = $this->getMockForAbstractClass(Target::class);
192			$logger->setTargets([$target]);
193
194			$namedTarget = $this->getMockForAbstractClass(Target::class);
195			$logger->addTarget($namedTarget, 'test-target');
196
197			$targets = $logger->getTargets();
198			$this->assertCount(2, $targets);
199			$this->assertTrue(isset($targets['test-target']));
200			$this->assertSame($namedTarget, $targets['test-target']);
201
202			$namelessTarget = $this->getMockForAbstractClass(Target::class);
203			$logger->addTarget($namelessTarget);
204			$targets = $logger->getTargets();
205			$this->assertCount(3, $targets);
206			$this->assertSame($namelessTarget, array_pop($targets));
207			}
208
209			/**
210			* Data provider for [[testParseMessage()]]
211			* @return array test data.
212			*/
213			public function dataProviderParseMessage(): array
214			{
215			return [
216			[
217			'no placeholder',
218			['foo' => 'some'],
219			'no placeholder',
220			],
221			[
222			'has {foo} placeholder',
223			['foo' => 'some'],
224			'has some placeholder',
225			],
226			[
227			'has {foo} placeholder',
228			[],
229			'has {foo} placeholder',
230			],
231			];
232			}
233
234			/**
235			* @depends testLog
236			* @dataProvider dataProviderParseMessage
237			*
238			* @covers \Yiisoft\Log\Logger::parseMessage()
239			*
240			* @param string $message
241			* @param array $context
242			* @param string $expected
243			*/
244			public function testParseMessage(string $message, array $context, string $expected): void
245			{
246			$this->logger->log(LogLevel::INFO, $message, $context);
247			$messages = $this->getInaccessibleProperty($this->logger, 'messages');
248			[, $message] = $messages[0];
249			$this->assertEquals($expected, $message);
250			}
251			}
252

yiisoft / log

Push — master ( 61f3a0...6b4c98 )

LoggerTest::dataProviderParseMessage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like