Merge pull request #6 from WyriHaximus/enforce-timeouts

Enforce timeouts

Author: WyriHaximus

README.md

@@ -43,6 +43,43 @@ final class SomeTest extends TestCase
 }
 ```
 
+## Timeouts
+
+This package supports marking a test failed once a timeout has been reached. Note that this doesn't stop anything
+running in the fiber the rest runs in or cleans up the loop as we cannot kill the running fiber once it starts. An
+exception is thrown in the scope between the test and PHPUnit that handles running the test in a fiber. And this is out
+of control of the test.
+
+```php
+<?php
+
+declare(strict_types=1);
+
+use PHPUnit\Framework\TestCase;
+use React\Promise\Promise;
+use WyriHaximus\React\PHPUnit\RunTestsInFibersTrait;
+use WyriHaximus\React\PHPUnit\TimeOut;
+
+use function React\Async\await;
+
+#[TimeOut(30)]
+final class SomeTest extends TestCase
+{
+    use RunTestsInFibersTrait;
+
+    /**
+     * @test
+     */
+    #[TimeOut(0.1)]
+    public function happyFlow()
+    {
+        self::assertTrue(await(new Promise(static function (callable $resolve): void {
+            $resolve(true);
+        })));
+    }
+}
+```
+
 
 # License
 

etc/qa/composer-require-checker.json

@@ -4,7 +4,7 @@
     "static", "self", "parent",
     "array", "string", "int", "float", "bool", "iterable", "callable", "void", "object", "mixed",
     "futurePromise", "WyriHaximus\\Constants\\ComposerAutoloader\\LOCATION",
-    "WyriHaximus\\Constants\\Boolean\\FALSE_", "WyriHaximus\\Constants\\Boolean\\TRUE_"
+    "React\\Promise\\Timer\\sleep"
   ],
   "php-core-extensions" : [
     "Core",

infection.json.dist

@@ -12,7 +12,18 @@
         "perMutator": "./var/infection-per-mutator.md"
     },
     "mutators": {
-        "@default": true
+        "@default": true,
+        "PublicVisibility": {
+            "ignore": [
+                "WyriHaximus\\React\\PHPUnit\\RunTestsInFibersTrait::setName::25"
+            ]
+        },
+        "MethodCallRemoval": {
+            "ignore": [
+                "WyriHaximus\\React\\PHPUnit\\RunTestsInFibersTrait::setName::28",
+                "WyriHaximus\\React\\PHPUnit\\RunTestsInFibersTrait::runAsyncTest::46"
+            ]
+        }
     },
     "phpUnit": {
         "configDir": "./etc/qa/"

src/RunTestsInFibersTrait.php

@@ -4,16 +4,21 @@
 
 namespace WyriHaximus\React\PHPUnit;
 
-use React\EventLoop\Loop;
+use React\Promise\PromiseInterface;
 use ReflectionClass;
 
 use function assert;
 use function is_string;
 use function React\Async\async;
 use function React\Async\await;
+use function React\Promise\race;
+use function React\Promise\reject;
+use function React\Promise\Timer\sleep;
 
 trait RunTestsInFibersTrait
 {
+    private const DEFAULT_TIMEOUT_SECONDS = 30;
+
     private string|null $realTestName = null;
 
     /** @codeCoverageIgnore Invoked before code coverage data is being collected. */
@@ -42,15 +47,15 @@ final protected function runAsyncTest(mixed ...$args): mixed
 
         assert(is_string($this->realTestName));
 
-        $timeout         = 30;
+        $timeout         = self::DEFAULT_TIMEOUT_SECONDS;
         $reflectionClass = new ReflectionClass($this::class);
         foreach ($reflectionClass->getAttributes() as $classAttribute) {
             $classTimeout = $classAttribute->newInstance();
-            if (! ($classTimeout instanceof TimeOut)) {
+            if (! ($classTimeout instanceof TimeOutInterface)) {
                 continue;
             }
 
-            $timeout = $classTimeout->timeout;
+            $timeout = $classTimeout->timeout();
         }
 
         /**
@@ -59,26 +64,23 @@ final protected function runAsyncTest(mixed ...$args): mixed
          */
         foreach ($reflectionClass->getMethod($this->realTestName)->getAttributes() as $methodAttribute) {
             $methodTimeout = $methodAttribute->newInstance();
-            if (! ($methodTimeout instanceof TimeOut)) {
+            if (! ($methodTimeout instanceof TimeOutInterface)) {
                 continue;
             }
 
-            $timeout = $methodTimeout->timeout;
+            $timeout = $methodTimeout->timeout();
         }
 
-        $timeout = Loop::addTimer($timeout, static fn () => Loop::stop());
-
-        try {
-            /**
-             * @psalm-suppress MixedArgument
-             * @psalm-suppress UndefinedInterfaceMethod
-             */
-            return await(async(
+        /**
+         * @psalm-suppress MixedArgument
+         * @psalm-suppress UndefinedInterfaceMethod
+         */
+        return await(race([
+            async(
                 fn (): mixed => ([$this, $this->realTestName])(...$args), /** @phpstan-ignore-line */
-            )());
-        } finally {
-            Loop::cancelTimer($timeout);
-        }
+            )(),
+            sleep($timeout)->then(static fn (): PromiseInterface => reject(new TimedOut('Test timed out after ' . $timeout . ' second(s)'))),
+        ]));
     }
 
     final protected function runTest(): mixed

src/TimeOut.php

@@ -7,10 +7,15 @@
 use Attribute;
 
 #[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_CLASS)]
-final readonly class TimeOut
+final readonly class TimeOut implements TimeOutInterface
 {
     public function __construct(
-        public int|float $timeout,
+        private int|float $timeout,
     ) {
     }
+
+    public function timeout(): int|float
+    {
+        return $this->timeout;
+    }
 }

src/TimeOutInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WyriHaximus\React\PHPUnit;
+
+interface TimeOutInterface
+{
+    public function timeout(): int|float;
+}

src/TimedOut.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WyriHaximus\React\PHPUnit;
+
+use RuntimeException;
+
+/**
+ * Ignore to allow Runtime Exception extension
+ *
+ * @phpstan-ignore-next-line
+ */
+final class TimedOut extends RuntimeException
+{
+}

tests/RunTestsInFibersTraitTest.php

@@ -7,19 +7,22 @@
 use PHPUnit\Framework\TestCase;
 use React\EventLoop\Loop;
 use WyriHaximus\React\PHPUnit\RunTestsInFibersTrait;
+use WyriHaximus\React\PHPUnit\TimedOut;
 use WyriHaximus\React\PHPUnit\TimeOut;
 
 use function React\Async\async;
 use function React\Async\await;
 use function React\Promise\Timer\sleep;
 
-#[TimeOut(1)]
+#[SomeAttribute]
+#[TimeOut(0.5)]
+#[SomeAttribute]
 final class RunTestsInFibersTraitTest extends TestCase
 {
     use RunTestsInFibersTrait;
 
-    #[TimeOut(0.1)]
-    public function testAllTestsAreRanInAFiber(): void
+    /** @test */
+    public function allTestsAreRanInAFiber(): void
     {
         self::expectOutputString('ab');
 
@@ -31,4 +34,25 @@ public function testAllTestsAreRanInAFiber(): void
 
         echo 'b';
     }
+
+    /** @test */
+    #[SomeAttribute]
+    #[TimeOut(0.1)]
+    #[SomeAttribute]
+    public function methodLevelTimeout(): void
+    {
+        self::expectException(TimedOut::class);
+        self::expectExceptionMessage('Test timed out after 0.1 second(s)');
+
+        await(sleep(0.2));
+    }
+
+    /** @test */
+    public function classLevelTimeout(): void
+    {
+        self::expectException(TimedOut::class);
+        self::expectExceptionMessage('Test timed out after 0.5 second(s)');
+
+        await(sleep(0.6));
+    }
 }

tests/SomeAttribute.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WyriHaximus\Tests\React\PHPUnit;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
+final readonly class SomeAttribute
+{
+}