eZ\Bundle\EzPublishCoreBundle\Features\Context\ConsoleContext

Complexity

Total Complexity

24

Size/Duplication

Total Lines	194
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	iRunAConsoleScript()	0	4	1
A	iRunAConsoleScriptWithSiteaccess()	0	4	1
A	iExpectItToBeExecutedWithTheSiteaccess()	0	9	1
A	iExpectItToBeExecutedWithTheDefaultOne()	0	4	1
A	thereIsASiteaccess()	0	14	4
A	thereIsADefaultSiteaccess()	0	8	1
A	iRunAConsoleScriptWithIt()	0	8	1
B	iRunTheCommand()	0	29	6
A	thereIsASiteaccessThatIsNotTheDefaultOne()	0	6	1
A	iExpectItToBeExecutedWithIt()	0	4	1
A	getNonDefaultSiteaccessName()	0	11	3
A	getConfigResolver()	0	4	1
A	getDefaultSiteaccessName()	0	4	1

<?php
namespace eZ\Bundle\EzPublishCoreBundle\Features\Context;

use Behat\Behat\Context\Context;
use eZ\Publish\Core\MVC\ConfigResolverInterface;
use Symfony\Component\Process\PhpExecutableFinder;
use Symfony\Component\Process\Process;
use PHPUnit\Framework\Assert as Assertion;

class ConsoleContext implements Context
{
    /** @var ConfigResolverInterface */
    private $configResolver;

    /** @var string[] */
    private $siteaccessList;

    /** @var string */
    private $defaultSiteaccess;

    private $scriptOutput = null;

    /**
     * Elements referenced by 'it' in sentences.
     * @var array
     */
    private $it = [];

    /**
     * @param ConfigResolverInterface $configResolver
     * @param string[] $siteaccessList
     * @param string $defaultSiteaccess
     */
    public function __construct(
        ConfigResolverInterface $configResolver,
        array $siteaccessList,
        string $defaultSiteaccess
    ) {
        $this->configResolver = $configResolver;
        $this->siteaccessList = $siteaccessList;
        $this->defaultSiteaccess = $defaultSiteaccess;
    }

    /**
     * @When I run a console script without specifying a siteaccess
     */
    public function iRunAConsoleScript()
    {
        $this->iRunTheCommand('ez:behat:siteaccess');
    }

    /**
     * @When I run a console script with the siteaccess option :siteaccessOption
     */
    public function iRunAConsoleScriptWithSiteaccess($siteaccessOption)
    {
        $this->iRunTheCommand('ez:behat:siteaccess', $siteaccessOption);
    }

    /**
     * @Then It is executed with the siteaccess :siteaccess
     */
    public function iExpectItToBeExecutedWithTheSiteaccess($siteaccess)
    {
        $actualSiteaccess = trim($this->scriptOutput);
        Assertion::assertEquals(
            $siteaccess,
            $actualSiteaccess,
            "The command was expected to be executed with the siteaccess \"$siteaccess\", but was executed with \"$actualSiteaccess\""
        );
    }

    /**
     * @Then it is executed with the default one
     *
     * default one: default siteaccess.
     */
    public function iExpectItToBeExecutedWithTheDefaultOne()
    {
        $this->iExpectItToBeExecutedWithTheSiteaccess($this->getDefaultSiteaccessName());
    }

    /**
     * @Given /^that there is a "([^"]*)" siteaccess$/
     */
    public function thereIsASiteaccess($expectedSiteaccessName, $default = false)
    {
        $found = false;

        $siteaccessList = $this->getConfigResolver()->getParameter('siteaccess.list');
        foreach ($siteaccessList as $siteaccessName) {
            if ($siteaccessName === $expectedSiteaccessName) {
                $found = $default === false || $siteaccessName !== $this->getDefaultSiteaccessName();
            }
        }

        Assertion::assertTrue($found, "No siteaccess named $expectedSiteaccessName was found");
        $this->it['siteaccess'] = $expectedSiteaccessName;
    }

    /**
     * @Given /^that there is a default "([^"]*)" siteaccess$/
     */
    public function thereIsADefaultSiteaccess($expectedSiteaccessName)
    {
        $this->thereIsASiteaccess($expectedSiteaccessName, true);
        Assertion::assertEquals(
            $expectedSiteaccessName,
            $siteaccessList = $this->getConfigResolver()->getParameter('siteaccess.default_siteaccess')
        );
    }

    /**
     * @When I run a console script with it
     *
     * it: the siteaccess referenced above.
     */
    public function iRunAConsoleScriptWithIt()
    {
        $this->iRunTheCommand(
            'ez:behat:siteaccess',
            $this->it['siteaccess']
        );
        $this->it['siteaccess'] = $this->scriptOutput;
    }

    private function iRunTheCommand($command, $siteaccess = null)
    {
        $phpFinder = new PhpExecutableFinder();
        if (!$phpPath = $phpFinder->find(false)) {
            throw new \RuntimeException('The php executable could not be found. Add it to your PATH environment variable and try again');
        }
        $arguments = $phpFinder->findArguments();
        if (false !== ($ini = php_ini_loaded_file())) {
            $arguments[] = '--php-ini=' . $ini;
        }
        $php = escapeshellarg($phpPath);
        $phpArgs = implode(' ', array_map('escapeshellarg', $arguments));
        $console = escapeshellarg('bin/console');
        $cmd = escapeshellarg($command);

        $console .= ' --env=' . escapeshellarg('behat');
        if ($siteaccess !== null) {
            $console .= ' --siteaccess=' . escapeshellarg($siteaccess);
        }

        $commandLine = $php . ($phpArgs ? ' ' . $phpArgs : '') . ' ' . $console . ' ' . $cmd;
        $process = Process::fromShellCommandline($commandLine);
        $process->run();
        if (!$process->isSuccessful()) {
            throw new \RuntimeException(sprintf('An error occurred when executing the "%s" command. %s', escapeshellarg($cmd), $process->getErrorOutput()));
        }

        $this->scriptOutput = $process->getOutput();
    }

    /**
     * @Given /^that there is a siteaccess that is not the default one$/
     */
    public function thereIsASiteaccessThatIsNotTheDefaultOne()
    {
        $siteaccessName = $this->getNonDefaultSiteaccessName();
        Assertion::assertNotNull($siteaccessName, 'There is no siteaccess other than the default one');
        $this->it['siteaccess'] = $siteaccessName;
    }

    /**
     * @Then /^I expect it to be executed with it$/
     */
    public function iExpectItToBeExecutedWithIt()
    {
        Assertion::assertEquals($this->it['siteaccess'], $this->scriptOutput);
    }

    /**
     * Returns the name of an existing siteaccess that isn't the default one.
     * @return string|null The siteaccess name, or null if there isn't one
     */
    private function getNonDefaultSiteaccessName()
    {
        $defaultSiteaccessName = $this->getDefaultSiteaccessName();
        foreach ($this->siteaccessList as $siteaccessName) {
            if ($siteaccessName !== $defaultSiteaccessName) {
                return $siteaccessName;
            }
        }

        return null;
    }

    /**
     * @return ConfigResolverInterface
     */
    private function getConfigResolver()
    {
        return $this->configResolver;
    }

    private function getDefaultSiteaccessName()
    {
        return $this->defaultSiteaccess;
    }
}