TheCodingMachine\Discovery\Tests\AbstractDiscoveryTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getRepositoryMock()	0	8	1
A	getRepositoryManagerMock()	0	6	1
A	getInstallationManagerMock()	0	9	1
A	callCommand()	0	12	1
A	getComposer()	0	8	1
A	getIO()	0	6	1

<?php


namespace TheCodingMachine\Discovery\Tests;


use Composer\Command\BaseCommand;
use Composer\Composer;
use Composer\Installer\InstallationManager;
use Composer\IO\IOInterface;
use Composer\Package\Package;
use Composer\Package\RootPackage;
use Composer\Repository\RepositoryInterface;
use Composer\Repository\RepositoryManager;
use PHPUnit\Framework\TestCase;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\BufferedOutput;

abstract class AbstractDiscoveryTest extends TestCase
{
    protected function getInstallationManagerMock(string $installPath = null) : InstallationManager
    {
        $installationManager = $this->createMock(InstallationManager::class);

        // Configure the stub.
        $installationManager->method('getInstallPath')
            ->willReturn(realpath($installPath ?? 'tests/fixtures/package_a'));

        return $installationManager;

The expression return $installationManager returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Composer\Installer\InstallationManager.

    }

    protected function getRepositoryMock() : RepositoryInterface
    {
        $packageA = new Package('package/a', '1.0.0', '1.0.0');

        $repository = $this->createMock(RepositoryInterface::class);
        $repository->method('getPackages')->willReturn([ $packageA ]);

        return $repository;

The expression return $repository returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Composer\Repository\RepositoryInterface.

    }

    protected function getRepositoryManagerMock() : RepositoryManager
    {
        $repositoryManager = $this->createMock(RepositoryManager::class);
        $repositoryManager->method('getLocalRepository')->willReturn($this->getRepositoryMock());

        return $repositoryManager;

The expression return $repositoryManager returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Composer\Repository\RepositoryManager.

    }

    protected function getComposer() : Composer
    {
        $composer = new Composer();
        $composer->setInstallationManager($this->getInstallationManagerMock());
        $composer->setRepositoryManager($this->getRepositoryManagerMock());
        $composer->setPackage(new RootPackage('__root__', 'stable', '1.0'));

        return $composer;
    }

    protected function getIO() : IOInterface
    {
        $io = $this->createMock(IOInterface::class);
        $io->method('writeError');

        return $io;

The expression return $io returns the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Composer\IO\IOInterface.

    }

    /**
     * Calls the command passed in parameter. Returns the output.
     *
     * @param BaseCommand $command
     * @param InputInterface $input
     * @return string
     */
    protected function callCommand(BaseCommand $command, InputInterface $input) : string
    {
        $command->setComposer($this->getComposer());
        $command->setIO($this->getIO());

        $output = new BufferedOutput();

        $r = new \ReflectionMethod($command, 'execute');
        $r->setAccessible(true);
        $r->invoke($command, $input, $output);

        return $output->fetch();
    }

}