RelativeNamespaceDiscoveryTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	testGetClasses()	0	13	1
A	testConvertPathToNamespace()	0	6	1
A	testConvertPathToNamespaceData()	0	9	1
A	testConvertNamespaceToPath()	0	6	1
A	testConvertNamespaceToPathData()	0	8	1
A	callProtected()	0	6	1

<?php

use Robo\ClassDiscovery\RelativeNamespaceDiscovery;
use Composer\Autoload\ClassLoader;

/**
 * Class RelativeNamespaceDiscoveryTest
 */
class RelativeNamespaceDiscoveryTest extends \Codeception\Test\Unit

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    public function testGetClasses()
    {
        $classLoader = new ClassLoader();
        $classLoader->addPsr4('\\Robo\\', [realpath(__DIR__.'/../../src')]);

        $discovery = new RelativeNamespaceDiscovery('\Commands');
        $discovery->setClassLoader($classLoader);

        $classes = $discovery->getClasses();

        $this->assertContains('\Robo\FirstCustomCommands', $classes);
        $this->assertContains('\Robo\SecondCustomCommands', $classes);
    }

    /**
     * @dataProvider testConvertPathToNamespaceData
     *
     * @param $path
     * @param $expected
     */
    public function testConvertPathToNamespace($path, $expected)
    {
        $discovery = new RelativeNamespaceDiscovery('');
        $actual = $this->callProtected($discovery, 'convertPathToNamespace', [$path]);
        $this->assertEquals($expected, $actual);
    }

    public function testConvertPathToNamespaceData()
    {
        return [
          ['/A/B/C', 'A\B\C'],
          ['A/B/C', 'A\B\C'],
          ['A/B/C', 'A\B\C'],
          ['A/B/C.php', 'A\B\C'],
        ];
    }

    /**
     * @dataProvider testConvertNamespaceToPathData
     *
     * @param $namespace
     * @param $expected
     */
    public function testConvertNamespaceToPath($namespace, $expected)
    {
        $discovery = new RelativeNamespaceDiscovery('');
        $actual = $this->callProtected($discovery, 'convertNamespaceToPath', [$namespace]);
        $this->assertEquals($expected, $actual);
    }

    public function testConvertNamespaceToPathData()
    {
        return [
          ['A\B\C', '/A/B/C'],
          ['\A\B\C\\', '/A/B/C'],
          ['A\B\C\\', '/A/B/C'],
        ];
    }

    function callProtected($object, $method, $args = [])

It is generally recommended to explicitly declare the visibility for methods.

    {
        $r = new \ReflectionMethod($object, $method);
        $r->setAccessible(true);
        return $r->invokeArgs($object, $args);
    }
}