Particletree\Pqp\PhpQuickProfilerTest

Complexity

Total Complexity

26

Size/Duplication

Total Lines	338
Duplicated Lines	9.47 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	10
Bugs	1	Features	8

23 Methods

Rating	Name	Duplication	Size	Complexity
A	tearDownAfterClass()	0	4	1
A	setUpBeforeClass()	0	20	1
A	testConstruct()	0	10	1
A	testSetConsole()	8	8	1
A	testSetDisplay()	0	8	1
A	testGatherFileData()	0	16	2
A	testGatherMemoryData()	0	14	1
A	testSetProfiledQueries()	0	8	1
B	testGatherQueryData()	0	27	3
A	testGatherQueryDataInternalProfiler()	0	10	1
A	testExplainQuery()	0	12	1
A	testExplainQueryBadQueryException()	0	11	1
A	testExplainQueryBadParametersException()	12	12	1
A	testGetExplainQuery()	0	15	1
A	testGetExplainQueryUnsupportedDriver()	12	12	1
A	testGatherSpeedData()	0	15	1
B	testDisplay()	0	30	1
A	testDisplayNothingSetException()	0	5	1
A	testDisplayNoConsoleException()	0	7	1
A	testDisplayNoDisplayException()	0	7	1
A	dataProfiledQueries()	0	15	1
A	dataConnectionDrivers()	0	13	1
A	getAccessibleMethod()	0	7	1

<?php

namespace Particletree\Pqp;

use PHPUnit_Framework_Testcase;
use ReflectionClass;

class PhpQuickProfilerTest extends PHPUnit_Framework_TestCase
{

    protected static $dbConnection;

    public static function setUpBeforeClass()
    {
        self::$dbConnection = new LoggingPdo('sqlite::memory:');
        $createTable = "
            CREATE TABLE IF NOT EXISTS `testing` (
                `id` integer PRIMARY KEY AUTOINCREMENT,
                `title` varchar(60) NOT NULL
            );";
        self::$dbConnection->exec($createTable);

        $hydrateTable = "
            INSERT INTO `testing`
                (`title`)
            VALUES
                ('alpha'),
                ('beta'),
                ('charlie'),
                ('delta');";
        self::$dbConnection->exec($hydrateTable);
    }

    public function testConstruct()
    {
        $startTime = microtime(true);

        $profiler = new PhpQuickProfiler();
        $this->assertAttributeEquals($startTime, 'startTime', $profiler);

        $profiler = new PhpQuickProfiler($startTime);
        $this->assertAttributeEquals($startTime, 'startTime', $profiler);
    }

    public function testSetConsole()
    {
        $console = new Console();
        $profiler = new PhpQuickProfiler();
        $profiler->setConsole($console);

        $this->assertAttributeSame($console, 'console', $profiler);
    }

    public function testSetDisplay()
    {
        $display = new Display();
        $profiler = new PhpQuickProfiler();
        $profiler->setDisplay($display);

        $this->assertAttributeSame($display, 'display', $profiler);
    }

    public function testGatherFileData()
    {
        $files = get_included_files();
        $profiler = new PhpQuickProfiler();
        $gatheredFileData = $profiler->gatherFileData();

        $this->assertInternalType('array', $gatheredFileData);
        $this->assertEquals(count($files), count($gatheredFileData));
        foreach ($gatheredFileData as $fileData) {
            $this->assertInternalType('array', $fileData);
            $this->assertArrayHasKey('name', $fileData);
            $this->assertContains($fileData['name'], $files);
            $this->assertArrayHasKey('size', $fileData);
            $this->assertEquals($fileData['size'], filesize($fileData['name']));
        }
    }

    public function testGatherMemoryData()
    {
        $memoryUsage = memory_get_peak_usage();
        $allowedLimit = ini_get('memory_limit');
        $profiler = new PhpQuickProfiler();
        $gatheredMemoryData = $profiler->gatherMemoryData();

        $this->assertInternalType('array', $gatheredMemoryData);
        $this->assertEquals(2, count($gatheredMemoryData));
        $this->assertArrayHasKey('used', $gatheredMemoryData);
        $this->assertEquals($memoryUsage, $gatheredMemoryData['used']);
        $this->assertArrayHasKey('allowed', $gatheredMemoryData);
        $this->assertEquals($allowedLimit, $gatheredMemoryData['allowed']);
    }

