SmartWeb\ModuleTesting\Codeception\SmartWeb\Setup

Complexity

Total Complexity

12

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getDisk()	0	4	1
A	getPath()	0	4	1
A	getWorkDir()	0	4	1
A	getTestsDir()	0	4	1
A	resolveWorkDir()	0	4	1
A	getNamespace()	0	10	1
A	getPathRelativeToBasePath()	0	4	1
A	getModule()	0	4	1
A	resolveModule()	0	13	3

<?php


namespace SmartWeb\ModuleTesting\Codeception\SmartWeb;

use Exception;
use Illuminate\Contracts\Filesystem\Filesystem;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Nwidart\Modules\Module;
use SmartWeb\ModuleTesting\Codeception\SetupInterface;
use const DIRECTORY_SEPARATOR;
use function base_path;
use function is_null;
use function is_string;


/**
 * Class SmartWebCodeceptionSetup
 *
 * @package SmartWeb\ModuleTesting\Codeception
 */
class Setup implements SetupInterface
{
    
    /**
     * @var string
     */
    protected static $configTemplate = <<<EOF
suites:
    unit:
        path: .
{{tester}}
settings:
    shuffle: true
paths:
    tests: {{dir}}
    output: {{dir}}/_output
    support: {{dir}}/_support
    data: {{dir}}
    
EOF;
    
    /**
     * @var string
     */
    protected static $testerAndModules = <<<EOF
        actor: UnitTester
        modules:
            enabled:
                # add more modules here
                - Asserts
EOF;
    
    /**
     * @var Module
     */
    protected $module;
    
    /**
     * @var Filesystem
     */
    protected $disk;
    
    /**
     * @var string
     */
    protected $workingDir;
    
    /**
     * SmartWebCodeceptionSetup constructor.
     *
     * @param Module|string $module
     * @param string        $disk
     *
     * @throws Exception
     */
    public function __construct($module, string $disk = 'solution')
    {
        $this->module = $this->resolveModule($module);
        $this->disk = Storage::disk($disk);
    }
    
    /**
     * @return Filesystem
     */
    public function getDisk() : Filesystem
    {
        return $this->disk;
    }
    
    /**
     * Get the path relative to the working directory of this Setup.
     *
     * @param string $path
     *
     * @return string
     */
    public function getPath(string $path) : string
    {
        return $this->getWorkDir() . DIRECTORY_SEPARATOR . $path;
    }
    
    /**
     * @return string
     */
    public function getWorkDir() : string
    {
        return $this->workingDir = $this->workingDir ?? $this->resolveWorkDir();
    }
    
    /**
     * @inheritDoc
     */
    public function getTestsDir() : string
    {
        return self::DEFAULT_TESTS_DIR;
    }
    
    /**
     * @return string
     */
    protected function resolveWorkDir() : string
    {
        return $this->getPathRelativeToBasePath($this->module->getPath());
    }
    
    /**
     * @return string
     */
    public function getNamespace() : string
    {
        $modulePath = $this->getModule()->getPath();
        $relativeToBasePath = $this->getPathRelativeToBasePath($modulePath);
        
        $properCase = Str::ucfirst($relativeToBasePath);
        $asNamespace = str_replace(DIRECTORY_SEPARATOR, '\\', $properCase);
        
        return $asNamespace;
    }
    
    /**
     * @param string $path
     *
     * @return string
     */
    protected function getPathRelativeToBasePath(string $path) : string
    {
        return str_replace(base_path('') . DIRECTORY_SEPARATOR, '', $path);
    }
    
    /**
     * @return Module
     */
    public function getModule() : Module
    {
        return $this->module;
    }
    
    /**
     * @param Module|string $module
     *
     * @return Module
     * @throws Exception
     */
    private function resolveModule($module) : Module
    {
        if (is_string($module)) {
            $moduleName = $module;
            $module = \Nwidart\Modules\Facades\Module::find($module);
            
            if (is_null($module)) {
                throw new Exception("Could not resolve module {$moduleName}.");
            }
        }
        
        return $module;
    }
    
}