Add FiberStub to achieve 100% code coverage for PHP < 8.1

Author: clue

composer.json

@@ -30,6 +30,9 @@
     "autoload-dev": {
         "psr-4": {
             "FrameworkX\\Tests\\": "tests/"
-        }
+        },
+        "files": [
+            "tests/FiberStub.php"
+        ]
     }
 }

phpstan.neon.dist

@@ -10,6 +10,3 @@ parameters:
     ignoreErrors:
         # ignore generic usage like `PromiseInterface<ResponseInterface>` until fixed upstream
         - '/^PHPDoc tag @return contains generic type React\\Promise\\PromiseInterface<Psr\\Http\\Message\\ResponseInterface> but interface React\\Promise\\PromiseInterface is not generic\.$/'
-        # ignore unknown `Fiber` class (PHP 8.1+)
-        - '/^Instantiated class Fiber not found\.$/'
-        - '/^Call to method (start|isTerminated|getReturn)\(\) on an unknown class Fiber\.$/'

src/Io/FiberHandler.php

@@ -35,7 +35,7 @@ class FiberHandler
      *     be turned into a valid error response before returning.
      * @throws void
      */
-    public function __invoke(ServerRequestInterface $request, callable $next): mixed
+    public function __invoke(ServerRequestInterface $request, callable $next)
     {
         $deferred = null;
         $fiber = new \Fiber(function () use ($request, $next, &$deferred) {

tests/FiberStub.php

@@ -0,0 +1,156 @@
+<?php
+
+if (!class_exists(Fiber::class)) {
+    class Fiber
+    {
+        /** @var callable */
+        private $callback;
+
+        /** @var mixed */
+        private $return;
+
+        /** @var bool */
+        private $started = false;
+
+        /** @var bool */
+        private $terminated = false;
+
+        /** @var bool */
+        private static $halt = false;
+
+        /** @var ?Fiber */
+        private static $suspended = null;
+
+        public function __construct(callable $callback)
+        {
+            $this->callback = $callback;
+        }
+
+        /**
+         * @param mixed ...$args
+         * @return mixed
+         * @throws \Throwable
+         */
+        public function start(...$args)
+        {
+            if ($this->started) {
+                throw new \FiberError();
+            }
+            $this->started = true;
+
+            if (self::$halt) {
+                assert(self::$suspended === null);
+                self::$suspended = $this;
+                return null;
+            }
+
+            try {
+                return $this->return = ($this->callback)(...$args);
+            } finally {
+                $this->terminated = true;
+            }
+        }
+
+        /**
+         * @param mixed $value
+         * @return mixed
+         * @throws \BadMethodCallException
+         */
+        public function resume($value = null)
+        {
+            throw new \BadMethodCallException();
+        }
+
+        /**
+         * @param Throwable $exception
+         * @return mixed
+         * @throws \BadMethodCallException
+         */
+        public function throw(Throwable $exception)
+        {
+            throw new \BadMethodCallException();
+        }
+
+        /**
+         * @return mixed
+         * @throws FiberError
+         */
+        public function getReturn()
+        {
+            if (!$this->terminated) {
+                throw new \FiberError();
+            }
+
+            return $this->return;
+        }
+
+        public function isStarted(): bool
+        {
+            return $this->started;
+        }
+
+        public function isSuspended(): bool
+        {
+            return false;
+        }
+
+        public function isRunning(): bool
+        {
+            return $this->started && !$this->terminated;
+        }
+
+        public function isTerminated(): bool
+        {
+            return $this->terminated;
+        }
+
+        /**
+         * @param mixed $value
+         * @return mixed
+         * @throws \Throwable
+         */
+        public static function suspend($value = null)
+        {
+            throw new \BadMethodCallException();
+        }
+
+        public static function getCurrent(): ?Fiber
+        {
+            return null;
+        }
+
+        /**
+         * @internal
+         */
+        public static function mockSuspend(): void
+        {
+            assert(self::$halt === false);
+            self::$halt = true;
+        }
+
+        /**
+         * @internal
+         * @throws void
+         */
+        public static function mockResume(): void
+        {
+            assert(self::$halt === true);
+            assert(self::$suspended instanceof self);
+
+            $fiber = self::$suspended;
+            assert($fiber->started);
+            assert(!$fiber->terminated);
+
+            self::$halt = false;
+            self::$suspended = null;
+
+            /** @throws void */
+            $fiber->return = ($fiber->callback)();
+            $fiber->terminated = true;
+        }
+    }
+
+    final class FiberError extends Error {
+
+    }
+}

tests/Io/FiberHandlerTest.php

@@ -14,13 +14,6 @@
 
 class FiberHandlerTest extends TestCase
 {
-    public function setUp(): void
-    {
-        if (PHP_VERSION_ID < 80100 || !function_exists('React\Async\async')) {
-            $this->markTestSkipped('Requires PHP 8.1+ with react/async 4+');
-        }
-    }
-
     public function testInvokeWithHandlerReturningResponseReturnsSameResponse(): void
     {
         $handler = new FiberHandler();
@@ -132,6 +125,11 @@ public function testInvokeWithHandlerReturningResponseAfterAwaitingResolvedPromi
 
     public function testInvokeWithHandlerReturningResponseAfterAwaitingPendingPromiseReturnsPromiseResolvingWithSameResponse(): void
     {
+        // work around lack of actual fibers in PHP < 8.1
+        if (\method_exists(\Fiber::class, 'mockSuspend')) {
+            \Fiber::mockSuspend();
+        }
+
         $handler = new FiberHandler();
 
         $request = new ServerRequest('GET', 'http://example.com/');
@@ -140,6 +138,16 @@ public function testInvokeWithHandlerReturningResponseAfterAwaitingPendingPromis
         $deferred = new Deferred();
 
         $promise = $handler($request, function () use ($deferred) {
+            // going the extra mile if using reactphp/async < 4 on PHP 8.1+
+            if (PHP_VERSION_ID >= 80100 && !function_exists('React\Async\async')) {
+                $fiber = \Fiber::getCurrent();
+                assert($fiber instanceof \Fiber);
+                $deferred->promise()->then(function () use ($fiber): void {
+                    $fiber->resume();
+                });
+                \Fiber::suspend();
+            }
+
             return await($deferred->promise());
         });
 
@@ -155,6 +163,11 @@ public function testInvokeWithHandlerReturningResponseAfterAwaitingPendingPromis
 
         $deferred->resolve($response);
 
+        // work around lack of actual fibers in PHP < 8.1
+        if (\method_exists(\Fiber::class, 'mockResume')) {
+            \Fiber::mockResume();
+        }
+
         $this->assertSame($response, $ret);
     }
 }