    public function testSetProfiledQueries()
    {
        $profiledQueries = $this->dataProfiledQueries();
        $profiler = new PhpQuickProfiler();
        $profiler->setProfiledQueries($profiledQueries);

        $this->assertAttributeEquals($profiledQueries, 'profiledQueries', $profiler);
    }

    public function testGatherQueryData()
    {
        $profiledQueries = $this->dataProfiledQueries();
        $profiledQueriesSql = array();
        $profiledQueriesTime = array();
        foreach ($profiledQueries as $queryData) {
            array_push($profiledQueriesSql, $queryData['sql']);
            array_push($profiledQueriesTime, $queryData['time']);
        }

        $profiler = new PhpQuickProfiler();
        $profiler->setProfiledQueries($profiledQueries);
        $gatheredQueryData = $profiler->gatherQueryData(self::$dbConnection);

        $this->assertInternalType('array', $gatheredQueryData);
        $this->assertEquals(count($profiledQueries), count($gatheredQueryData));
        foreach ($gatheredQueryData as $queryData) {
            $this->assertInternalType('array', $queryData);
            $this->assertArrayHasKey('sql', $queryData);
            $this->assertContains($queryData['sql'], $profiledQueriesSql);
            $this->assertArrayHasKey('explain', $queryData);
            $this->assertInternaltype('array', $queryData['explain']);
            $this->assertGreaterThan(0, count($queryData['explain']));
            $this->assertArrayHasKey('time', $queryData);
            $this->assertContains($queryData['time'], $profiledQueriesTime);
        }
    }

    public function testGatherQueryDataInternalProfiler()
    {
        $profiledQueries = $this->dataProfiledQueries();
        $dbConnection = self::$dbConnection;
        $dbConnection->queries = $profiledQueries;
        $profiler = new PhpQuickProfiler();
        $profiler->gatherQueryData($dbConnection);

        $this->assertAttributeSame($profiledQueries, 'profiledQueries', $profiler);
    }

    /**
     * @dataProvider dataProfiledQueries
     */
    public function testExplainQuery($sql, $parameters)
    {
        $profiler = new PhpQuickProfiler();
        $reflectedMethod = $this->getAccessibleMethod($profiler, 'explainQuery');

        $explainedQuery = $reflectedMethod->invokeArgs(
            $profiler,
            array(self::$dbConnection, $sql, $parameters)
        );
        $this->assertInternalType('array', $explainedQuery);
        $this->assertGreaterThan(0, count($explainedQuery));
    }

    /**
     * @expectedException Exception
     */
    public function testExplainQueryBadQueryException()
    {
        $invalidQuery = 'SELECT * FROM `fake_table`';
        $profiler = new PhpQuickProfiler();
        $reflectedMethod = $this->getAccessibleMethod($profiler, 'explainQuery');

        $reflectedMethod->invokeArgs(
            $profiler,
            array(self::$dbConnection, $invalidQuery)
        );
    }

    /**
     * @expectedException Exception
     */
    public function testExplainQueryBadParametersException()
    {
        $query = 'SELECT * FROM `testing` WHERE `title` = :title';
        $invalidParams = array('id' => 1);
        $profiler = new PhpQuickProfiler();
        $reflectedMethod = $this->getAccessibleMethod($profiler, 'explainQuery');

        $reflectedMethod->invokeArgs(
            $profiler,
            array(self::$dbConnection, $query, $invalidParams)
        );
    }

    /**
     * @dataProvider dataConnectionDrivers
     */
    public function testGetExplainQuery($driver, $prefix)
    {
        $query = 'SELECT * FROM `testing`';
        $profiler = new PhpQuickProfiler();
        $reflectedMethod = $this->getAccessibleMethod($profiler, 'getExplainQuery');

        $explainQuery = $reflectedMethod->invokeArgs(
            $profiler,
            array($query, $driver)
        );

        $explainPrefix = str_replace($query, '', $explainQuery);
        $explainPrefix = trim($explainPrefix);
        $this->assertEquals($prefix, $explainPrefix);
    }

