.editorconfig

@@ -18,3 +18,6 @@ indent_size = 2
 
 [Makefile]
 indent_style = tab
+
+[*.neon]
+indent_style = tab

.github/settings.yml

@@ -10,6 +10,8 @@ repository:
 
 # Labels: define labels for Issues and Pull Requests
 labels:
+    - name: "Deprecations 👋"
+      color: ff7700
     - name: "Dependencies 📦"
       color: 0025ff
       description: "Pull requests that update a dependency file"

README.md

@@ -17,13 +17,67 @@ composer require wyrihaximus/async-test-utilities
 
 # Usage
 
-Any test file can extend `WyriHaximus\AsyncTestUtilities\TestCase` and it comes with some goodies such as random namespaces and random directories to use for file storage related tests.
+Any test file can extend `WyriHaximus\AsyncTestUtilities\TestCase` and it comes with some goodies such as random
+namespaces and random directories to use for file storage related tests.
+
+Since all tests are executed inside a fiber, there is a default timeout of `30` seconds. To lower or raise that timeout
+this package comes with a `TimeOut` attribute. It can be set on the class and method level. When set on both the method level it takes priority over the class level.
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace WyriHaximus\Tests\AsyncTestUtilities;
+
+use React\EventLoop\Loop;
+use WyriHaximus\AsyncTestUtilities\AsyncTestCase;
+use WyriHaximus\AsyncTestUtilities\TimeOut;
+
+use function React\Async\async;
+use function React\Async\await;
+use function React\Promise\resolve;
+use function React\Promise\Timer\sleep;
+use function time;
+
+#[TimeOut(0.3)]
+final class AsyncTestCaseTest extends AsyncTestCase
+{
+    #[TimeOut(1)]
+    public function testAllTestsAreRanInAFiber(): void
+    {
+        self::expectOutputString('ab');
+
+        Loop::futureTick(async(static function (): void {
+            echo 'a';
+        }));
+
+        await(sleep(1));
+
+        echo 'b';
+    }
+
+    public function testExpectCallableExactly(): void
+    {
+        $callable = $this->expectCallableExactly(3);
+
+        Loop::futureTick($callable);
+        Loop::futureTick($callable);
+        Loop::futureTick($callable);
+    }
+
+    public function testExpectCallableOnce(): void
+    {
+        Loop::futureTick($this->expectCallableOnce());
+    }
+}
+```
 
 # License
 
 The MIT License (MIT)
 
-Copyright (c) 2021 Cees-Jan Kiewiet
+Copyright (c) 2023 Cees-Jan Kiewiet
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

composer.json

@@ -17,6 +17,7 @@
     "wyrihaximus/test-utilities": "^5.5.0 || ^6"
   },
   "require-dev": {
+    "react/promise-timer": "^1.9",
     "wyrihaximus/iterator-or-array-to-array": "^1.2"
   },
   "autoload": {

etc/qa/phpstan.neon

@@ -1,11 +1,14 @@
 parameters:
-	excludes_analyse:
+	excludePaths:
 		- tests/bootstrap.php
 	ignoreErrors:
+		- '#Parameter \#1 \$name of method PHPUnit\\Framework\\TestCase::setName\(\) expects string, string\|null given.#'
+		- '#Trying to invoke array\{\$this\(WyriHaximus\\AsyncTestUtilities\\AsyncTestCase\), string\|null\} but it might not be a callable.#'
 		- '#Method WyriHaximus\\AsyncTestUtilities\\CallableStub::__invoke\(\) is not final, but since the containing class is abstract, it should be.#'
-		- '#Call to deprecated method await\(\) of class WyriHaximus\\AsyncTestUtilities\\AsyncTestCase#'
-		- '#Call to deprecated method awaitAll\(\) of class WyriHaximus\\AsyncTestUtilities\\AsyncTestCase#'
-		- '#Call to deprecated method awaitAny\(\) of class WyriHaximus\\AsyncTestUtilities\\AsyncTestCase#'
+		- '#Parameter \#1 \$name of method ReflectionClass\<\$this\(WyriHaximus\\AsyncTestUtilities\\AsyncTestCase\)\>::getMethod\(\) expects string, string\|null given.#'
+		- '#Call to an undefined method React\\Promise\\PromiseInterface\<mixed\>::always\(\).#'
+		- '#Call to deprecated method expectCallableExactly\(\)#'
+		- '#Call to deprecated method expectCallableOnce\(\)#'
 	ergebnis:
 		classesAllowedToBeExtended:
 			- WyriHaximus\AsyncTestUtilities\AsyncTestCase

src/AsyncTestCase.php

@@ -5,63 +5,38 @@
 namespace WyriHaximus\AsyncTestUtilities;
 
 use PHPUnit\Framework\MockObject\Rule\InvokedCount;
-use React\Promise\PromiseInterface;
+use React\EventLoop\Loop;
+use ReflectionClass;
 use WyriHaximus\TestUtilities\TestCase;
 
+use function React\Async\async;
 use function React\Async\await;
-use function React\Promise\all;
-use function React\Promise\any;
 
 abstract class AsyncTestCase extends TestCase
 {
     private const INVOKE_ARRAY = ['__invoke'];
 
-    /**
-     * @return mixed returns whatever the promise resolves to
-     *
-     * @psalm-suppress MissingReturnType
-     *
-     * @codingStandardsIgnoreStart
-     * @deprecated Use \React\Async\await directly
-     */
-    final protected function await(PromiseInterface $promise): mixed
-    {
-        return await($promise);
-    }
-
-    /**
-     * @return array<mixed>
-     * @deprecated Use \React\Async\await and \React\Promise\all directly
-     */
-    final protected function awaitAll(PromiseInterface ...$promises): array
-    {
-        /** @var array<mixed> */
-        return await(all($promises));
-    }
+    private ?string $realTestName = null;
 
     /**
-     * @return mixed
-     *
-     * @psalm-suppress MissingReturnType
-     *
-     * @codingStandardsIgnoreStart
-     * @deprecated Use \React\Async\await and \React\Promise\any directly
+     * @deprecated With the move to fibers there is no need for these rarely used methods anymore. (Unless proven otherwise of course.)
      */
-    final protected function awaitAny(PromiseInterface ...$promises): mixed
-    {
-        return await(any($promises));
-    }
-
     final protected function expectCallableExactly(int $amount): callable
     {
         return $this->getCallableMock(self::exactly($amount));
     }
 
+    /**
+     * @deprecated With the move to fibers there is no need for these rarely used methods anymore. (Unless proven otherwise of course.)
+     */
     final protected function expectCallableOnce(): callable
     {
         return $this->getCallableMock(self::once());
     }
 
+    /**
+     * @deprecated With the move to fibers there is no need for these rarely used methods anymore. (Unless proven otherwise of course.)
+     */
     final protected function expectCallableNever(): callable
     {
         return $this->getCallableMock(self::never());
@@ -79,4 +54,69 @@ private function getCallableMock(InvokedCount $invokedCount): callable
         /** @psalm-suppress InvalidReturnStatement */
         return $mock;
     }
+
+    /**
+     * @codeCoverageIgnore Invoked before code coverage data is being collected.
+     */
+    final public function setName(string $name): void
+    {
+        /**
+         * @psalm-suppress InternalMethod
+         */
+        parent::setName($name);
+        $this->realTestName = $name;
+    }
+
+    /** @internal */
+    final protected function runAsyncTest(mixed ...$args): mixed
+    {
+        /**
+         * @psalm-suppress InternalMethod
+         * @psalm-suppress PossiblyNullArgument
+         */
+        parent::setName($this->realTestName);
+        $timeout         = 30;
+        $reflectionClass = new ReflectionClass($this::class);
+        foreach ($reflectionClass->getAttributes() as $classAttribute) {
+            $classTimeout = $classAttribute->newInstance();
+            if (! ($classTimeout instanceof TimeOut)) {
+                continue;
+            }
+
+            $timeout = $classTimeout->timeout;
+        }
+
+        /**
+         * @psalm-suppress InternalMethod
+         * @psalm-suppress PossiblyNullArgument
+         */
+        foreach ($reflectionClass->getMethod($this->realTestName)->getAttributes() as $methodAttribute) {
+            $methodTimeout = $methodAttribute->newInstance();
+            if (! ($methodTimeout instanceof TimeOut)) {
+                continue;
+            }
+
+            $timeout = $methodTimeout->timeout;
+        }
+
+        $timeout = Loop::addTimer($timeout, static fn () => Loop::stop());
+
+        /**
+         * @psalm-suppress MixedArgument
+         * @psalm-suppress UndefinedInterfaceMethod
+         */
+        return await(async(
+            fn (): mixed => ([$this, $this->realTestName])(...$args),
+        )()->always(static fn () => Loop::cancelTimer($timeout)));
+    }
+
+    final protected function runTest(): mixed
+    {
+        /**
+         * @psalm-suppress InternalMethod
+         */
+        parent::setName('runAsyncTest');
+
+        return parent::runTest();
+    }
 }

src/TimeOut.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace WyriHaximus\AsyncTestUtilities;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_METHOD | Attribute::TARGET_CLASS)]
+final readonly class TimeOut
+{
+    public function __construct(
+        public int|float $timeout,
+    ) {
+    }
+}