CI: Only enable Whoops when it is tested

phpunit.xml.dist

@@ -5,6 +5,7 @@
 	xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd"
 
 	bootstrap="tests/bootstrap.php"
+	convertDeprecationsToExceptions="true"
 	colors="true"
 	verbose="true"
 	stderr="true"

src/Cms/AppErrors.php

@@ -26,6 +26,15 @@
  */
 trait AppErrors
 {
+	/**
+	 * Allows to disable Whoops globally in CI;
+	 * can be overridden by explicitly setting
+	 * the `whoops` option to `true` or `false`
+	 *
+	 * @internal
+	 */
+	public static bool $enableWhoops = true;
+
 	/**
 	 * Whoops instance cache
 	 */
@@ -45,6 +54,17 @@ protected function handleCliErrors(): void
 	 */
 	protected function handleErrors(): void
 	{
+		// no matter the environment, exit early if
+		// Whoops was disabled globally
+		// (but continue if the option was explicitly
+		// set to `true` in the config)
+		if (
+			static::$enableWhoops === false &&
+			$this->option('whoops') !== true
+		) {
+			return;
+		}
+
 		if ($this->environment()->cli() === true) {
 			$this->handleCliErrors();
 			return;

tests/Cms/App/AppErrorsTest.php

@@ -15,15 +15,37 @@
  */
 class AppErrorsTest extends TestCase
 {
+	protected App|null $originalApp;
+
+	public function setUp(): void
+	{
+		parent::setUp();
+
+		// Whoops is normally enabled by default, but disabled in CI
+		// to reduce memory leaks; in this test class we need it!
+		$this->originalApp = $this->app;
+		$this->app = $this->originalApp->clone([
+			'options' => [
+				'whoops' => true
+			]
+		]);
+	}
+
 	public function tearDown(): void
 	{
 		$unsetMethod = new ReflectionMethod(App::class, 'unsetWhoopsHandler');
 		$unsetMethod->setAccessible(true);
 
 		$app = App::instance();
 		$unsetMethod->invoke($app);
+		$unsetMethod->invoke($this->app);
+		$unsetMethod->invoke($this->originalApp);
 
 		parent::tearDown();
+		$this->originalApp = null;
+
+		// reset to the value set by tests/bootstrap.php
+		App::$enableWhoops = false;
 	}
 
 	/**
@@ -166,6 +188,39 @@ public function testHandleErrors3()
 		$this->assertInstanceOf('Whoops\Handler\CallbackHandler', $handlers[1]);
 	}
 
+	/**
+	 * @covers ::handleErrors
+	 */
+	public function testHandleErrorsGlobalSetting()
+	{
+		$whoopsMethod = new ReflectionMethod(App::class, 'whoops');
+		$whoopsMethod->setAccessible(true);
+
+		$testMethod = new ReflectionMethod(App::class, 'handleErrors');
+		$testMethod->setAccessible(true);
+
+		$whoopsEnabled  = $whoopsMethod->invoke($this->app);
+		$whoopsDisabled = $whoopsMethod->invoke($this->originalApp);
+
+		$testMethod->invoke($this->app);
+		$handlers = $whoopsEnabled->getHandlers();
+		$this->assertCount(2, $handlers);
+
+		$testMethod->invoke($this->originalApp);
+		$handlers = $whoopsDisabled->getHandlers();
+		$this->assertCount(0, $handlers);
+
+		App::$enableWhoops = true;
+
+		$testMethod->invoke($this->app);
+		$handlers = $whoopsEnabled->getHandlers();
+		$this->assertCount(2, $handlers);
+
+		$testMethod->invoke($this->originalApp);
+		$handlers = $whoopsDisabled->getHandlers();
+		$this->assertCount(2, $handlers);
+	}
+
 	/**
 	 * @covers ::handleHtmlErrors
 	 * @covers ::getAdditionalWhoopsHandler

tests/Cms/App/AppTest.php

@@ -727,12 +727,14 @@ public function testOptionsOnReady()
 						'error'        => $kirby->site()->content()->error()->value(),
 						'slugs'        => 'de'
 					];
-				}
+				},
+				'whoops' => true
 			]
 		]);
 
 		$this->assertSame([
 			'ready' => $ready,
+			'whoops' => true,
 			'test' => '/dev/null',
 			'another.test' => 'foo',
 			'debug' => true,

tests/Cms/Helpers/HelperFunctionsTest.php

@@ -7,6 +7,8 @@
 use Kirby\Filesystem\Dir;
 use Kirby\Toolkit\Collection;
 use Kirby\Toolkit\Obj;
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\Error\Deprecated;
 
 class HelperFunctionsTest extends TestCase
 {
@@ -188,10 +190,15 @@ public function testDeprecated()
 	{
 		// the deprecation warnings are always triggered in testing mode,
 		// so we cannot test it with disabled debug mode
-		$this->expectException('Whoops\Exception\ErrorException');
-		$this->expectExceptionMessage('The xyz method is deprecated.');
 
-		deprecated('The xyz method is deprecated.');
+		try {
+			deprecated('The xyz method is deprecated.');
+		} catch (Deprecated $e) {
+			$this->assertSame('The xyz method is deprecated.', $e->getMessage());
+			return;
+		}
+
+		Assert::fail('Expected deprecation warning was not generated');
 	}
 
 	public function testDumpOnCli()

tests/Cms/Helpers/HelpersTest.php

@@ -4,6 +4,9 @@
 
 use Kirby\Exception\InvalidArgumentException;
 use Kirby\Toolkit\Obj;
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\Error\Deprecated;
+use PHPUnit\Framework\Error\Warning;
 
 /**
  * @coversDefaultClass Kirby\Cms\Helpers
@@ -39,33 +42,46 @@ public function testDeprecated()
 	{
 		// the deprecation warnings are always triggered in testing mode,
 		// so we cannot test it with disabled debug mode
-		$this->expectException('Whoops\Exception\ErrorException');
-		$this->expectExceptionMessage('The xyz method is deprecated.');
 
-		Helpers::deprecated('The xyz method is deprecated.');
+		try {
+			Helpers::deprecated('The xyz method is deprecated.');
+		} catch (Deprecated $e) {
+			$this->assertSame('The xyz method is deprecated.', $e->getMessage());
+			return;
+		}
+
+		Assert::fail('Expected deprecation warning was not generated');
 	}
 
 	/**
 	 * @covers ::deprecated
 	 */
 	public function testDeprecatedKeyUndefined()
 	{
-		$this->expectException('Whoops\Exception\ErrorException');
-		$this->expectExceptionMessage('The xyz method is deprecated.');
+		try {
+			Helpers::deprecated('The xyz method is deprecated.', 'my-key');
+		} catch (Deprecated $e) {
+			$this->assertSame('The xyz method is deprecated.', $e->getMessage());
+			return;
+		}
 
-		Helpers::deprecated('The xyz method is deprecated.', 'my-key');
+		Assert::fail('Expected deprecation warning was not generated');
 	}
 
 	/**
 	 * @covers ::deprecated
 	 */
 	public function testDeprecatedActivated()
 	{
-		$this->expectException('Whoops\Exception\ErrorException');
-		$this->expectExceptionMessage('The xyz method is deprecated.');
+		try {
+			Helpers::$deprecations = ['my-key' => true];
+			Helpers::deprecated('The xyz method is deprecated.', 'my-key');
+		} catch (Deprecated $e) {
+			$this->assertSame('The xyz method is deprecated.', $e->getMessage());
+			return;
+		}
 
-		Helpers::$deprecations = ['my-key' => true];
-		Helpers::deprecated('The xyz method is deprecated.', 'my-key');
+		Assert::fail('Expected deprecation warning was not generated');
 	}
 
 	/**
@@ -195,19 +211,24 @@ public function testHandleErrorsWarningCaughtCallbackValue()
 	 */
 	public function testHandleErrorsWarningNotCaught()
 	{
-		$this->expectExceptionMessage('Some warning');
-
-		Helpers::handleErrors(
-			fn () => trigger_error('Some warning', E_USER_WARNING),
-			function (int $errno, string $errstr) {
-				$this->assertSame(E_USER_WARNING, $errno);
-				$this->assertSame('Some warning', $errstr);
+		try {
+			Helpers::handleErrors(
+				fn () => trigger_error('Some warning', E_USER_WARNING),
+				function (int $errno, string $errstr) {
+					$this->assertSame(E_USER_WARNING, $errno);
+					$this->assertSame('Some warning', $errstr);
+
+					// continue the handler chain
+					return false;
+				},
+				'handled'
+			);
+		} catch (Warning $e) {
+			$this->assertSame('Some warning', $e->getMessage());
+			return;
+		}
 
-				// continue the handler chain
-				return false;
-			},
-			'handled'
-		);
+		Assert::fail('Expected warning was not generated');
 	}
 
 	/**

tests/bootstrap.php

@@ -1,9 +1,15 @@
 <?php
 
+use Kirby\Cms\App;
+
 error_reporting(E_ALL);
 ini_set('display_errors', 'on');
 ini_set('display_startup_errors', 'on');
 
 require_once __DIR__ . '/../vendor/autoload.php';
 
 define('KIRBY_TESTING', true);
+
+// disable Whoops for all tests that don't need it
+// to reduce the impact of memory leaks
+App::$enableWhoops = false;