[9.x] Return non-zero exit code for uncaught exceptions

src/Illuminate/Foundation/Bootstrap/HandleExceptions.php

@@ -194,17 +194,23 @@ public function handleException(Throwable $e)
     {
         self::$reservedMemory = null;
 
+        $uncaught = false;
+
         try {
             $this->getExceptionHandler()->report($e);
         } catch (Exception $e) {
-            //
+            $uncaught = true;
         }
 
         if (static::$app->runningInConsole()) {
             $this->renderForConsole($e);
         } else {
             $this->renderHttpResponse($e);
         }
+
+        if ($uncaught) {
+            exit(1);
+        }
     }
 
     /**

src/Illuminate/Foundation/Testing/Concerns/MakesArtisanScript.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Illuminate\Foundation\Testing\Concerns;
+
+use Illuminate\Filesystem\Filesystem;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Str;
+use Symfony\Component\Process\PhpExecutableFinder;
+
+trait MakesArtisanScript
+{
+    /**
+     * The file system.
+     *
+     * @var Filesystem|null
+     */
+    protected $fileSystem;
+
+    /**
+     * The contents of the original Artisan file if it exists.
+     *
+     * @var string|null
+     */
+    protected $originalArtisanFile;
+
+    /**
+     * Create an Artisan script in the Laravel testbench core for external testing.
+     *
+     * @param  array<string, callable>|callable  $slots
+     * @return string
+     */
+    public function setUpArtisanScript($slots = []): string
+    {
+        $this->fileSystem = new Filesystem;
+        $path = base_path('artisan');
+
+        $uuid = Str::random(32);
+
+        // Save existing artisan script if there is one.
+        if ($this->fileSystem->exists($path)) {
+            $this->originalArtisanFile = $this->fileSystem->get($path);
+        }
+
+        $this->fileSystem->put(
+            base_path('artisan'),
+            $this->buildArtisanScript($uuid, $slots)
+        );
+
+        return $uuid;
+    }
+
+    /**
+     * Delete an Artisan script and revert it to the cached original.
+     *
+     * @return void
+     */
+    public function tearDownArtisanScript(): void
+    {
+        $this->fileSystem->delete(base_path('artisan'));
+        if (! is_null($this->originalArtisanFile)) {
+            $this->fileSystem->put(base_path('artisan'), $this->originalArtisanFile);
+        }
+    }
+
+    /**
+     * Execute the Artisan script in a separate process and return the output and exit code.
+     *
+     * @param  string  $command
+     * @return array
+     */
+    public function artisanScript($command): array
+    {
+        $output = $exitCode = null;
+        exec((new PhpExecutableFinder)->find().' '.base_path('artisan').' '.$command, $output, $exitCode);
+
+        return [$output, $exitCode];
+    }
+
+    /**
+     * Build a custom Artisan script containing specific scripts.
+     *
+     * @param  string  $uuid
+     * @param  array<string, callable>|callable  $slots
+     * @return string
+     */
+    protected function buildArtisanScript($uuid, $slots = []): string
+    {
+        // If no array is passed, the default "preHandle" slot is assumed.
+        $slots = ! is_array($slots) ? ['preHandle' => $slots] : $slots;
+
+        $thisFile = __FILE__;
+
+        $slots = array_merge([
+            'preBootstrap' => '', 'preKernel' => '', 'preHandle' => '', 'preTerminate' => '', 'preExit' => '',
+        ], Arr::map($slots, fn ($part) => value($part, $uuid)));
+
+        return <<<PHP
+#!/usr/bin/env php
+<?php
+
+define('LARAVEL_START', microtime(true));
+
+// This is a custom artisan testing script made specifically for:
+// File: {$thisFile}
+// Uuid: {$uuid}
+
+require __DIR__.'/../../../autoload.php';
+
+{$slots['preBootstrap']}
+
+\$app = require_once __DIR__.'/bootstrap/app.php';
+
+{$slots['preKernel']}
+
+\$kernel = \$app->make(Illuminate\Contracts\Console\Kernel::class);
+
+{$slots['preHandle']}
+
+\$status = \$kernel->handle(
+    \$input = new Symfony\Component\Console\Input\ArgvInput,
+    new Symfony\Component\Console\Output\ConsoleOutput
+);
+
+{$slots['preTerminate']}
+
+\$kernel->terminate(\$input, \$status);
+
+{$slots['preExit']}
+
+exit(\$status);
+
+PHP;
+    }
+}

tests/Integration/Foundation/ExceptionHandlerTest.php

@@ -4,11 +4,14 @@
 
 use Illuminate\Auth\Access\AuthorizationException;
 use Illuminate\Auth\Access\Response;
+use Illuminate\Foundation\Testing\Concerns\MakesArtisanScript;
 use Illuminate\Support\Facades\Route;
 use Orchestra\Testbench\TestCase;
 
 class ExceptionHandlerTest extends TestCase
 {
+    use MakesArtisanScript;
+
     public function testItRendersAuthorizationExceptions()
     {
         Route::get('test-route', fn () => Response::deny('expected message', 321)->authorize());
@@ -107,4 +110,67 @@ public function testItHasFallbackErrorMessageForUnknownStatusCodes()
                 'message' => 'Whoops, looks like something went wrong.',
             ]);
     }
+
+    /**
+     * @dataProvider exitCodesProvider
+     */
+    public function testItReturnsNonZeroExitCodesForUncaughtExceptions($shouldThrow)
+    {
+        $this->setUpArtisanScript(function () use ($shouldThrow) {
+            return <<<PHP
+class ThrowExceptionCommand extends \Illuminate\Console\Command
+{
+    protected \$signature = 'throw-exception-command';
+
+    public function handle()
+    {
+        throw new \Exception('Thrown inside ThrowExceptionCommand');
+    }
+}
+
+class ThrowExceptionLogHandler extends \Monolog\Handler\AbstractProcessingHandler
+{
+    protected function write(array \$record): void
+    {
+        if ({$shouldThrow}) {
+            throw new \Exception('Thrown inside ThrowExceptionLogHandler');
+        }
+    }
+}
+
+\$config = \$app['config'];
+
+\$config->set('logging.channels.stack', [
+    'driver' => 'stack',
+    'path' => storage_path('logs/stacklog.log'),
+    'channels' => ['throw_exception'],
+    'ignore_exceptions' => false,
+]);
+
+\$config->set('logging.channels.throw_exception', [
+    'driver' => 'monolog',
+    'handler' => ThrowExceptionLogHandler::class,
+]);
+
+Illuminate\Console\Application::starting(function (\$artisan) {
+    \$artisan->add(new ThrowExceptionCommand);
+});
+
+PHP;
+        });
+
+        [, $exitCode] = $this->artisanScript('throw-exception-command');
+
+        $this->assertEquals($shouldThrow, $exitCode);
+
+        $this->tearDownArtisanScript();
+    }
+
+    public static function exitCodesProvider()
+    {
+        return [
+            ['Throw exception' => 1],
+            ['Do not throw exception' => 0],
+        ];
+    }
 }