Add factory tests

config/entity-generator.php

@@ -16,7 +16,7 @@
         'repositories' => 'app/Repositories',
         'tests' => 'tests',
         'routes' => 'routes/api.php',
-        'factory' => 'database/factories/ModelFactory.php',
+        'factories' => 'database/factories',
         'translations' => 'resources/lang/en/validation.php',
         'resources' => 'app/Http/Resources',
         'nova' => 'app/Nova',
@@ -32,8 +32,6 @@
         'routes' => 'entity-generator::routes',
         'use_routes' => 'entity-generator::use_routes',
         'factory' => 'entity-generator::factory',
-        'legacy_factory' => 'entity-generator::legacy_factory',
-        'legacy_empty_factory' => 'entity-generator::legacy_empty_factory',
         'seeder' => 'entity-generator::seeder',
         'legacy_seeder' => 'entity-generator::legacy_seeder',
         'database_empty_seeder' => 'entity-generator::database_empty_seeder',

src/Commands/MakeEntityCommand.php

@@ -2,7 +2,6 @@
 
 namespace RonasIT\Support\Commands;
 
-use Closure;
 use Illuminate\Console\Command;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\Config;
@@ -217,10 +216,9 @@ protected function outputNewConfig($packageConfigs, $projectConfigs)
         }
 
         $factories = 'database/factories';
-        $factories = (version_compare(app()->version(), '8', '>=')) ? $factories : "{$factories}/ModelFactory.php";
 
-        if ($newConfig['paths.factory'] !== $factories) {
-            $newConfig['paths.factory'] = $factories;
+        if ($newConfig['paths.factories'] !== $factories) {
+            $newConfig['paths.factories'] = $factories;
         }
 
         $differences = array_diff_key($newConfig, $flattenedProjectConfigs);

src/Exceptions/FakerMethodNotFoundException.php

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

src/Generators/AbstractTestsGenerator.php

@@ -89,14 +89,11 @@ protected function getInserts(): array
         }, $this->buildRelationsTree($arrayModels));
     }
 
-    protected function isFactoryExists($modelName): bool
+    protected function isFactoryExists(string $modelName): bool
     {
-        $factory = app(LegacyFactories::class);
         $modelClass = $this->getModelClass($modelName);
 
-        $isNewStyleFactoryExists = $this->classExists('factory', "{$modelName}Factory") && method_exists($modelClass, 'factory');
-
-        return $isNewStyleFactoryExists || !empty($factory[$this->getModelClass($modelName)]);
+        return $this->classExists('factories', "{$modelName}Factory") && method_exists($modelClass, 'factory');
     }
 
     protected function isMethodExists($modelName, $method): bool
