Subreality\Dilmun\Tests\Nabu\LoggerHandler\FileTest

Complexity

Total Complexity

23

Size/Duplication

Total Lines	262
Duplicated Lines	13.36 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes	1
Bugs	0	Features	0

<?php
class FileTest extends \PHPUnit_Framework_TestCase
{
    public static $full_log_location;
    public static $log_file_name;
    public static $log_file_path;

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

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

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

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

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

    public function testGettingSetFileName()
    {
        $some_file = new File();

        $some_file->setFileName(self::$log_file_name);

        $result_file_name = $some_file->getFileName();

        $this->assertEquals(self::$log_file_name, $result_file_name);
    }

    public function testGettingSetFilePath()
    {
        $some_file = new File();

        $some_file->setFilePath(self::$log_file_path);

        $trimmed_file_path = rtrim(self::$log_file_path, '\/');

        $result_file_path = $some_file->getFilePath();

        $this->assertEquals($trimmed_file_path, $result_file_path);
    }

    public function testClearingFileOfContents()
    {
        $log_file = new File(self::$full_log_location);

        $log_file->initialize();

        $string_to_write = "This should be written to the log file!";

        $log_file->write($string_to_write);

        //Must call clearstatcache to report on file size accurately!
        clearstatcache();

        $written_file_size = filesize(self::$full_log_location);

        $this->assertGreaterThan(0, $written_file_size);

        $file_cleared = $log_file->clearFile();

        //Must call clearstatcache to report on file size accurately!
        clearstatcache();

        $cleared_file_size = filesize(self::$full_log_location);

        $this->assertTrue($file_cleared);
        $this->assertEquals(0, $cleared_file_size);
    }

    public function testClearFileReturnsFalseWhenFileNotInitialized()
    {
        $some_file = new File();

        $file_cleared = $some_file->clearFile();

        $this->assertFalse($file_cleared);
    }

    public function testFileInitializationCreatesFile()
    {
        $log_file = new File(self::$full_log_location);

        $log_file->initialize();

        $this->assertFileExists(self::$full_log_location);
    }

    public function testFileInitializationCreatesFileFromSeparateNameAndPath()
    {
        $log_file = new File();

        $log_file->setFileName(self::$log_file_name);
        $log_file->setFilePath(self::$log_file_path);

        $log_file->initialize();

        $this->assertFileExists(self::$full_log_location);
    }

    /**
     * @dataProvider badNameProvider
     */
    public function testFileInitiailizationReturnsFalseWhenAttemptingToInitializeWithBadData($bad_name)
    {
        $bad_file = new File($bad_name);

        $bad_file->suppressInitFailureMessage();

        $file_initialized = $bad_file->initialize();

        $this->assertFalse($file_initialized);
    }

    /**
     * @dataProvider badNameProvider
     */
    public function testWritingReturnsFalseWhenAttemptingToWriteToInvalidPointer($bad_name)
    {
        $bad_file = new File($bad_name);

        $bad_file->suppressInitFailureMessage();

        $bad_file->initialize();

        $write_succeeded = $bad_file->write("This should never be written!");

        $this->assertFalse($write_succeeded);
    }

    public function testWritingReturnsFalseWhenAttemptingToWriteToUninitializedFile()
    {
        $bad_file = new File();

        $write_succeeded = $bad_file->write("This should never be written!");

        $this->assertFalse($write_succeeded);
    }

    public function testSuppressingInitFailureMessageSetsDisplayInitFailureToFalse()
    {
        $stub_file = new File();

        $stub_file->suppressInitFailureMessage();

        $this->assertEquals(false, \PHPUnit_Framework_Assert::readAttribute($stub_file, "display_init_failure"));
    }

    public function testDisplayingInitFailureMessageSetsDisplayInitFailureToTrue()
    {
        $stub_file = new File();

        $stub_file->suppressInitFailureMessage();

        $this->assertEquals(false, \PHPUnit_Framework_Assert::readAttribute($stub_file, "display_init_failure"));

        $stub_file->displayInitFailureMessage();

        $this->assertEquals(true, \PHPUnit_Framework_Assert::readAttribute($stub_file, "display_init_failure"));
    }

    public function testSuppressingInitFailureMessagePreventsFailureMessage()
    {
        $expected_output = "";

        $stub_file = new File();

        $stub_file->suppressInitFailureMessage();

        $this->assertEquals(false, \PHPUnit_Framework_Assert::readAttribute($stub_file, "display_init_failure"));

        ob_start();

        $stub_file->initialize();

        $output = ob_get_contents();

        ob_end_clean();

        $this->assertEquals($expected_output, $output);
    }

    public function testDisplayingInitFailureMessageDisplaysFailureMessage()
    {
        $expected_output = "Cannot open specified log file for writing: : SplFileObject::__construct(): Filename cannot be empty\n";

        $this->expectOutputString($expected_output);

        $stub_file = new File();

        $stub_file->suppressInitFailureMessage();

        $this->assertEquals(false, \PHPUnit_Framework_Assert::readAttribute($stub_file, "display_init_failure"));

        $stub_file->displayInitFailureMessage();

        $this->assertEquals(true, \PHPUnit_Framework_Assert::readAttribute($stub_file, "display_init_failure"));

        $stub_file->initialize();
    }

    public function testSendInitFailureEmailAddressSetsPrivateEmailAddress()
    {
        $email_address = "email@some.one";

        $stub_file = new File();

        $stub_file->sendInitFailureEmailAddress($email_address);

        $this->assertEquals($email_address, \PHPUnit_Framework_Assert::readAttribute($stub_file, "init_failure_email_address"));
    }

    public function testSendInitFailureEmailAddressSetAttemptsToSendErrorEmail()
    {
        $email_address = "email@some.one";

        $stub_file = new File();

        $stub_file->sendInitFailureEmailAddress($email_address);

        $this->assertEquals($email_address, \PHPUnit_Framework_Assert::readAttribute($stub_file, "init_failure_email_address"));

        $stub_file->suppressInitFailureMessage();

        $stub_file->initialize();
    }

    /**
     * Data provider of invalid file names.
     *
     * @return array
     */
    public function badNameProvider()
    {
        return array(
            array(""),
            array('t|-|1$is/IN\/@L1d!'),
            array(self::$log_file_path)
        );
    }
}