Uses a database per process regardless of the used database testing t…

…rait
laravel · taylorotwell · Jan 13, 2021 · Jan 4, 2021 · Jan 4, 2021 · Jan 4, 2021
commit 5697ee4f50c290e33b6fafac7ec09ec61ba115f3
diff --git a/src/Illuminate/Foundation/Testing/RefreshDatabase.php b/src/Illuminate/Foundation/Testing/RefreshDatabase.php
@@ -3,8 +3,6 @@
 namespace Illuminate\Foundation\Testing;
 
 use Illuminate\Contracts\Console\Kernel;
-use Illuminate\Support\Facades\Schema;
-use Illuminate\Support\Facades\Testing;
 
 trait RefreshDatabase
 {
@@ -15,15 +13,9 @@ trait RefreshDatabase
      */
     public function refreshDatabase()
     {
-        if ($this->usingInMemoryDatabase()) {
-            return $this->refreshInMemoryDatabase();
-        }
-
-        Testing::whenRunningInParallel(function () {
-            $this->switchToTemporaryDatabase();
-        });
-
-        $this->refreshTestDatabase();
+        $this->usingInMemoryDatabase()
+                        ? $this->refreshInMemoryDatabase()
+                        : $this->refreshTestDatabase();
     }
 
     /**
@@ -38,68 +30,6 @@ protected function usingInMemoryDatabase()
         return config("database.connections.$default.database") === ':memory:';
     }
 
-    /**
-     * Switch to the temporary test database.
-     *
-     * @return void
-     */
-    protected function switchToTemporaryDatabase()
-    {
-        $default = config('database.default');
-
-        config()->set(
-            "database.connections.{$default}.database",
-            RefreshDatabaseState::$temporaryDatabase,
-        );
-    }
-
-    /**
-     * Creates a temporary database, if needed.
-     *
-     * @beforeClass
-     *
-     * @return void
-     */
-    public static function setUpTemporaryDatabase()
-    {
-        tap(new static(), function ($testCase) {
-            $testCase->refreshApplication();
-
-            if ($testCase->usingInMemoryDatabase()) {
-                return;
-            }
-
-            Testing::whenRunningInParallel(function () use ($testCase) {
-                $name = $testCase->getConnection()->getConfig('database');
-
-                RefreshDatabaseState::$temporaryDatabase = Testing::addTokenIfNeeded($name);
-
-                Schema::dropDatabaseIfExists(RefreshDatabaseState::$temporaryDatabase);
-                Schema::createDatabase(RefreshDatabaseState::$temporaryDatabase);
-            });
-        })->app->flush();
-    }
-
-    /**
-     * Drop the temporary database, if any.
-     *
-     * @afterClass
-     *
-     * @return void
-     */
-    public static function tearDownTemporaryDatabase()
-    {
-        if (RefreshDatabaseState::$temporaryDatabase) {
-            tap(new static(), function ($testCase) {
-                $testCase->refreshApplication();
-
-                Schema::dropDatabaseIfExists(
-                    RefreshDatabaseState::$temporaryDatabase,
-                );
-            })->app->flush();
-        }
-    }
-
     /**
      * Refresh the in-memory database.
      *

diff --git a/src/Illuminate/Foundation/Testing/RefreshDatabaseState.php b/src/Illuminate/Foundation/Testing/RefreshDatabaseState.php
@@ -10,11 +10,4 @@ class RefreshDatabaseState
      * @var bool
      */
     public static $migrated = false;
-
-    /**
-     * The temporary database name, if any.
-     *
-     * @var string|null
-     */
-    public static $temporaryDatabase;
 }
diff --git a/src/Illuminate/Foundation/Testing/TestCase.php b/src/Illuminate/Foundation/Testing/TestCase.php
@@ -7,6 +7,7 @@
 use Illuminate\Console\Application as Artisan;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Facades\Facade;
+use Illuminate\Testing\ParallelTesting;
 use Illuminate\Support\Str;
 use Mockery;
 use Mockery\Exception\InvalidCountException;
@@ -83,6 +84,8 @@ protected function setUp(): void
             $this->refreshApplication();
         }
 
