Add service provider tests

src/Exceptions/FakerMethodNotFoundException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace RonasIT\Support\Exceptions;
+
+use Exception;
+
+class FakerMethodNotFoundException extends Exception
+{
+}

src/Exceptions/UnknownFieldTypeException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace RonasIT\Support\Exceptions;
+
+use Exception;
+
+class UnknownFieldTypeException extends Exception
+{
+}

src/Generators/AbstractTestsGenerator.php

@@ -169,10 +169,6 @@ protected function getModelFields($model): array
 
     protected function getMockModel($model): array
     {
-        if (!$this->isFactoryExists($model)) {
-            return [];
-        }
-
         $modelClass = $this->getModelClass($model);
         $hasFactory = method_exists($modelClass, 'factory') && $this->classExists('factory', "{$model}Factory");
         $factory = ($hasFactory) ? $modelClass::factory() : factory($modelClass);

src/Generators/EntityGenerator.php

@@ -114,6 +114,14 @@ protected function saveClass($path, $name, $content, $additionalEntityFolder = f
     {
         $entitiesPath = base_path($this->paths[$path]);
 
+        $pathParts = explode('/', $entitiesPath);
+
+        if (Str::endsWith(Arr::last($pathParts), '.php')) {
+            array_pop($pathParts);
+        }
+
+        $entitiesPath = implode('/', $pathParts);
+
         if ($additionalEntityFolder) {
             $entitiesPath = $entitiesPath . "/{$additionalEntityFolder}";
         }

src/Generators/FactoryGenerator.php

@@ -5,12 +5,13 @@
 use Faker\Generator as Faker;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Str;
+use InvalidArgumentException;
+use RonasIT\Support\Exceptions\FakerMethodNotFoundException;
 use RonasIT\Support\Exceptions\ModelFactoryNotFound;
 use RonasIT\Support\Exceptions\ClassNotExistsException;
 use RonasIT\Support\Exceptions\ModelFactoryNotFoundedException;
 use RonasIT\Support\Exceptions\ClassAlreadyExistsException;
 use RonasIT\Support\Events\SuccessCreateMessage;
-use Exception;
 
 class FactoryGenerator extends EntityGenerator
 {
@@ -32,7 +33,7 @@ protected function generateSeparateClass(): string
             $this->throwFailureException(
                 ClassNotExistsException::class,
                 "Cannot create {$this->model}Factory cause {$this->model} Model does not exists.",
-                "Create a {$this->model} Model by himself or run command 'php artisan make:entity {$this->model} --only-model'."
+                "Create a {$this->model} Model by itself or run command 'php artisan make:entity {$this->model} --only-model'."
             );
         }
 
@@ -74,7 +75,7 @@ protected function generateToGenericClass(): string
 
             $createMessage = "Created a new Test factory for {$this->model} model in '{$this->paths['factory']}'";
 
-            file_put_contents($this->paths['factory'], $content, FILE_APPEND);
+            file_put_contents(base_path($this->paths['factory']), $content, FILE_APPEND);
 
             $this->prepareRelatedFactories();
         } else {
@@ -86,13 +87,18 @@ protected function generateToGenericClass(): string
 
     public function generate(): void
     {
-        $createMessage = (version_compare(app()->version(), '8', '>='))
+        $createMessage = ($this->allowedToCreateFactoryInSeparateClass())
             ? $this->generateSeparateClass()
             : $this->generateToGenericClass();
 
         event(new SuccessCreateMessage($createMessage));
     }
 
+    protected function allowedToCreateFactoryInSeparateClass(): bool
+    {
+        return version_compare(app()->version(), '8', '>=');
+    }
+
     protected function prepareEmptyFactory(): void
     {
         $stubPath = config('entity-generator.stubs.legacy_empty_factory');
@@ -102,16 +108,18 @@ protected function prepareEmptyFactory(): void
 
         list($basePath, $databaseFactoryDir) = extract_last_part(config('entity-generator.paths.factory'), '/');
 
+        $databaseFactoryDir = base_path($databaseFactoryDir);
+
         if (!is_dir($databaseFactoryDir)) {
             mkdir($databaseFactoryDir);
         }
 
-        file_put_contents($this->paths['factory'], $content);
+        file_put_contents(base_path($this->paths['factory']), $content);
     }
 
     protected function checkExistRelatedModelsFactories(): bool
     {
-        $modelFactoryContent = file_get_contents($this->paths['factory']);
+        $modelFactoryContent = file_get_contents(base_path($this->paths['factory']));
         $relatedModels = $this->getRelatedModels($this->model);
         $modelNamespace = $this->getOrCreateNamespace('models');
 
@@ -122,8 +130,9 @@ protected function checkExistRelatedModelsFactories(): bool
             if (!$existModelFactory) {
                 $this->throwFailureException(
                     ModelFactoryNotFoundedException::class,
-                    "Not found $relatedModel factory for $relatedModel model in '{$this->paths['factory']}",
-                    "Please declare a factory for $relatedModel model on '{$this->paths['factory']}' path and run your command with option '--only-tests'."
+                    "Not found {$relatedModel} factory for {$relatedModel} model in '{$this->paths['factory']}",
+                    "Please declare a factory for {$relatedModel} model on '{$this->paths['factory']}' "
+                    . "path and run your command with option '--only-tests'."
                 );
             }
         }
@@ -146,8 +155,10 @@ protected static function getCustomMethod($field): string
             return self::CUSTOM_METHODS[$field['type']];
         }
 
-        $message = $field['type'] . 'not found in CUSTOM_METHODS variable CUSTOM_METHODS = ' . self::CUSTOM_METHODS;
-        throw new Exception($message);
+        $message = "Cannot generate fake data for unsupported {$field['type']} field type. "
+            . "Supported custom field types are " . implode(', ', array_keys(self::CUSTOM_METHODS));
+
+        throw new FakerMethodNotFoundException($message);
     }
 
     protected function prepareRelatedFactories(): void
@@ -158,12 +169,12 @@ protected function prepareRelatedFactories(): void
         );
 
         foreach ($relations as $relation) {
-            $modelFactoryContent = file_get_contents($this->paths['factory']);
+            $modelFactoryContent = file_get_contents(base_path($this->paths['factory']));
 
             if (!Str::contains($modelFactoryContent, $this->getModelClass($relation))) {
                 $this->throwFailureException(
                     ModelFactoryNotFound::class,
-                    "Model factory for mode {$relation} not found.",
+                    "Model factory for model {$relation} not found.",
                     "Please create it and after thar you can run this command with flag '--only-tests'."
                 );
             }
@@ -180,7 +191,7 @@ protected function prepareRelatedFactories(): void
                 $modelFactoryContent = str_replace($match, $match . $newField, $modelFactoryContent);
             }
 
