SmartWeb\ModuleTesting\Providers\ModuleTestingServiceProvider

Complexity

Total Complexity

17

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	boot()	0	15	2
A	includeCodeceptionShim()	0	4	1
A	registerConfig()	0	9	1
A	registerHelpers()	0	6	2
A	registerMacros()	0	11	1
B	registerBaseTestClasses()	0	26	3
A	registerTemplates()	0	20	1
A	registerProviders()	0	4	1
A	templatePath()	0	4	1
A	register()	0	4	1
A	provides()	0	4	1
A	registerCommands()	0	22	1
A	path()	0	4	1

<?php


namespace SmartWeb\ModuleTesting\Providers;

use Illuminate\Support\Collection;
use Illuminate\Support\Facades\File;
use Illuminate\Support\ServiceProvider;
use SmartWeb\ModuleTesting\BaseAcceptanceCest;
use SmartWeb\ModuleTesting\BaseGraphQLCest;
use SmartWeb\ModuleTesting\BaseIntegrationCest;
use SmartWeb\ModuleTesting\BaseUnitTest;
use SmartWeb\ModuleTesting\Console\Command\GenerateCest;
use SmartWeb\ModuleTesting\Console\Command\GenerateSetup;
use SmartWeb\ModuleTesting\Console\Command\GenerateTest;
use SmartWeb\ModuleTesting\Generator\Test\BaseClassResolver;
use SmartWeb\ModuleTesting\Generator\Test\CodeceptionTestType;
use SmartWeb\ModuleTesting\Template\TemplateFactory;
use const DIRECTORY_SEPARATOR;
use function glob;
use function implode;

/**
 * Class ModuleTestingServiceProvider
 *
 * @package SmartWeb\ModuleTesting\Providers
 */
class ModuleTestingServiceProvider extends ServiceProvider
{
    
    /**
     * Indicates if loading of the provider is deferred.
     *
     * @var bool
     */
    protected $defer = false;
    
    /**
     * Boot the application events.
     */
    public function boot()
    {
        if ($this->app->environment() !== 'production') {
            $this->includeCodeceptionShim();
            
            $this->registerConfig();
            $this->registerHelpers();
            $this->registerMacros();
            
            $this->registerBaseTestClasses();
            $this->registerTemplates();
            
            $this->registerProviders();
        }
    }
    
    private function includeCodeceptionShim()
    {
        require_once __DIR__ . '/../../vendor/codeception/codeception/shim.php';
    }
    
    /**
     * Register config.
     *
     * @return void
     */
    protected function registerConfig()
    {
        $this->publishes([
            __DIR__ . '/../Config/config.php' => config_path('testing.php'),
        ], 'config');
        $this->mergeConfigFrom(
            __DIR__ . '/../Config/config.php', 'testing'
        );
    }
    
    protected function registerHelpers()
    {
        foreach (glob($this->path('Helpers/*.php')) as $file) {
            File::requireOnce($file);
        }
    }
    
    protected function registerMacros()
    {
        Collection::macro('mapIntoWithValues', function (string $class) {
            /**
             * @var Collection $this
             */
            return $this->map(function ($value) use ($class) {

The method map() does not seem to exist on object<SmartWeb\ModuleTesting\Providers\ModuleTestingServiceProvider>.

                return new $class($value);
            });
        });
    }
    
    protected function registerBaseTestClasses()
    {
        $baseClasses = [
            'test' => [
                'Unit' => BaseUnitTest::class,
            ],
            'cest' => [
                'Integration' => BaseIntegrationCest::class,
                'GraphQL'     => BaseGraphQLCest::class,
                'Acceptance'  => BaseAcceptanceCest::class,
            ],
            'cept' => [],
        ];
        
        foreach ($baseClasses as $type => $classesForType) {
            /**
             * @var CodeceptionTestType $type
             * @var string[]            $classesForType
             */
            $type = CodeceptionTestType::memberByKey($type);
            
            foreach ($classesForType as $suite => $baseClass) {
                BaseClassResolver::registerBaseClassForModule($type, $suite, BaseClassResolver::DEFAULT_MODULE, $baseClass);
            }
        }
    }
    
    protected function registerTemplates()
    {
        TemplateFactory::registerTemplate(
            CodeceptionTestType::test(),
            'Unit',
            $this->templatePath('test.unit.tpl')
        );
        
        TemplateFactory::registerTemplate(
            CodeceptionTestType::cest(),
            'Integration',
            $this->templatePath('cest.integration.tpl')
        );
        
        TemplateFactory::registerTemplate(
            CodeceptionTestType::cest(),
            'GraphQL',
            $this->templatePath('cest.graphql.tpl')
        );
    }
    
    protected function registerProviders()
    {
        $this->app->register(ExpressionLanguageServiceProvider::class);
    }
    
    /**
     * @param string $template
     *
     * @return string
     */
    protected function templatePath(string $template) : string
    {
        return TemplateFactory::DEFAULT_TEMPLATE_DIR . DIRECTORY_SEPARATOR . $template;
    }
    
    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->registerCommands();
    }
    
    /**
     * Get the services provided by the provider.
     *
     * @return array
     */
    public function provides()
    {
        return [];
    }
    
    protected function registerCommands()
    {
        $this->app->singleton(
            'command.smartweb.testing.generate-setup',
            GenerateSetup::class
        );
        
        $this->app->singleton(
            'command.smartweb.testing.generate-test',
            GenerateTest::class
        );
        
        $this->app->singleton(
            'command.smartweb.testing.generate-cest',
            GenerateCest::class
        );
        
        $this->commands(
            'command.smartweb.testing.generate-setup',
            'command.smartweb.testing.generate-test',
            'command.smartweb.testing.generate-cest');
    }
    
    /**
     * @param string[] ...$parts
     *
     * @return string
     */
    protected function path(...$parts) : string
    {
        return __DIR__ . '/../' . implode(DIRECTORY_SEPARATOR, $parts);
    }
}