    /**
     * @expectedException Exception
     */
    public function testGetExplainQueryUnsupportedDriver()
    {
        $query = 'SELECT * FROM `testing`';
        $unsupportedDriver = 'zz';
        $profiler = new PhpQuickProfiler();
        $reflectedMethod = $this->getAccessibleMethod($profiler, 'getExplainQuery');

        $reflectedMethod->invokeArgs(
            $profiler,
            array($query, $unsupportedDriver)
        );
    }

    public function testGatherSpeedData()
    {
        $elapsedTime = 1.234;
        $startTime = microtime(true) - $elapsedTime;
        $allowedTime = ini_get('max_execution_time');
        $profiler = new PhpQuickProfiler($startTime);
        $gatheredSpeedData = $profiler->gatherSpeedData();

        $this->assertInternalType('array', $gatheredSpeedData);
        $this->assertEquals(2, count($gatheredSpeedData));
        $this->assertArrayHasKey('elapsed', $gatheredSpeedData);
        $this->assertEquals($elapsedTime, $gatheredSpeedData['elapsed']);
        $this->assertArrayHasKey('allowed', $gatheredSpeedData);
        $this->assertEquals($allowedTime, $gatheredSpeedData['allowed']);
    }

    public function testDisplay()
    {
        $console = new Console();
        $profiler = new PhpQuickProfiler();

        $reflectedProfiler = new ReflectionClass(get_class($profiler));
        $reflectedProperty = $reflectedProfiler->getProperty('startTime');
        $reflectedProperty->setAccessible(true);
        $startTime = $reflectedProperty->getValue($profiler);

        $expectedDisplay = new Display();
        $expectedDisplay->setStartTime($startTime);
        $expectedDisplay->setConsole($console);
        $expectedDisplay->setFileData($profiler->gatherFileData());
        $expectedDisplay->setMemoryData($profiler->gatherMemoryData());
        $expectedDisplay->setQueryData($profiler->gatherQueryData());
        $expectedDisplay->setSpeedData($profiler->gatherSpeedData());
        ob_start();
        $expectedDisplay->__invoke();
        ob_end_clean();

        $display = new Display();
        $profiler->setConsole($console);
        $profiler->setDisplay($display);
        ob_start();
        $profiler->display();
        ob_end_clean();

        $this->assertAttributeEquals($expectedDisplay, 'display', $profiler);
    }

    /**
     * @expectedException Exception
     */
    public function testDisplayNothingSetException()
    {
        $profiler = new PhpQuickProfiler();
        $profiler->display();
    }

    /**
     * @expectedException Exception
     */
    public function testDisplayNoConsoleException()
    {
        $display = new Display();
        $profiler = new PhpQuickProfiler();
        $profiler->setDisplay($display);
        $profiler->display();
    }

    /**
     * @expectedException Exception
     */
    public function testDisplayNoDisplayException()
    {
        $console = new Console();
        $profiler = new PhpQuickProfiler();
        $profiler->setConsole($console);
        $profiler->display();
    }

    public function dataProfiledQueries()
    {
        return array(
            array(
              'sql' => "SELECT * FROM testing",
              'parameters' => array(),
              'time' => 25
            ),
            array(
              'sql' => "SELECT id FROM testing WHERE title = :title",
              'parameters' => array('title' => 'beta'),
              'time' => 5
            )
        );
    }

    public function dataConnectionDrivers()
    {
        return array(
            array(
                'driver' => 'mysql',
                'prefix' => 'EXPLAIN'
            ),
            array(
                'driver' => 'sqlite',
                'prefix' => 'EXPLAIN QUERY PLAN'
            )
        );
    }

    protected function getAccessibleMethod(PhpQuickProfiler $profiler, $methodName)
    {
        $reflectedConsole = new ReflectionClass(get_class($profiler));
        $reflectedMethod = $reflectedConsole->getMethod($methodName);
        $reflectedMethod->setAccessible(true);
        return $reflectedMethod;
    }

    public static function tearDownAfterClass()
    {
        self::$dbConnection = null;
    }
}