-            file_put_contents($this->paths['factory'], $modelFactoryContent);
+            file_put_contents(base_path($this->paths['factory']), $modelFactoryContent);
         }
     }
 
@@ -193,20 +204,23 @@ public static function getFactoryFieldsContent($field): string
             return 1;
         }
 
-        if (property_exists($faker, $field['name'])) {
-            return "\$faker-\>{$field['name']}";
+        try {
+            $faker->{$field['name']};
+            $hasFormatter = true;
+        } catch (InvalidArgumentException $e) {
+            $hasFormatter = false;
         }
 
-        if (method_exists($faker, $field['name'])) {
-            return "\$faker-\>{$field['name']}()";
+        if ($hasFormatter) {
+            return "\$faker->{$field['name']}";
         }
 
         return self::getFakerMethod($field);
     }
 
     protected function checkExistModelFactory(): int
     {
-        $modelFactoryContent = file_get_contents($this->paths['factory']);
+        $modelFactoryContent = file_get_contents(base_path($this->paths['factory']));
         $modelNamespace = $this->getOrCreateNamespace('models');
         $factoryClass = "{$modelNamespace}\\$this->model::class";
 
@@ -262,8 +276,8 @@ protected function getModelClassContent($model): string
         if (!$this->classExists('models', $model)) {
             $this->throwFailureException(
                 ClassNotExistsException::class,
-                "Cannot create {$model} Model cause {$model} Model does not exists.",
-                "Create a {$model} Model by himself or run command 'php artisan make:entity {$model} --only-model'."
+                "Cannot get {$model} Model class content cause {$model} Model does not exists.",
+                "Create a {$model} Model by itself or run command 'php artisan make:entity {$model} --only-model'."
             );
         }
 

src/Generators/MigrationGenerator.php

@@ -3,8 +3,9 @@
 namespace RonasIT\Support\Generators;
 
 use Carbon\Carbon;
-use Exception;
+use Illuminate\Support\Arr;
 use RonasIT\Support\Events\SuccessCreateMessage;
+use RonasIT\Support\Exceptions\UnknownFieldTypeException;
 
 class MigrationGenerator extends EntityGenerator
 {
@@ -34,7 +35,7 @@ protected function isJson($typeName): bool
 
     protected function isRequired($typeName): bool
     {
-        return !empty(explode('-', $typeName)[1]);
+        return Arr::get(explode('-', $typeName), 1) === 'required';
     }
 
     protected function isNullable($typeName): bool
@@ -96,6 +97,6 @@ protected function getTableRow($fieldName, $typeName): string
             return $this->getNonRequiredLine($fieldName, $typeName);
         }
 
-        throw new Exception('Unknown fieldType in MigrationGenerator');
+        throw new UnknownFieldTypeException("Unknown field type {$typeName} in MigrationGenerator.");
     }
 }

src/Generators/ModelGenerator.php

@@ -58,8 +58,8 @@ public function prepareRelatedModels(): void
                 if (!$this->classExists('models', $relation)) {
                     $this->throwFailureException(
                         ClassNotExistsException::class,
-                        "Cannot create {$relation} Model cause {$relation} Model does not exists.",
-                        "Create a {$relation} Model by himself or run command 'php artisan make:entity {$relation} --only-model'."
+                        "Cannot create {$this->model} Model cause relation model {$relation} does not exist.",
+                        "Create the {$relation} Model by himself or run command 'php artisan make:entity {$relation} --only-model'."
                     );
                 }
 
