KochTest\Autoload\LoaderTest

Complexity

Total Complexity

26

Size/Duplication

Total Lines	255
Duplicated Lines	25.88 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	3
Bugs	2	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	18	2
A	tearDown()	0	4	1
A	apcClearCache()	0	6	4
A	testMethodautoloadExclusions()	0	19	1
A	testMethodautoloadInclusions()	0	9	1
A	testMethodautoloadByApcOrFileMap()	0	8	1
A	testMethodwriteAutoloadingMapApc()	0	10	2
A	testMethodreadAutoloadingMapApc()	0	8	2
A	testMethodaddMapping()	22	22	1
A	testMethodincludeFile()	0	14	1
A	testsetInclusionMap()	0	6	1
A	testMethodautoload()	0	22	2
A	testMethodconstruct()	0	17	1
A	testMethodautoloadIncludePath()	0	12	1
A	testMethodwriteAutoloadingMapFile()	14	14	2
A	testMethodreadAutoloadingMapFile()	13	13	2
A	testMethodincludeFileAndMap()	17	17	1

<?php

namespace KochTest\Autoload;

use Koch\Autoload\Loader;

/**
 * Interface and Class definition for testing
 * the autoload skipping, when "already loaded".
 */
interface ThisInterfaceExists

ThisInterfaceExists does not seem to conform to the naming convention (^[A-Z][a-zA-Z0-9]*Interface$).

{
}

class ThisClassExists

Each interface must be in a file by itself

{
}

class LoaderTest extends \PHPUnit_Framework_TestCase

PSR1 recommends that each class should be in its own file to aid autoloaders.