@@ -170,13 +167,14 @@ protected function getModelFields($model): array
 
     protected function getMockModel($model): array
     {
-        if (!$this->isFactoryExists($model)) {
+        $hasFactory = $this->isFactoryExists($model);
+
+        if (!$hasFactory) {
             return [];
         }
 
         $modelClass = $this->getModelClass($model);
-        $hasFactory = method_exists($modelClass, 'factory') && $this->classExists('factory', "{$model}Factory");
-        $factory = ($hasFactory) ? $modelClass::factory() : factory($modelClass);
+        $factory = $modelClass::factory();
 
         return $factory
             ->make()

src/Generators/FactoryGenerator.php

@@ -5,12 +5,11 @@
 use Faker\Generator as Faker;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Str;
-use RonasIT\Support\Exceptions\ModelFactoryNotFound;
+use InvalidArgumentException;
+use RonasIT\Support\Exceptions\FakerMethodNotFoundException;
 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
 {
@@ -26,109 +25,33 @@ class FactoryGenerator extends EntityGenerator
         'json' => '[]',
     ];
 
-    protected function generateSeparateClass(): string
+    public function generate(): void
     {
         if (!$this->classExists('models', $this->model)) {
             $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'."
+                exceptionClass: ClassNotExistsException::class,
+                failureMessage: "Cannot create {$this->model}Factory cause {$this->model} Model does not exists.",
+                recommendedMessage: "Create a {$this->model} Model by itself or run command 'php artisan make:entity {$this->model} --only-model'.",
             );
         }
 
-        if ($this->classExists('factory', "{$this->model}Factory")) {
+        if ($this->classExists('factories', "{$this->model}Factory")) {
             $this->throwFailureException(
-                ClassAlreadyExistsException::class,
-                "Cannot create {$this->model}Factory cause {$this->model}Factory already exists.",
-                "Remove {$this->model}Factory."
+                exceptionClass: ClassAlreadyExistsException::class,
+                failureMessage: "Cannot create {$this->model}Factory cause {$this->model}Factory already exists.",
+                recommendedMessage: "Remove {$this->model}Factory.",
             );
         }
 
         $factoryContent = $this->getStub('factory', [
-            'namespace' => $this->getOrCreateNamespace('factory'),
+            'namespace' => $this->getOrCreateNamespace('factories'),
             'entity' => $this->model,
-            'fields' => $this->prepareFields()
+            'fields' => $this->prepareFields(),
         ]);
 
-        $this->saveClass('factory', "{$this->model}Factory", $factoryContent);
-
-        return "Created a new Factory: {$this->model}Factory";
-    }
-
-    protected function generateToGenericClass(): string
-    {
-        if (!file_exists($this->paths['factory'])) {
-            $this->prepareEmptyFactory();
-        }
-
-        if (!$this->checkExistModelFactory() && $this->checkExistRelatedModelsFactories()) {
-            $stubPath = config("entity-generator.stubs.legacy_factory");
-
-            $content = view($stubPath)->with([
-                'entity' => $this->model,
-                'fields' => $this->prepareFields(),
-                'modelsNamespace' => $this->getOrCreateNamespace('models')
-            ])->render();
-
-            $content = "\n\n" . $content;
-
-            $createMessage = "Created a new Test factory for {$this->model} model in '{$this->paths['factory']}'";
-
-            file_put_contents($this->paths['factory'], $content, FILE_APPEND);
-
-            $this->prepareRelatedFactories();
-        } else {
-            $createMessage = "Factory for {$this->model} model has already created, so new factory not necessary create.";
-        }
-
-        return $createMessage;
-    }
+        $this->saveClass('factories', "{$this->model}Factory", $factoryContent);
 
-    public function generate(): void
-    {
-        $createMessage = (version_compare(app()->version(), '8', '>='))
-            ? $this->generateSeparateClass()
-            : $this->generateToGenericClass();
-
-        event(new SuccessCreateMessage($createMessage));
-    }
-
-    protected function prepareEmptyFactory(): void
-    {
-        $stubPath = config('entity-generator.stubs.legacy_empty_factory');
-        $content = "<?php \n\n" . view($stubPath, [
-            'modelsNamespace' => $this->getOrCreateNamespace('models')
-        ])->render();
-
-        list($basePath, $databaseFactoryDir) = extract_last_part(config('entity-generator.paths.factory'), '/');
-
-        if (!is_dir($databaseFactoryDir)) {
-            mkdir($databaseFactoryDir);
-        }
-
-        file_put_contents($this->paths['factory'], $content);
-    }
-
-    protected function checkExistRelatedModelsFactories(): bool
-    {
-        $modelFactoryContent = file_get_contents($this->paths['factory']);
-        $relatedModels = $this->getRelatedModels($this->model, "{$this->model}Factory");
-        $modelNamespace = $this->getOrCreateNamespace('models');
-
-        foreach ($relatedModels as $relatedModel) {
-            $relatedFactoryClass = "{$modelNamespace}\\$relatedModel::class";
-            $existModelFactory = strpos($modelFactoryContent, $relatedFactoryClass);
-
-            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'."
-                );
-            }
-        }
-
-        return true;
+        event(new SuccessCreateMessage("Created a new Factory: {$this->model}Factory"));
     }
 
     protected static function getFakerMethod($field): string
@@ -146,42 +69,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);
-    }
-
-    protected function prepareRelatedFactories(): void
-    {
-        $relations = array_merge(
-            $this->relations['hasOne'],
-            $this->relations['hasMany']
-        );
-
-        foreach ($relations as $relation) {
-            $modelFactoryContent = file_get_contents($this->paths['factory']);
-
-            if (!Str::contains($modelFactoryContent, $this->getModelClass($relation))) {
-                $this->throwFailureException(
-                    ModelFactoryNotFound::class,
-                    "Model factory for mode {$relation} not found.",
-                    "Please create it and after thar you can run this command with flag '--only-tests'."
-                );
-            }
-
-            $matches = [];
-
-            preg_match($this->getFactoryPattern($relation), $modelFactoryContent, $matches);
-
-            foreach ($matches as $match) {
-                $field = Str::snake($this->model) . '_id';
-
-                $newField = "\n        \"{$field}\" => 1,";
+        $message = "Cannot generate fake data for unsupported {$field['type']} field type. "
+            . "Supported custom field types are " . implode(', ', array_keys(self::CUSTOM_METHODS));
 
-                $modelFactoryContent = str_replace($match, $match . $newField, $modelFactoryContent);
-            }
-
-            file_put_contents($this->paths['factory'], $modelFactoryContent);
-        }
+        throw new FakerMethodNotFoundException($message);
     }
 
     public static function getFactoryFieldsContent($field): string
@@ -193,49 +84,33 @@ 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']);
-        $modelNamespace = $this->getOrCreateNamespace('models');
-        $factoryClass = "{$modelNamespace}\\$this->model::class";
-
-        return strpos($modelFactoryContent, $factoryClass);
-    }
-
     protected function prepareFields(): array
     {
         $result = [];
 
         foreach ($this->fields as $type => $fields) {
             foreach ($fields as $field) {
-                $explodedType = explode('-', $type);
-
                 $result[] = [
                     'name' => $field,
-                    'type' => head($explodedType)
+                    'type' => Str::before($type, '-'),
                 ];
             }
         }
 
         return $result;
     }
-
-    protected function getFactoryPattern($model): string
-    {
-        $modelNamespace = "App\\\\Models\\\\" . $model;
-        $return = "return \\[";
-
-        return "/{$modelNamespace}.*{$return}/sU";
-    }
 }

stubs/factory.blade.php

@@ -17,4 +17,4 @@ public function definition(): array
 @endforeach
         ];
     }
-}
+}