Sonata\EasyExtendsBundle\Tests\Command\GenerateCommandTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	1
Bugs	0	Features	1

12 Methods

Rating	Name	Duplication	Size	Complexity
A	testExecute()	0	10	1
B	executeData()	0	33	1
A	testExecuteWrongDest()	0	11	1
A	testNoArgument()	0	13	1
A	testFakeBundleName()	0	17	1
A	testNotExtendableBundle()	0	14	1
A	testInvalidFolderStructure()	0	16	1
A	buildCommand()	0	7	1
A	mockContainer()	0	10	1
A	mockContainerWithKernel()	0	11	1
A	mockKernel()	0	12	2
A	mockGenerator()	0	9	1

<?php

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\EasyExtendsBundle\Tests\Command;

use PHPUnit\Framework\TestCase;
use Sonata\AcmeBundle\SonataAcmeBundle;
use Sonata\EasyExtendsBundle\Command\GenerateCommand;
use Sonata\EasyExtendsBundle\Generator\GeneratorInterface;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Tester\CommandTester;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpKernel\KernelInterface;

/**
 * @author Marko Kunic <kunicmarko20@gmail.com>
 */
final class GenerateCommandTest extends TestCase
{
    /**
     * @dataProvider executeData
     */
    public function testExecute($args)
    {
        $commandTester = $this->buildCommand($this->mockContainer());
        $commandTester->execute($args);

        $this->assertContains(
            'done!',
            $commandTester->getDisplay()
        );
    }

    public function executeData()
    {
        return [
            [
                [
                    '--dest' => 'src',
                    'bundle' => ['SonataAcmeBundle'],
                ],
            ],
            [
                [
                    '--dest' => 'src',
                    'bundle' => ['SonataAcmeBundle'],
                    '--namespace' => 'Application\\Sonata',
                ],
            ],
            [
                [
                    '--dest' => 'src',
                    'bundle' => ['SonataAcmeBundle'],
                    '--namespace_prefix' => 'App',
                ],
            ],
            [
                [
                    '--dest' => 'src',
                    'bundle' => ['SonataAcmeBundle'],
                    '--namespace' => 'Application\\Sonata',
                    '--namespace_prefix' => 'App',
                ],
            ],
        ];
    }

    public function testExecuteWrongDest()
    {
        $commandTester = $this->buildCommand($this->createMock(ContainerInterface::class));

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage("The provided destination folder 'fakedest' does not exist!");

        $commandTester->execute([
            '--dest' => 'fakedest',
        ]);
    }

    public function testNoArgument()
    {
        $commandTester = $this->buildCommand($this->mockContainerWithKernel());

        $commandTester->execute([
            '--dest' => 'src',
        ]);

        $this->assertContains(
            'You must provide a bundle name!',
            $commandTester->getDisplay()
        );
    }

    public function testFakeBundleName()
    {
        $commandTester = $this->buildCommand($this->mockContainerWithKernel());

        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage("The bundle 'FakeBundle' does not exist or is not registered in the kernel!");

        $commandTester->execute([
            '--dest' => 'src',
            'bundle' => ['FakeBundle'],
        ]);

        $this->assertContains(
            'You must provide a bundle name!',
            $commandTester->getDisplay()
        );
    }

    public function testNotExtendableBundle()
    {
        $commandTester = $this->buildCommand($this->mockContainerWithKernel(new \Symfony\Bundle\NotExtendableBundle()));

        $commandTester->execute([
            '--dest' => 'src',
            'bundle' => ['NotExtendableBundle'],
        ]);

        $this->assertContains(
            sprintf('Ignoring bundle : "Symfony\Bundle\NotExtendableBundle"'),
            $commandTester->getDisplay()
        );
    }

    public function testInvalidFolderStructure()
    {
        $commandTester = $this->buildCommand(
            $this->mockContainerWithKernel(new \Application\Sonata\NotExtendableBundle())
        );

        $commandTester->execute([
            '--dest' => 'src',
            'bundle' => ['NotExtendableBundle'],
        ]);

        $this->assertContains(
            sprintf('Application\Sonata\NotExtendableBundle : wrong directory structure'),
            $commandTester->getDisplay()
        );
    }

    private function buildCommand($container)
    {
        $command = new GenerateCommand();
        $command->setContainer($container);

        return new CommandTester($command);
    }

    private function mockContainer()
    {
        $containerMock = $this->mockContainerWithKernel();

        $containerMock->expects($this->exactly(6))
            ->method('get')
            ->willReturn($this->mockGenerator());

        return $containerMock;
    }

    private function mockContainerWithKernel($kernelReturnValue = null)
    {
        $containerMock = $this->createMock(ContainerInterface::class);

        $containerMock->expects($this->at(0))
            ->method('get')
            ->with('kernel')
            ->willReturn($this->mockKernel($kernelReturnValue));

        return $containerMock;
    }

    private function mockKernel($returnValue)
    {
        $kernelMock = $this->createMock(KernelInterface::class);

        $kernelMock->expects($this->once())
            ->method('getBundles')
            ->willReturn([
                $returnValue ?: new SonataAcmeBundle(),
            ]);

        return $kernelMock;
    }

    private function mockGenerator()
    {
        $generatorMock = $this->createMock(GeneratorInterface::class);

        $generatorMock->expects($this->exactly(5))
            ->method('generate');

        return $generatorMock;
    }
}