{
    public $classMapFile = 'autoloader.classmap.php';

    public function setUp()
    {
        parent::setUp();

        // add Fixtures folder, only if not already on the include_path
        $path = realpath(__DIR__ . '/fixtures');
        if (strpos(get_include_path(), $path) === false) {
            set_include_path($path . PATH_SEPARATOR . get_include_path());
        }

        /*
         * The APC user cache needs a reset, so that the map is generated freshly each run.
         * APC is used by readAutoloadingMapApc() / writeAutoloadingMapApc().
         */
        self::apcClearCache();

        Loader::setClassMapFile($this->classMapFile);
    }

    public function tearDown()
    {
        self::apcClearCache();
    }

    public static function apcClearCache()
    {
        if (extension_loaded('apc') and ini_get('apc.enabled') and ini_get('apc.enable_cli')) {

Using logical operators such as and instead of && is generally not recommended.

            apc_clear_cache('user');
        }
    }

    /**
     * testMethodautoload().
     */
    public function testMethodautoload()
    {
        // workflow of autoloading

        // 1. existing class
        $this->assertFalse(Loader::autoload('ThisClassExists'));
        // 2. existing interface
        $this->assertFalse(Loader::autoload('ThisInterfaceExists'));
        // 3. existing trait
        if (PHP_VERSION_ID <= 50400) {
            $this->assertFalse(Loader::autoload('ClassADefinesTraitA'));
        }
        // PHP 5.4.6 Bug... trait_exists does not return anything (true|false|null).

41% of this comment could be valid code. Did you maybe forget this after debugging?

        // So a "cannot redeclare class TraitA" fatal error is thrown.
        //$this->assertFalse(Loader::autoload('ClassBDefinesTraitA'));

75% of this comment could be valid code. Did you maybe forget this after debugging?

        // 1. autoloadExclusions()

50% of this comment could be valid code. Did you maybe forget this after debugging?

        // 2. autoloadInclusions()

50% of this comment could be valid code. Did you maybe forget this after debugging?

        // 3. autoloadByApcOrFileMap()

50% of this comment could be valid code. Did you maybe forget this after debugging?

        // 4. autoloadIncludePath()

50% of this comment could be valid code. Did you maybe forget this after debugging?

        // 5. autoloadTryPathsAndMap()

50% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    public function testMethodconstruct()
    {
        // unregister first (autoloader was registered during test setup)
        $r = spl_autoload_unregister(['Koch\Autoload\Loader', 'autoload']);

$r is not used, you could remove the assignment.

        // registers autoloader via constructor
        new Loader();

         // test Koch Framework Autoloader is registered in the spl_autoloader_stack at first place
        $registered_autoloaders = spl_autoload_functions();

$registered_autoloaders does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $this->assertTrue(is_string($registered_autoloaders[0][0]));

$registered_autoloaders does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $this->assertFalse(is_object($registered_autoloaders[0][0]));

$registered_autoloaders does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $this->assertEquals('Koch\Autoload\Loader', $registered_autoloaders[0][0]);

$registered_autoloaders does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

        $this->assertEquals('autoload', $registered_autoloaders[0][1]);

$registered_autoloaders does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    }

    /**
     * testMethodautoloadExclusions().
     */
    public function testMethodautoloadExclusions()
    {
        // exclude "Smarty_Internal" classes
        $this->assertTrue(Loader::autoloadExclusions('Smarty_Internal_SomeClass'));

        // exclude "Doctrine" classes
        $this->assertTrue(Loader::autoloadExclusions('Doctrine_SomeClass'));
        $this->assertTrue(Loader::autoloadExclusions('Doctrine\SomeClass'));

        // but not, our own namespaced doctrine classes "Koch\Doctrine\"
        $this->assertFalse(Loader::autoloadExclusions('Koch\Doctrine\SomeClass'));
        $this->assertFalse(Loader::autoloadExclusions('Koch\Pagination\Adapter\Doctrine'));

        // exclude "Smarty" classes
        $this->assertTrue(Loader::autoloadExclusions('Smarty_'));

        // but not, our own smarty class "\Smarty"
        $this->assertFalse(Loader::autoloadExclusions('Koch\View\Renderer\Smarty'));
    }

    /**
     * testMethodautoloadInclusions().
     */
    public function testMethodautoloadInclusions()
    {
        // try to load an unknown class
        $this->assertFalse(Loader::autoloadInclusions('SomeUnknownClass'));

        // try to load "Application_Staging" class
        // no definitions atm
        #$this->assertTrue(Loader::autoloadInclusions('Application_Staging'));

75% of this comment could be valid code. Did you maybe forget this after debugging?

    }

    /**
     * testMethodautoloadByApcOrFileMap.
     */
    public function testMethodautoloadByApcOrFileMap()
    {
        // try to load an unknown class
        $this->assertFalse(Loader::autoloadByApcOrFileMap('SomeUnknownClass'));

        Loader::addMapping('Captcha', realpath(__DIR__ . '/../../../framework/Koch/Captcha/Captcha.php'));
        $this->assertTrue(Loader::autoloadByApcOrFileMap('Captcha'));
    }

    /**
     * testMethodautoloadIncludePath().
     */
    public function testMethodautoloadIncludePath()
    {
        // try to load an unknown class
        $this->assertFalse(Loader::autoloadIncludePath('\Namespace\Library\SomeUnknownClass'));

        // set the include path to our fixtures directory, where a namespaced class exists
        $path = __DIR__ . '/fixtures/Application';
        set_include_path($path . PATH_SEPARATOR . get_include_path());

        // try to load existing namespaced class
        $this->assertTrue(Loader::autoloadIncludePath('NamespacedClass'));
    }

    public function testMethodwriteAutoloadingMapFile()

This method seems to be duplicated in your project.

    {
        if (is_file($this->classMapFile)) {
            unlink($this->classMapFile);
        }

        // file will be created
        $this->assertSame([], Loader::readAutoloadingMapFile());
        $this->assertTrue(is_file($this->classMapFile));

        $array = ['class' => 'file'];
        $this->assertTrue(Loader::writeAutoloadingMapFile($array));
        $this->assertSame($array, Loader::readAutoloadingMapFile());
    }

    public function testMethodreadAutoloadingMapFile()

This method seems to be duplicated in your project.

    {
        if (is_file($this->classMapFile)) {
            unlink($this->classMapFile);
        }
        // file will be created
        $this->assertSame([], Loader::readAutoloadingMapFile());
        $this->assertTrue(is_file($this->classMapFile));

        $array = ['class' => 'file'];
        $this->assertTrue(Loader::writeAutoloadingMapFile($array));
        $this->assertSame($array, Loader::readAutoloadingMapFile());
    }

    public function testMethodwriteAutoloadingMapApc()
    {
        if (!extension_loaded('apc')) {
            $this->markTestSkipped('This test requires the PHP extension "apc".');
        }

        $array = ['class' => 'file'];
        $this->assertTrue(Loader::writeAutoloadingMapApc($array));
        $this->assertSame($array, Loader::readAutoloadingMapApc());
    }

    public function testMethodreadAutoloadingMapApc()
    {
        if (!extension_loaded('apc')) {
            $this->markTestSkipped(' This test requires the PHP extension "apc".');
        }

        $this->assertSame(apc_fetch('KF_CLASSMAP'), Loader::readAutoloadingMapApc());
    }

    public function testMethodaddMapping()

This method seems to be duplicated in your project.

    {
        $class = 'addToMappingClass';
        $file  = realpath(__DIR__ . '/fixtures/notloaded/addToMapping.php');

        $this->assertTrue(Loader::addMapping($class, $file));

        // test if the entry was added to the autoloader class map array
        $map = Loader::getAutoloaderClassMap();
        // entry exists
        $this->assertTrue(true, array_key_exists($class, $map));
        // compare entries
        $this->assertEquals($map[$class], $file);

        // file not loaded, just mapped
        #$this->assertFalse(class_exists($class, false));

77% of this comment could be valid code. Did you maybe forget this after debugging?

        // triggering autoload via class_exists
        // --- WARNING ---
        // The "Koch Framework Autoloader" needs to be registered BEFORE "Composers Autoloader".
        $this->assertTrue(class_exists($class, true));
    }

    public function testMethodincludeFileAndMap()

This method seems to be duplicated in your project.

    {
        $file  = realpath(__DIR__ . '/fixtures/includeFileAndMap.php');
        $class = 'includeFileAndMapClass';

        Loader::includeFileAndMap($file, $class);

        // test if the entry was added to the autoloader class map array
        $map = Loader::getAutoloaderClassMap();

        $this->assertTrue(true, array_key_exists($class, $map));

        $this->assertEquals($map[$class], $file);

        // file already loaded
        $this->assertTrue(class_exists($class, false));
    }

    public function testMethodincludeFile()
    {
        // a) include file
        $this->assertTrue(Loader::includeFile(__DIR__ . '/fixtures/ClassForRequireFile1.php'));

        // b) include class

43% of this comment could be valid code. Did you maybe forget this after debugging?

        $this->assertTrue(Loader::includeFile(__DIR__ . '/fixtures/ClassForRequireFile2.php', 'ClassForRequireFile2'));

        // c) include class (second parameter), but class does not exist
        $this->assertFalse(Loader::includeFile('nonExistantFile.php'), 'ThisClassDoesNotExist');

        // d) file not found returns false
        $this->assertFalse(Loader::includeFile('nonExistantFile.php'));
    }

    public function testsetInclusionMap()
    {
        $classmap = ['class' => 'file'];
        Loader::setInclusionsClassMap($classmap);
        $this->assertEquals(Loader::$inclusionsClassmap, $classmap);
    }
}