ApplicationTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	_before()	0	15	2
A	testTaskAccessor()	0	19	1
A	testAllowEmptyValuesAsDefaultsToOptionalOptions()	0	14	1
A	testCommandDocumentation()	0	8	1
A	testCommandCompactDocumentation()	0	8	1
A	testCommandArgumentDocumentation()	0	16	1
A	testCommandOptionDocumentation()	0	10	1
A	testCommandHelpDocumentation()	0	8	1
A	testCommandNaming()	0	4	1
A	createCommand()	0	5	1

<?php
require_once codecept_data_dir() . 'TestedRoboFile.php';

use Robo\Robo;
use Consolidation\AnnotatedCommand\Parser\CommandInfo;
use Robo\Collection\CollectionBuilder;

class ApplicationTest extends \Codeception\TestCase\Test
{
    /**
     * @var \Robo\Runner
     */
    private $runner;

    /**
     * @var \Robo\Application
     */
    private $app;

    /**
     * @var Consolidation\AnnotatedCommand\AnnotatedCommandFactory
     */
    private $commandFactory;

    /**
     * @var TestRoboFile
     */
    private $roboCommandFileInstance;

    protected function _before()
    {
        $container = Robo::createDefaultContainer();

        $this->app = $container->get('application');
        $config = $container->get('config');

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

        $this->commandFactory = $container->get('commandFactory');
        $this->roboCommandFileInstance = new TestedRoboFile;

It seems like new \TestedRoboFile() of type object<TestedRoboFile> is incompatible with the declared type object<TestRoboFile> of property $roboCommandFileInstance.

        $builder = CollectionBuilder::create($container, $this->roboCommandFileInstance);
        $this->roboCommandFileInstance->setBuilder($builder);
        $commandList = $this->commandFactory->createCommandsFromClass($this->roboCommandFileInstance);
        foreach ($commandList as $command) {
            $this->app->add($command);
        }
    }

    public function testTaskAccessor()
    {
        // Get a reference to the protected 'task' method, as
        // this is normally only callable by methods of the
        // commandfile instance.
        $method = new ReflectionMethod($this->roboCommandFileInstance, 'task');
        $method->setAccessible(true);
        $collectionBuilder = $method->invoke($this->roboCommandFileInstance, 'Robo\Task\Base\Exec', 'ls');
        $this->assertEquals(
            'Robo\Collection\CollectionBuilder',
            get_class($collectionBuilder));
        $task = $collectionBuilder->getCollectionBuilderCurrentTask();
        $this->assertEquals(
            'Robo\Task\Base\Exec',
            get_class($task));
        $this->assertEquals(
            'Robo\Task\Base\Exec',
            get_class($task));
    }

    public function testAllowEmptyValuesAsDefaultsToOptionalOptions()
    {
        $command = $this->createCommand('hello');

        $yell = $command->getDefinition()->getOption('yell');

        $this->assertFalse($yell->isValueOptional());
        $this->assertFalse($yell->getDefault());

        $to = $command->getDefinition()->getOption('to');

        $this->assertTrue($to->isValueOptional());
        $this->assertNull($to->getDefault());
    }

    public function testCommandDocumentation()
    {
        $command = $this->createCommand('fibonacci');

        $this->assertEquals(
            'Calculate the fibonacci sequence between two numbers.',
            $command->getDescription());
    }

    public function testCommandCompactDocumentation()
    {
        $command = $this->createCommand('compact');

        $this->assertEquals(
            'Compact doc comment',
            $command->getDescription());
    }

    public function testCommandArgumentDocumentation()
    {
        $command = $this->createCommand('fibonacci');

        $start = $command->getDefinition()->getArgument('start');

        $this->assertEquals(
            'Number to start from',
            $start->getDescription());

        $steps = $command->getDefinition()->getArgument('steps');

        $this->assertEquals(
            'Number of steps to perform',
            $steps->getDescription());
    }

    public function testCommandOptionDocumentation()
    {
        $command = $this->createCommand('fibonacci');

        $graphic = $command->getDefinition()->getOption('graphic');

        $this->assertEquals(
            'Display the sequence graphically using cube representation',
            $graphic->getDescription());
    }

    public function testCommandHelpDocumentation()
    {
        $command = $this->createCommand('fibonacci');

        $this->assertContains(
            '+----+---+',
            $command->getHelp());
    }

    public function testCommandNaming()
    {
        $this->assertNotNull($this->app->find('generate:user-avatar'));
    }

    protected function createCommand($name)
    {
        $commandInfo = new CommandInfo($this->roboCommandFileInstance, $name);
        return $this->commandFactory->createCommand($commandInfo, $this->roboCommandFileInstance);
    }
}