Shamaseen\Repository\Tests\Feature\GenerateFilesTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	108
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	4	1
A	__construct()	0	3	1
A	testGenerateMCROnly()	0	9	2
A	testGenerate()	0	8	2
A	testDefaultStubsConfig()	0	14	3
A	defaultStubsConfigProvider()	0	39	1

<?php

namespace Shamaseen\Repository\Tests\Feature;

use Illuminate\Support\Facades\Config;
use Shamaseen\Repository\Commands\Generator;
use Shamaseen\Repository\PathResolver;
use Shamaseen\Repository\Tests\TestCase;

class GenerateFilesTest extends TestCase
{
    /**
     * @var mixed
     */
    private PathResolver $pathResolver;

    private array $filesToGenerate = ['Controller', 'Repository', 'Model', 'Request', 'Resource', 'Collection', 'Policy', 'Test'];

    protected string $modelName = 'Test';
    protected string $userPath = 'Tests';

    /**
     * @param string $dataName
     */
    public function __construct(?string $name = null, array $data = [], $dataName = '')
    {
        parent::__construct($name, $data, $dataName);
    }

    public function setUp(): void
    {
        parent::setUp();
        $this->pathResolver = new PathResolver($this->modelName, $this->userPath, config('repository.base_path'));
    }

    public function testGenerate()
    {
        $this->artisan("generate:repository $this->userPath/$this->modelName -f");

        foreach ($this->filesToGenerate as $type) {
            $absolutePath = $this->pathResolver->absolutePath($type);

            $this->assertFileExists($absolutePath);
        }
    }

    public function testGenerateMCROnly()
    {
        $this->artisan("generate:repository $this->userPath/$this->modelName -f -mrc");

        $filesToGenerate = ['Controller', 'Repository', 'Model'];
        foreach ($filesToGenerate as $type) {
            $absolutePath = $this->pathResolver->absolutePath($type);

            $this->assertFileExists($absolutePath);
        }
    }

    public function defaultStubsConfigProvider(): array
    {
        return [
            // run 1
            [
                [
                    Generator::RESOURCE_OPTION
                ],
                [
                    'Resource',
                ]
            ],
            // run 2
            [
                [
                    Generator::MODEL_OPTION,
                    Generator::CONTROLLER_OPTION,
                ],
                [
                    'Model',
                    'Controller',
                ],
            ],
            // running Request option should only generate Request
            [
                [
                    Generator::REQUEST_OPTION,
                ],
                [
                    'Request',
                ]
            ],
            // running Collection option should only generate Collection
            [
                [
                    Generator::COLLECTION_OPTION,
                ],
                [
                    'Collection',
                ]
            ],
        ];
    }

    /** @dataProvider defaultStubsConfigProvider */
    public function testDefaultStubsConfig(array $config, array $generatedNames)
    {
        Config::set('repository.default_stubs', $config);
        $this->artisan("generate:repository $this->userPath/$this->modelName -f");

        foreach ($generatedNames as $generatedName) {
            $this->assertFileExists($this->pathResolver->absolutePath($generatedName));
        }

        $allGeneratedStubs = array_keys(PathResolver::$configTypePathMap);
        $filesNotGenerated = array_diff($allGeneratedStubs, $generatedNames);

        foreach ($filesNotGenerated as $fileNotGenerated) {
            $this->assertFileDoesNotExist($this->pathResolver->absolutePath($fileNotGenerated));
        }
    }
}