Subreality\Dilmun\Nabu\StaticLoggerTest

Complexity

Total Complexity

18

Size/Duplication

Total Lines	201
Duplicated Lines	36.32 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

<?php
class StaticLoggerTest extends \PHPUnit_Framework_TestCase
{
    public static $full_log_location;

    /**
     * @var File
     */
    public static $log_file;

    public static function setUpBeforeClass()
    {
        self::$full_log_location = DILMUN_LOGS_DIR . "StaticLogger_test.log";

        if(file_exists(self::$full_log_location))
        {
            unlink(self::$full_log_location);
        }

        self::$log_file = new File(self::$full_log_location);
        self::$log_file->initialize();
    }

    protected function assertPreconditions()
    {
        $this->assertFileExists(self::$full_log_location);
    }

    protected function setUp()
    {
        if(file_exists(self::$full_log_location))
        {
            self::$log_file->clearFile();
        }
    }

    protected function tearDown()
    {
    }

    public static function tearDownAfterClass()
    {
        if(file_exists(self::$full_log_location))
        {
            unlink(self::$full_log_location);
        }
    }

    public function testLogToFileWithFileHandler()
    {
        static_logger::setHandler(self::$log_file);

        $returned_message = static_logger::log("debug", "Test successful.");

        $logged_message = file_get_contents(self::$full_log_location);

        $this->assertContains($returned_message, $logged_message);
    }

    /**
     * @expectedException InvalidArgumentException
     */
    public function testInvalidLogLevelThrowsException()
    {
        static_logger::log("not_a_log_level", "This message should never be logged!");
    }

    /**
     * @dataProvider validLevelProvider
     */
    public function testLogCallStaticLogsMessagesBasedOnValidLogLevels($level)
    {
        static_logger::setHandler(self::$log_file);

        //This generates a PhpStorm error but is valid code
        $returned_message = static_logger::{$level}("This is a {$level} log entry.");

        $logged_message = file_get_contents(self::$full_log_location);

        $this->assertContains($returned_message, $logged_message);
    }

    public function testLoggingWithPsrContextArrayWithString()
    {
        static_logger::setHandler(self::$log_file);

        $context_array = array(
            "context" =>    "stuff"
        );

        $expected_context_message = "Here is some stuff for ya.";

        $returned_message = static_logger::log("debug","Here is some {context} for ya.",$context_array);

        $this->assertContains($expected_context_message, $returned_message);
    }

    /**
     * @dataProvider contextArrayProvider
     */
    public function testLoggingWithPsrContextArrayWithUnparsedThings($context_array)
    {
        static_logger::setHandler(self::$log_file);

        //Provided contexts that do not adhere to PSR-3 templating, the log method should write the message without
        //affecting the {context} section and not throw any exceptions.
        $expected_context_message = "Here is some {context} for ya.";

        $returned_message = static_logger::log("debug","Here is some {context} for ya.",$context_array);

        $this->assertContains($expected_context_message, $returned_message);
    }

    public function testLoggingWithExceptionContext()
    {
        static_logger::setHandler(self::$log_file);

        try{
            throw new \Exception("This is an arbitrary exception");
        }
        catch (\Exception $e)
        {
            $context_array = array(
                "exception" =>  $e
            );
        }

        //Not testing {line} because it's too volatile.
        $log_message = "The Exception processor provides line, file ({file}), and message ({message})";

        $expected_context_message = 'The Exception processor provides line, file (/home/derek/PHP/Subreality/Dilmun/tests/Nabu/StaticLoggerTest.php), and message (This is an arbitrary exception)';

        $returned_message = static_logger::log("debug",$log_message,$context_array);

        $this->assertContains($expected_context_message, $returned_message);
    }

    /**
     * @expectedException \PHPUnit_Framework_Error
     */
    public function testLoggingWithNonArrayContext()
    {
        static_logger::setHandler(self::$log_file);

        $context_array = 4;

        //Provided contexts that do not adhere to PSR-3 templating, the log method should write the message without
        //affecting the {context} section and not throw any exceptions.
        $expected_context_message = "Here is some {context} for ya.";

        $returned_message = static_logger::log("debug","Here is some {context} for ya.",$context_array);

        $this->assertContains($expected_context_message, $returned_message);
    }

    /**
     * Provides data for testing valid log levels.
     *
     * @return array
     */
    public function validLevelProvider()
    {
        return array(
            array("emergency"),
            array("alert"),
            array("critical"),
            array("error"),
            array("warning"),
            array("notice"),
            array("info"),
            array("debug"),
        );
    }

    public function contextArrayProvider()
    {
        return array(
            array(
                array(
                    3,
                    2,
                    1
                )
            ),
            array(
                array(
                    self::$log_file
                )
            ),
            array(
                array(
                    "unparsed string"
                )
            ),
            array(
                array(
                    "stuff" =>  "context"
                )
            )
        );
    }
}