Adds ModelFactory support for hyperf/testing (#5894)

Author: huangdijia

composer.json

@@ -32,6 +32,9 @@
         "hyperf/utils": "~3.1.0",
         "symfony/http-foundation": "^5.4|^6.0"
     },
+    "suggest": {
+        "fakerphp/faker": "Required to use Faker feature.(^1.23)"
+    },
     "extra": {
         "branch-alias": {
             "dev-master": "3.0-dev"

src/Concerns/InteractsWithModelFactory.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  [email protected]
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+namespace Hyperf\Testing\Concerns;
+
+use Faker\Factory as FakerFactory;
+use Hyperf\Testing\ModelFactory;
+
+trait InteractsWithModelFactory
+{
+    protected ?ModelFactory $modelFactory = null;
+
+    protected string|array $factoryPath = BASE_PATH . '/database/factories';
+
+    protected function setUpInteractsWithModelFactory()
+    {
+        if (! class_exists(FakerFactory::class)) {
+            return;
+        }
+
+        $this->modelFactory = ModelFactory::create(
+            FakerFactory::create('en_US')
+        );
+
+        foreach ((array) $this->factoryPath as $path) {
+            if (is_dir($path)) {
+                $this->modelFactory->load($path);
+            }
+        }
+    }
+
+    protected function tearDownInteractsWithModelFactory()
+    {
+        $this->modelFactory = null;
+    }
+}

src/ModelFactory.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  [email protected]
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+namespace Hyperf\Testing;
+
+use Faker\Generator;
+use Hyperf\Database\Model\Factory;
+
+/**
+ * @template T
+ */
+class ModelFactory
+{
+    public function __construct(protected Factory $factory)
+    {
+    }
+
+    public static function create(Generator $faker)
+    {
+        return new static(new Factory($faker));
+    }
+
+    /**
+     * @param class-string<T> $model
+     * @return T
+     */
+    public function factory(string $model, ...$arguments)
+    {
+        $factory = $this->factory;
+
+        if (isset($arguments[1]) && is_string($arguments[1])) {
+            return $factory->of($arguments[0], $arguments[1])->times($arguments[2] ?? null);
+        }
+        if (isset($arguments[1])) {
+            return $factory->of($arguments[0])->times($arguments[1]);
+        }
+
+        return $factory->of($arguments[0]);
+    }
+
+    public function load(string $path): void
+    {
+        $this->factory->load($path);
+    }
+}

src/TestCase.php

@@ -14,28 +14,105 @@
 use Mockery as m;
 use Throwable;
 
+use function Hyperf\Support\class_basename;
+use function Hyperf\Support\class_uses_recursive;
+
 /**
  * @internal
  * @coversNothing
  */
 abstract class TestCase extends \PHPUnit\Framework\TestCase
 {
     use Concerns\InteractsWithContainer;
+    use Concerns\InteractsWithModelFactory;
     use Concerns\MakesHttpRequests;
     use Concerns\RunTestsInCoroutine;
 
+    /**
+     * The callbacks that should be run after the application is created.
+     */
+    protected array $afterApplicationCreatedCallbacks = [];
+
+    /**
+     * The callbacks that should be run before the application is destroyed.
+     */
+    protected array $beforeApplicationDestroyedCallbacks = [];
+
+    /**
+     * The exception thrown while running an application destruction callback.
+     */
+    protected ?Throwable $callbackException = null;
+
     protected function setUp(): void
     {
         $this->refreshContainer();
+
+        $this->setUpTraits();
+
+        foreach ($this->afterApplicationCreatedCallbacks as $callback) {
+            $callback();
+        }
     }
 
     protected function tearDown(): void
     {
         $this->flushContainer();
 
+        $this->callBeforeApplicationDestroyedCallbacks();
+
         try {
             m::close();
-        } catch (Throwable) {
+        } catch (Throwable $e) {
+        }
+
+        if ($this->callbackException) {
+            throw $this->callbackException;
+        }
+    }
+
+    /**
+     * Boot the testing helper traits.
+     *
+     * @return array
+     */
+    protected function setUpTraits()
+    {
+        $uses = array_flip(class_uses_recursive(static::class));
+
+        foreach ($uses as $trait) {
+            if (method_exists($this, $method = 'setUp' . class_basename($trait))) {
+                $this->{$method}();
+            }
+
+            if (method_exists($this, $method = 'tearDown' . class_basename($trait))) {
+                $this->beforeApplicationDestroyed(fn () => $this->{$method}());
+            }
+        }
+
+        return $uses;
+    }
+
+    /**
+     * Register a callback to be run before the application is destroyed.
+     */
+    protected function beforeApplicationDestroyed(callable $callback)
+    {
+        $this->beforeApplicationDestroyedCallbacks[] = $callback;
+    }
+
+    /**
+     * Execute the application's pre-destruction callbacks.
+     */
+    protected function callBeforeApplicationDestroyedCallbacks()
+    {
+        foreach ($this->beforeApplicationDestroyedCallbacks as $callback) {
+            try {
+                $callback();
+            } catch (Throwable $e) {
+                if (! $this->callbackException) {
+                    $this->callbackException = $e;
+                }
+            }
         }
     }
 }