N98\Util\AutoloadHandlerTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	160
Duplicated Lines	11.25 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	tearDown()	0	8	2
A	creation()	0	6	1
A	noRegistrationOnCreation()	0	15	1
A	create()	0	7	1
A	registrationAndDeregistration()	6	18	1
A	changingCallback()	6	22	1
A	disablingAndEnabling()	0	10	1
A	callbackSelfReference()	0	15	1
A	cleanupCallback()	6	20	1

<?php
/**
 * this file is part of magerun
 *
 * @author Tom Klingenberg <https://github.com/ktomk>
 */

namespace N98\Util;

/**
 * Class AutoloadHandlerTest
 *
 * @covers \N98\Util\AutoloadHandler
 * @package N98\Util
 */
class AutoloadHandlerTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var array
     */
    private $cleanup = array();

    public function tearDown()
    {
        foreach ($this->cleanup as $key => $task) {
            $task();
            unset($this->cleanup[$key]);
        }
        parent::tearDown();
    }

    /**
     * @test
     */
    public function creation()
    {
        $handler = $this->create(null);
        $this->assertInstanceOf(__NAMESPACE__ . '\AutoloadHandler', $handler);
        $this->assertInternalType('callable', $handler);
    }

    /**
     * @test
     * @expectedException \BadMethodCallException
     * @expectedExceptionMessage Autoload callback is not callable
     */
    public function noRegistrationOnCreation()
    {
        $handler = $this->create(null, AutoloadHandler::NO_AUTO_REGISTER);
        $handler->disable(); // assertions require a disabled handler b/c of exceptions

        $this->assertFalse(in_array($handler, spl_autoload_functions()));
        $this->assertFalse($handler->__invoke('test'));
        $handler->register();
        $actual = in_array($handler, spl_autoload_functions());
        $this->assertTrue($actual);

        $handler->enable();
        $handler->__invoke('test');
        $this->fail('An expected exception was not thrown');
    }

    private function create($implementation, $flags = null)
    {
        $handler = AutoloadHandler::create($implementation, $flags);
        $this->cleanup[] = $handler->getCleanupCallback();

        return $handler;
    }

    /**
     * @test
     */
    public function registrationAndDeregistration()
    {
        $calls = (object) array('retval' => true);
        $assertAble = function ($className) use (&$calls) {

This code seems to be duplicated across your project.

            $calls->log[] = array($className);
            $calls->count[$className] = 1 + @$calls->count[$className];

            return $calls->retval;
        };

        $handler = $this->create($assertAble);
        $this->assertTrue($handler->isEnabled());
        $this->assertTrue($handler->__invoke("Fake"));

        $handler->unregister();
        $this->assertFalse($handler->__invoke("Fake"));
        $this->assertEquals(1, $calls->count['Fake']);
    }

    /**
     * @test
     */
    public function changingCallback()
    {
        $calls = (object) array('retval' => true);
        $assertAble = function ($className) use (&$calls) {

This code seems to be duplicated across your project.

            $calls->log[] = array($className);
            $calls->count[$className] = 1 + @$calls->count[$className];

            return $calls->retval;
        };

        $handler = $this->create(null, AutoloadHandler::NO_EXCEPTION);
        $this->assertFalse($handler->__invoke("Test"));
        $this->assertObjectNotHasAttribute('count', $calls);

        $handler->setCallback($assertAble);
        $this->assertTrue($handler->__invoke("Test"));
        $this->assertEquals(1, $calls->count["Test"]);

        $handler->setCallback(null);
        $this->assertFalse($handler->__invoke("Test"));
        $this->assertEquals(1, $calls->count["Test"]);
    }

    /**
     * @test
     */
    public function disablingAndEnabling()
    {
        $handler = $this->create(null);
        $handler->setEnabled(false);
        $this->assertFalse($handler->__invoke("Test"));
        $handler->setEnabled(true);
        $this->setExpectedException('BadMethodCallException');
        $this->assertFalse($handler->__invoke("Test"));
        $this->fail('An expected exception has not been thrown');
    }

    /**
     * @test
     */
    public function callbackSelfReference()
    {
        $testClass = 'MyOf' . mt_rand(1000, 9999) . 'Fake' . mt_rand(1000, 9999) . 'Class';
        $test = $this;
        $handler = $this->create(function ($className) use (&$handler, $test, $testClass) {
            /** @var $handler AutoloadHandler */
            $test->assertEquals($testClass, $className);
            $handler->disable();
        });
        $actual = class_exists($testClass);
        $isEnabled = $handler->isEnabled();
        $this->assertEquals(1, $this->getCount());
        $this->assertFalse($isEnabled);
        $this->assertFalse($actual);
    }

    /**
     * @test
     */
    public function cleanupCallback()
    {
        $calls = (object) array('retval' => true);
        $assertAble = function ($className) use (&$calls) {

This code seems to be duplicated across your project.

            $calls->log[] = array($className);
            $calls->count[$className] = 1 + @$calls->count[$className];

            return $calls->retval;
        };

        $handler = $this->create($assertAble, AutoloadHandler::NO_EXCEPTION);
        $cleanup = $handler->getCleanupCallback();
        $actual = class_exists('Test');
        $this->assertFalse($actual);
        $this->assertTrue(in_array($handler, spl_autoload_functions()), 'before cleanup');
        $cleanup();
        $this->assertFalse(in_array($handler, spl_autoload_functions()), 'after cleanup');
        // calling cleanup again must not do any warnings etc.
        $cleanup();
    }
}