/var/www/hkosl.com/littleark/webadmin/libraies/psr/log/Psr/Log/Test/LoggerInterfaceTest.php


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
<?php

namespace Psr\Log\Test;

use 
Psr\Log\LoggerInterface;
use 
Psr\Log\LogLevel;

/**
 * Provides a base test class for ensuring compliance with the LoggerInterface.
 *
 * Implementors can extend the class and implement abstract methods to run this
 * as part of their test suite.
 */
abstract class LoggerInterfaceTest extends \PHPUnit_Framework_TestCase
{
    
/**
     * @return LoggerInterface
     */
    
abstract public function getLogger();

    
/**
     * This must return the log messages in order.
     *
     * The simple formatting of the messages is: "<LOG LEVEL> <MESSAGE>".
     *
     * Example ->error('Foo') would yield "error Foo".
     *
     * @return string[]
     */
    
abstract public function getLogs();

    public function 
testImplements()
    {
        
$this->assertInstanceOf('Psr\Log\LoggerInterface'$this->getLogger());
    }

    
/**
     * @dataProvider provideLevelsAndMessages
     */
    
public function testLogsAtAllLevels($level$message)
    {
        
$logger $this->getLogger();
        
$logger->{$level}($message, array('user' => 'Bob'));
        
$logger->log($level$message, array('user' => 'Bob'));

        
$expected = array(
            
$level.' message of level '.$level.' with context: Bob',
            
$level.' message of level '.$level.' with context: Bob',
        );
        
$this->assertEquals($expected$this->getLogs());
    }

    public function 
provideLevelsAndMessages()
    {
        return array(
            
LogLevel::EMERGENCY => array(LogLevel::EMERGENCY'message of level emergency with context: {user}'),
            
LogLevel::ALERT => array(LogLevel::ALERT'message of level alert with context: {user}'),
            
LogLevel::CRITICAL => array(LogLevel::CRITICAL'message of level critical with context: {user}'),
            
LogLevel::ERROR => array(LogLevel::ERROR'message of level error with context: {user}'),
            
LogLevel::WARNING => array(LogLevel::WARNING'message of level warning with context: {user}'),
            
LogLevel::NOTICE => array(LogLevel::NOTICE'message of level notice with context: {user}'),
            
LogLevel::INFO => array(LogLevel::INFO'message of level info with context: {user}'),
            
LogLevel::DEBUG => array(LogLevel::DEBUG'message of level debug with context: {user}'),
        );
    }

    
/**
     * @expectedException \Psr\Log\InvalidArgumentException
     */
    
public function testThrowsOnInvalidLevel()
    {
        
$logger $this->getLogger();
        
$logger->log('invalid level''Foo');
    }

    public function 
testContextReplacement()
    {
        
$logger $this->getLogger();
        
$logger->info('{Message {nothing} {user} {foo.bar} a}', array('user' => 'Bob''foo.bar' => 'Bar'));

        
$expected = array('info {Message {nothing} Bob Bar a}');
        
$this->assertEquals($expected$this->getLogs());
    }

    public function 
testObjectCastToString()
    {
        if (
method_exists($this'createPartialMock')) {
            
$dummy $this->createPartialMock('Psr\Log\Test\DummyTest', array('__toString'));
        } else {
            
$dummy $this->getMock('Psr\Log\Test\DummyTest', array('__toString'));
        }
        
$dummy->expects($this->once())
            ->
method('__toString')
            ->
will($this->returnValue('DUMMY'));

        
$this->getLogger()->warning($dummy);

        
$expected = array('warning DUMMY');
        
$this->assertEquals($expected$this->getLogs());
    }

    public function 
testContextCanContainAnything()
    {
        
$context = array(
            
'bool' => true,
            
'null' => null,
            
'string' => 'Foo',
            
'int' => 0,
            
'float' => 0.5,
            
'nested' => array('with object' => new DummyTest),
            
'object' => new \DateTime,
            
'resource' => fopen('php://memory''r'),
        );

        
$this->getLogger()->warning('Crazy context data'$context);

        
$expected = array('warning Crazy context data');
        
$this->assertEquals($expected$this->getLogs());
    }

    public function 
testContextExceptionKeyCanBeExceptionOrOtherValues()
    {
        
$logger $this->getLogger();
        
$logger->warning('Random message', array('exception' => 'oops'));
        
$logger->critical('Uncaught Exception!', array('exception' => new \LogicException('Fail')));

        
$expected = array(
            
'warning Random message',
            
'critical Uncaught Exception!'
        
);
        
$this->assertEquals($expected$this->getLogs());
    }
}

class 
DummyTest
{
    public function 
__toString()
    {
    }
}