Add factory tests

config/entity-generator.php

@@ -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/Exceptions/FakerMethodNotFound.php

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

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\FakerMethodNotFound;
 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")) {
             $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'),
             '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;
-    }
-
-    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);
-        $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,";
-
-                $modelFactoryContent = str_replace($match, $match . $newField, $modelFactoryContent);
-            }
+        $message = "Cannot generate fake data for unsupported {$field['type']} field type. "
+            . "Supported custom field types are " . implode(', ', array_keys(self::CUSTOM_METHODS));
 
-            file_put_contents($this->paths['factory'], $modelFactoryContent);
-        }
+        throw new FakerMethodNotFound($message);
     }
 
     public static function getFactoryFieldsContent($field): string
@@ -193,80 +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";
-    }
-
-    protected function getModelClass($model): string
-    {
-        $modelNamespace = $this->getOrCreateNamespace('models');
-
-        return "{$modelNamespace}\\{$model}";
-    }
-
-    protected function getRelatedModels($model)
-    {
-        $content = $this->getModelClassContent($model);
-
-        preg_match_all('/(?<=belongsTo\().*(?=::class)/', $content, $matches);
-
-        return head($matches);
-    }
-
-    protected function getModelClassContent($model): string
-    {
-        $path = base_path("{$this->paths['models']}/{$model}.php");
-
-        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'."
-            );
-        }
-
-        return file_get_contents($path);
-    }
 }

stubs/factory.blade.php

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

tests/ControllerGeneratorTest.php

@@ -27,7 +27,7 @@ public function testControllerAlreadyExists()
             $this->classExistsMethodCall(['controllers', 'PostController'])
         ]);
 
-        $this->assertExceptionThrowed(
+        $this->assertExceptionThrew(
             className: ClassAlreadyExistsException::class,
             message: 'Cannot create PostController cause PostController already exists. Remove PostController.',
         );
@@ -44,7 +44,7 @@ public function testModelServiceNotExists()
             $this->classExistsMethodCall(['services', 'PostService'], false)
         ]);
 
-        $this->assertExceptionThrowed(
+        $this->assertExceptionThrew(
             className: ClassNotExistsException::class,
             message: 'Cannot create PostService cause PostService does not exists. Create a PostService by himself.',
         );
@@ -58,7 +58,7 @@ public function testRouteFileNotExists()
     {
         $this->mockFilesystemWithoutRoutesFile();
 
-        $this->assertExceptionThrowed(
+        $this->assertExceptionThrew(
             className: FileNotFoundException::class,
             message: "Not found file with routes. Create a routes file on path: 'vfs://root/routes/api.php'",
         );