@@ -115,7 +115,7 @@ protected function getCasts($fields): array
         $result = [];
 
         foreach ($fields as $fieldType => $names) {
-            if (empty($casts[$fieldType])) {
+            if (!array_key_exists($fieldType, $casts)) {
                 continue;
             }
 

src/Generators/NovaTestGenerator.php

@@ -62,10 +62,6 @@ protected function getActions(): array
     {
         $actions = $this->loadNovaActions();
 
-        if (empty($actions)) {
-            return [];
-        }
-
         $actions = array_unique(array_map(function ($action) {
             return get_class($action);
         }, $actions));

src/Generators/SeederGenerator.php

@@ -15,28 +15,30 @@ public function __construct()
     {
         parent::__construct();
 
-        $this->seedsPath = Arr::get($this->paths, 'seeders', 'database/seeders');
-        $this->databaseSeederPath = Arr::get($this->paths, 'database_seeder', 'database/seeders/DatabaseSeeder.php');
+        $this->seedsPath = base_path(Arr::get($this->paths, 'seeders', 'database/seeders'));
+        $this->databaseSeederPath = base_path(Arr::get($this->paths, 'database_seeder', 'database/seeders/DatabaseSeeder.php'));
     }
 
     public function generate(): void
     {
         $this->checkConfigs();
 
+        if (!file_exists($this->seedsPath)) {
+            mkdir($this->seedsPath);
+        }
+
         if (!file_exists($this->databaseSeederPath)) {
             list($basePath, $databaseSeederDir) = extract_last_part($this->databaseSeederPath, '/');
 
+            $databaseSeederDir = base_path($databaseSeederDir);
+
             if (!is_dir($databaseSeederDir)) {
                 mkdir($databaseSeederDir);
             }
 
             $this->createDatabaseSeeder();
         }
 
-        if (!is_dir($this->seedsPath)) {
-            mkdir($this->seedsPath);
-        }
-
         $this->createEntitySeeder();
 
         $this->appendSeederToList();
@@ -59,7 +61,7 @@ protected function createDatabaseSeeder(): void
 
     protected function createEntitySeeder(): void
     {
-        $seeder = (version_compare(app()->version(), '8', '>=')) ? 'seeder' : 'legacy_seeder';
+        $seeder = ($this->useClassStyleSeeder()) ? 'seeder' : 'legacy_seeder';
 
         $stubPath = config("entity-generator.stubs.{$seeder}");
 
@@ -70,7 +72,7 @@ protected function createEntitySeeder(): void
             'modelsNamespace' => $this->getOrCreateNamespace('models')
         ])->render();
 
-        $seederPath = base_path("{$this->seedsPath}/{$this->model}Seeder.php");
+        $seederPath = "{$this->seedsPath}/{$this->model}Seeder.php";
 
         file_put_contents($seederPath, $content);
 
@@ -79,6 +81,11 @@ protected function createEntitySeeder(): void
         event(new SuccessCreateMessage($createMessage));
     }
 
+    protected function useClassStyleSeeder(): bool
+    {
+        return version_compare(app()->version(), '8', '>=');
+    }
+
     protected function appendSeederToList(): void
     {
         $content = file_get_contents($this->databaseSeederPath);

src/Generators/TestsGenerator.php

@@ -11,24 +11,6 @@ public function getTestClassName(): string
         return "{$this->model}Test";
     }
 
-    protected function generateExistedEntityFixture()
-    {
-        $object = $this->getFixtureValuesList($this->model);
-        $entity = Str::snake($this->model);
-
-        foreach (self::FIXTURE_TYPES as $type => $modifications) {
-            if ($this->isFixtureNeeded($type)) {
-                foreach ($modifications as $modification) {
-                    $excepts = [];
-                    if ($modification === 'request') {
-                        $excepts = ['id'];
-                    }
-                    $this->generateFixture("{$type}_{$entity}_{$modification}.json", Arr::except($object, $excepts));
-                }
-            }
-        }
-    }
-
     protected function isFixtureNeeded($type): bool
     {
         $firstLetter = strtoupper($type[0]);

src/Generators/TranslationsGenerator.php

@@ -13,7 +13,7 @@ public function __construct()
     {
         parent::__construct();
 
-        $this->translationPath = Arr::get($this->paths, 'translations', 'resources/lang/en/validation.php');
+        $this->translationPath = base_path(Arr::get($this->paths, 'translations', 'resources/lang/en/validation.php'));
     }
 
     public function generate(): void
@@ -29,7 +29,7 @@ public function generate(): void
 
     protected function isTranslationMissed($translation) : bool
     {
-        return __($translation) === 'validation.exceptions.not_found';
+        return __($translation) !== 'validation.exceptions.not_found';
     }
 
     protected function createTranslate(): void
@@ -57,4 +57,4 @@ protected function appendNotFoundException(): void
 
         file_put_contents($this->translationPath, $fixedContent);
     }
-}
+}