SmartWeb\ModuleTesting\Codeception\SmartWeb\SetupGenerator

Complexity

Total Complexity

24

Size/Duplication

Total Lines	255
Duplicated Lines	7.84 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	__get()	0	8	2
B	generate()	0	31	1
A	createSuiteAndBuild()	0	5	1
A	generateSuite()	0	7	1
A	build()	0	4	1
A	executeCodeceptionCommand()	0	17	2
A	parseCommand()	0	4	1
A	createGlobalConfiguration()	0	6	1
A	createTestsDir()	0	4	1
A	createSupportingDirs()	0	6	2
A	createSuites()	0	11	1
A	createFile()	10	10	2
A	createDir()	10	10	2
A	getPath()	0	8	2
A	createEmptyDir()	0	8	2
A	createGitKeep()	0	4	1

<?php


namespace SmartWeb\ModuleTesting\Codeception\SmartWeb;

use Illuminate\Contracts\Filesystem\Filesystem;
use InvalidArgumentException;
use SmartWeb\ModuleTesting\Codeception\GlobalConfiguration;
use SmartWeb\ModuleTesting\Codeception\GlobalConfigurationInterface;
use SmartWeb\ModuleTesting\Codeception\SetupGeneratorInterface;
use SmartWeb\ModuleTesting\Codeception\SetupInterface;
use SmartWeb\ModuleTesting\Codeception\SuiteInfoInterface;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\Process;
use Symfony\Component\Yaml\Yaml;
use const DIRECTORY_SEPARATOR;
use function collect;
use function implode;


/**
 * Class Generator
 *
 * @package SmartWeb\Testing\Codeception
 */
class SetupGenerator implements SetupGeneratorInterface
{
    
    /**
     * @var SetupInterface
     */
    protected $setup;
    
    /**
     * @var Filesystem
     */
    protected $disk;
    
    /**
     * @var GlobalConfigurationInterface
     */
    protected $globalConfiguration;
    
    /**
     * Generator constructor.
     *
     * @param SetupInterface $setup
     */
    public function __construct(SetupInterface $setup)
    {
        $this->setup = $setup;
        $this->disk = $setup->getDisk();
    }
    
    /**
     * @param string $name
     *
     * @return mixed
     */
    public function __get($name)
    {
        if ($this->globalConfiguration->has($name)) {
            return $this->globalConfiguration->get($name);
        }
        
        throw new InvalidArgumentException("'{$name}' was not found in the global configuration");
    }
    
    /**
     * @param string[] $suites
     *
     * @return void
     */
    public function generate($suites = [])
    {
        $testDir = $this->setup->getTestsDir();
        $namespace = $this->setup->getNamespace() . '\\' . $testDir;
        
        $this->globalConfiguration = new GlobalConfiguration(
            [
                'namespace'  => $namespace,
                'actor'      => 'Tester',
                'paths'      => [
                    'tests'   => $testDir,
                    'data'    => $testDir . DIRECTORY_SEPARATOR . '_data',
                    'output'  => $testDir . DIRECTORY_SEPARATOR . '_output',
                    'support' => $testDir . DIRECTORY_SEPARATOR . '_support',
                    'envs'    => $testDir . DIRECTORY_SEPARATOR . '_envs',
                ],
                'extensions' => [
                    'enabled' => [
                        'Codeception\Extension\RunFailed',
                    ],
                ],
            ]
        );
        
        $this->createGlobalConfiguration();
        $this->createTestsDir();
        $this->createSupportingDirs();
        
        $this->createSuites($suites);
        $this->build();
    }
    
    /**
     * @param string $suite
     */
    public function createSuiteAndBuild(string $suite)
    {
        $this->generateSuite(new SuiteInfo($suite));
        $this->build();
    }
    
    /**
     * @param SuiteInfoInterface $suiteInfo
     *
     * @return void
     */
    protected function generateSuite(SuiteInfoInterface $suiteInfo)
    {
        $suite = $suiteInfo->getName();
        $actor = $suiteInfo->getActor();
        
        $this->executeCodeceptionCommand("g:suite {$suite} {$actor}");
    }
    
    /**
     * Build Actor classes
     *
     * @return void
     */
    protected function build()
    {
        $this->executeCodeceptionCommand('build');
    }
    
    /**
     * @param string $command
     */
    protected function executeCodeceptionCommand(string $command)
    {
        $command = $this->parseCommand(
            'vendor/bin/codecept',
            $command, "-c {$this->setup->getWorkDir()}", '--quiet'
        );
        
        $process = new Process($command);
        
        try {
            $process->mustRun();
            
            echo $process->getOutput();
        } catch (ProcessFailedException $e) {
            echo $e->getMessage();
        }
    }
    
    /**
     * @param string   $command
     * @param string[] ...$arguments
     *
     * @return string
     */
    protected function parseCommand(string $command, string ...$arguments) : string
    {
        return $command . ' ' . implode(' ', $arguments);
    }
    
    protected function createGlobalConfiguration()
    {
        $str = Yaml::dump($this->globalConfiguration->toArray(), 4);
        
        $this->createFile('codeception.yml', $str, true);
    }
    
    protected function createTestsDir()
    {
        $this->createDir($this->setup->getTestsDir(), true);
    }
    
    protected function createSupportingDirs()
    {
        foreach ($this->globalConfiguration->getSupportingDirs() as $dir) {
            $this->createEmptyDir($dir);
        }
    }
    
    /**
     * @param string[] $suites
     */
    protected function createSuites($suites)
    {
        collect($suites)
            ->mapInto(SuiteInfo::class)
            ->each(
                function (SuiteInfoInterface $suiteInfo)
                {
                    $this->generateSuite($suiteInfo);
                }
            );
    }
    
    /**
     * @param string          $path
     * @param string|resource $contents
     * @param bool            $inBasePath
     *
     * @return bool
     */
    protected function createFile(string $path, $contents, bool $inBasePath = false) : bool

This method seems to be duplicated in your project.

    {
        $path = $this->getPath($path, $inBasePath);
        
        if (!$this->disk->exists($path)) {
            return $this->disk->put($path, $contents);
        }
        
        return false;
    }
    
    /**
     * @param string $path
     * @param bool   $inBasePath
     *
     * @return bool
     */
    protected function createDir(string $path, bool $inBasePath = false) : bool

This method seems to be duplicated in your project.

    {
        $path = $this->getPath($path, $inBasePath);
        
        if (!$this->disk->exists($path)) {
            return $this->disk->makeDirectory($path);
        }
        
        return false;
    }
    
    /**
     * @param string $path
     * @param bool   $inBasePath
     *
     * @return string
     */
    protected function getPath(string $path, bool $inBasePath = false) : string
    {
        $pathPrefix = $this->setup->getWorkDir() . DIRECTORY_SEPARATOR;
        
        return $inBasePath
            ? $pathPrefix . $path
            : $pathPrefix . $this->setup->getTestsDir() . DIRECTORY_SEPARATOR . $path;
    }
    
    /**
     * @param string $path
     * @param bool   $inBasePath
     *
     * @return bool
     */
    protected function createEmptyDir(string $path, bool $inBasePath = false) : bool
    {
        if ($this->createDir($path, $inBasePath)) {
            return $this->createGitKeep($path, $inBasePath);
        }
        
        return false;
    }
    
    /**
     * @param string $dir
     * @param bool   $inBasePath
     *
     * @return bool
     */
    protected function createGitKeep(string $dir, bool $inBasePath = false) : bool
    {
        return $this->createFile($dir . DIRECTORY_SEPARATOR . '.gitkeep', '', $inBasePath);
    }
    
}