+        $this->app[ParallelTesting::class]->setUpIfNeeded($this);
+
         $this->setUpTraits();
 
         foreach ($this->afterApplicationCreatedCallbacks as $callback) {

diff --git a/src/Illuminate/Support/Facades/Storage.php b/src/Illuminate/Support/Facades/Storage.php
@@ -3,6 +3,7 @@
 namespace Illuminate\Support\Facades;
 
 use Illuminate\Filesystem\Filesystem;
+use Illuminate\Testing\ParallelTesting;
 
 /**
  * @method static \Illuminate\Contracts\Filesystem\Filesystem assertExists(string|array $path)
@@ -54,7 +55,7 @@ public static function fake($disk = null, array $config = [])
             $root = storage_path('framework/testing/disks/'.$disk)
         );
 
-        $root = Testing::addTokenIfNeeded($root);
+        $root = static::$app[ParallelTesting::class]->addTokenIfNeeded($root);
 
         static::set($disk, $fake = static::createLocalDriver(array_merge($config, [
             'root' => $root,

diff --git a/src/Illuminate/Support/Facades/Testing.php b/src/Illuminate/Support/Facades/Testing.php
diff --git a/src/Illuminate/Testing/ParallelConsoleOutput.php b/src/Illuminate/Testing/ParallelConsoleOutput.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Illuminate\Testing;
+
+use Illuminate\Support\Arr;
+use Illuminate\Support\Str;
+use Symfony\Component\Console\Output\ConsoleOutput;
+
+class ParallelConsoleOutput extends ConsoleOutput
+{
+    /**
+     * The original output instance.
+     *
+     * @var \Symfony\Component\Console\Output\OutputInterface
+     */
+    protected $output;
+
+    /**
+     * The output that should be ignored.
+     *
+     * @var array
+     */
+    protected $ignore = [
+        'Running phpunit in',
+        'Configuration read from',
+    ];
+
+    /**
+     * Create a new Parallel ConsoleOutput instance.
+     *
+     * @param  \Symfony\Component\Console\Output\OutputInterface
+     * @return void
+     */
+    public function __construct($output)
+    {
+        parent::__construct(
+            $output->getVerbosity(),
+            $output->isDecorated(),
+            $output->getFormatter(),
+        );
+
+        $this->output = $output;
+    }
+
+    /**
+     * Writes a message to the output.
+     *
+     * @param  string|iterable  $messages
+     * @param  bool  $newline
+     * @param  int  $options
+     * @return void
+     */
+    public function write($messages, bool $newline = false, int $options = 0)
+    {
+        $messages = collect($messages)->filter(function ($message) {
+            return ! Str::contains($message, $this->ignore);
+        });
+
+        $this->output->write($messages->toArray(), $newline, $options);
+    }
+}
diff --git a/src/Illuminate/Testing/ParallelRunner.php b/src/Illuminate/Testing/ParallelRunner.php
@@ -0,0 +1,136 @@
+<?php
+
+namespace Illuminate\Testing;
+
+use Illuminate\Contracts\Console\Kernel;
+use Illuminate\Support\Facades\Schema;
+use ParaTest\Runners\PHPUnit\Options;
+use ParaTest\Runners\PHPUnit\RunnerInterface;
+use ParaTest\Runners\PHPUnit\WrapperRunner;
+use Symfony\Component\Console\Output\ConsoleOutput;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class ParallelRunner implements RunnerInterface
+{
+    /**
+     * The application resolver callback.
+     *
+     * @var \Closure|null
+     */
+    protected static $applicationResolver;
+
+    /**
+     * The original test runner options.
+     *
+     * @var \ParaTest\Runners\PHPUnit\Options
+     */
+    protected $options;
+
+    /**
+     * The output instance.
+     *
+     * @var \Symfony\Component\Console\Output\OutputInterface
+     */
+    protected $output;
+
+    /**
+     * The original test runner.
+     *
+     * @var \ParaTest\Runners\PHPUnit\RunnerInterface
+     */
+    protected $runner;
+
+    /**
+     * Creates a new test runner instance.
+     *
+     * @param  \ParaTest\Runners\PHPUnit\Options  $options
+     * @param  \Symfony\Component\Console\Output\OutputInterface  $output
+     * @return void
+     */
+    public function __construct(Options $options, OutputInterface $output)
+    {
+        $this->options = $options;
+
+        if ($output instanceof ConsoleOutput) {
+            $output = new ParallelConsoleOutput($output);
+        }
+
+        $this->runner = new WrapperRunner($options, $output);
+    }
+
+    /**
+     * Set the application resolver callback.
+     *
+     * @param  \Closure|null  $resolver
+     * @return void
+     */
+    public static function resolveApplicationUsing($resolver)
+    {
+        static::$applicationResolver = $resolver;
+    }
+
+    /**
+     * Runs the test suite.
+     *
+     * @return void
+     */
+    public function run(): void
+    {
+        try {
+            $this->runner->run();
+        } catch (Throwable $e) {
+            throw $e;
+        } finally {
+            $this->forEachProcess(function ($app) {
+                $app[ParallelTesting::class]->beforeProcessDestroyed();
+            });
+        }
+    }
+
+    /**
+     * Returns the highest exit code encountered throughout the course of test execution.
+     *
+     * @return int
+     */
+    public function getExitCode(): int
+    {
+        return $this->runner->getExitCode();
+    }
+
+    /**
+     * Apply the given callback for each process.
+     *
+     * @param  callable $callback
+     * @return void
+     */
+    protected function forEachProcess($callback)
+    {
+        collect(range(1, $this->options->processes()))->each(function ($token) use ($callback) {
+            tap($this->createApplication(), function ($app) use ($callback, $token) {
+                ParallelTesting::resolveTokenUsing(function () use ($token) {
+                    return $token;
+                });
+
+                $callback($app);
+            })->flush();
+        });
+    }
+
+    /**
+     * Creates the application.
+     *
+     * @return \Illuminate\Contracts\Foundation\Application
+     */
+    protected function createApplication()
+    {
+        $applicationResolver = static::$applicationResolver ?: function () {
+            $applicationCreator = new class {
+                use \Tests\CreatesApplication;
+            };
+
+            return $applicationCreator->createApplication();
+        };
+
+        return call_user_func($applicationResolver);
+    }
+}