Use now() and rename to UnhandledException

Author: kelunik

src/AsyncTestCase.php

@@ -11,12 +11,13 @@
 use Revolt\EventLoop\Driver\TracingDriver;
 use function Amp\async;
 use function Amp\Future\all;
+use function Amp\now;
 
 abstract class AsyncTestCase extends PHPUnitTestCase
 {
     private const RUNTIME_PRECISION = 2;
 
-    private DeferredFuture $deferred;
+    private DeferredFuture $deferredFuture;
 
     private string $timeoutId;
 
@@ -48,15 +49,14 @@ protected function cleanup(): void
     protected function setUp(): void
     {
         $this->setUpInvoked = true;
-
-        $this->deferred = new DeferredFuture();
+        $this->deferredFuture = new DeferredFuture();
 
         EventLoop::setErrorHandler(function (\Throwable $exception): void {
-            if ($this->deferred->isComplete()) {
+            if ($this->deferredFuture->isComplete()) {
                 return;
             }
 
-            $this->deferred->error(new LoopCaughtException($exception));
+            $this->deferredFuture->error(new UnhandledException($exception));
         });
     }
 
@@ -73,11 +73,12 @@ final protected function runAsyncTest(mixed ...$args): mixed
 
         parent::setName($this->realTestName);
 
-        $start = \microtime(true);
+        $start = now();
 
         try {
             try {
-                [$returnValue] = all([
+                [, $returnValue] = all([
+                    $this->deferredFuture->getFuture(),
                     async(function () use ($args): mixed {
                         try {
                             $result = ([$this, $this->realTestName])(...$args);
@@ -93,12 +94,11 @@ final protected function runAsyncTest(mixed ...$args): mixed
 
                             return $result;
                         } finally {
-                            if (!$this->deferred->isComplete()) {
-                                $this->deferred->complete();
+                            if (!$this->deferredFuture->isComplete()) {
+                                $this->deferredFuture->complete();
                             }
                         }
                     }),
-                    $this->deferred->getFuture()
                 ]);
             } finally {
                 $this->cleanup();
@@ -111,7 +111,7 @@ final protected function runAsyncTest(mixed ...$args): mixed
             \gc_collect_cycles(); // Throw from as many destructors as possible.
         }
 
-        $end = \microtime(true);
+        $end = now();
 
         if ($this->minimumRuntime > 0) {
             $actualRuntime = \round($end - $start, self::RUNTIME_PRECISION);
@@ -133,27 +133,27 @@ final protected function runTest(): mixed
     }
 
     /**
-     * Fails the test if the loop does not run for at least the given amount of time.
+     * Fails the test if it does not run for at least the given amount of time.
      *
-     * @param float $runtime Required run time in seconds.
+     * @param float $seconds Required runtime in seconds.
      */
-    final protected function setMinimumRuntime(float $runtime): void
+    final protected function setMinimumRuntime(float $seconds): void
     {
-        if ($runtime < 0.001) {
-            throw new \Error('Minimum runtime must be at least 0.001s');
+        if ($seconds <= 0) {
+            throw new \Error('Minimum runtime must be greater than 0, got ' . $seconds);
         }
 
-        $this->minimumRuntime = \round($runtime, self::RUNTIME_PRECISION);
+        $this->minimumRuntime = \round($seconds, self::RUNTIME_PRECISION);
     }
 
     /**
-     * Fails the test (and stops the loop) after the given timeout.
+     * Fails the test (and stops the event loop) after the given timeout.
      *
-     * @param float $timeout Timeout in seconds.
+     * @param float $seconds Timeout in seconds.
      */
-    final protected function setTimeout(float $timeout): void
+    final protected function setTimeout(float $seconds): void
     {
-        $this->timeoutId = EventLoop::delay($timeout, function () use ($timeout): void {
+        $this->timeoutId = EventLoop::delay($seconds, function () use ($seconds): void {
             EventLoop::setErrorHandler(null);
 
             $additionalInfo = '';
@@ -167,22 +167,26 @@ final protected function setTimeout(float $timeout): void
                 $additionalInfo .= "\r\n\r\nSet REVOLT_DEBUG_TRACE_WATCHERS=true as environment variable to trace watchers keeping the loop running.";
             }
 
-            if ($this->deferred->isComplete()) {
+            if ($this->deferredFuture->isComplete()) {
                 return;
             }
 
             try {
-                $this->fail(\sprintf('Expected test to complete before %0.3fs time limit%s', $timeout, $additionalInfo));
+                $this->fail(\sprintf(
+                    'Expected test to complete before %0.3fs time limit%s',
+                    $seconds,
+                    $additionalInfo
+                ));
             } catch (AssertionFailedError $e) {
-                $this->deferred->error($e);
+                $this->deferredFuture->error($e);
             }
         });
 
         EventLoop::unreference($this->timeoutId);
     }
 
     /**
-     * @param int $invocationCount Number of times the callback must be invoked or the test will fail.
+     * @param int           $invocationCount Number of times the callback must be invoked or the test will fail.
      * @param callable|null $returnCallback Callable providing a return value for the callback.
      *
      * @return \Closure&MockObject Mock object having only an __invoke method.

src/LoopCaughtException.php src/UnhandledException.phpsrc/LoopCaughtException.php renamed to src/UnhandledException.php

@@ -2,9 +2,9 @@
 
 namespace Amp\PHPUnit;
 
-final class LoopCaughtException extends \Exception
+final class UnhandledException extends \Exception
 {
-    public function __construct(\Throwable $previous = null)
+    public function __construct(\Throwable $previous)
     {
         parent::__construct(\sprintf(
             "%s thrown to event loop error handler: %s",

test/AsyncTestCaseTest.php

@@ -5,8 +5,8 @@
 use Amp\DeferredFuture;
 use Amp\Future;
 use Amp\PHPUnit\AsyncTestCase;
-use Amp\PHPUnit\LoopCaughtException;
 use Amp\PHPUnit\TestException;
+use Amp\PHPUnit\UnhandledException;
 use PHPUnit\Framework\AssertionFailedError;
 use Revolt\EventLoop;
 use function Amp\async;
@@ -25,14 +25,14 @@ public function cleanup(): void
         }
     }
 
-    public function testThatMethodRunsInLoopContext(): Future
+    public function testThatMethodRunsInEventLoopContext(): Future
     {
         $returnDeferred = new DeferredFuture; // make sure our test runs to completion
         $testDeferred = new DeferredFuture; // used by our defer callback to ensure we're running on the Loop
 
         EventLoop::queue(function () use ($testDeferred, $returnDeferred): void {
             $data = $testDeferred->getFuture()->await();
-            self::assertEquals('foobar', $data, 'Expected the data to be what was resolved in EventLoop::defer');
+            self::assertSame('foobar', $data);
             $returnDeferred->complete();
         });
 
@@ -43,19 +43,20 @@ public function testThatMethodRunsInLoopContext(): Future
         return $returnDeferred->getFuture();
     }
 
-    public function testThatWeHandleNullReturn(): void
+    public function testHandleNullReturn(): void
     {
         $testDeferred = new DeferredFuture;
         $testData = new \stdClass;
-        $testData->val = null;
+        $testData->val = 0;
+
         EventLoop::defer(function () use ($testData, $testDeferred) {
-            $testData->val = true;
-            $testDeferred->complete(null);
+            $testData->val++;
+            $testDeferred->complete();
         });
 
         $testDeferred->getFuture()->await();
 
-        self::assertTrue($testData->val, 'Expected our test to run on loop to completion');
+        self::assertSame(1, $testData->val);
     }
 
     public function testReturningFuture(): Future
@@ -65,18 +66,20 @@ public function testReturningFuture(): Future
         EventLoop::delay(0.1, fn () => $deferred->complete('value'));
 
         $returnValue = $deferred->getFuture();
-        self::assertInstanceOf(Future::class, $returnValue); // An assertion is required for the test to pass
+        $this->expectNotToPerformAssertions();
+
         return $returnValue; // Return value used by testReturnValueFromDependentTest
     }
 
     public function testExpectingAnExceptionThrown(): Future
     {
         $throwException = function (): void {
             delay(0.1);
-            throw new \Exception('threw the error');
+
+            throw new TestException('threw the error');
         };
 
-        $this->expectException(\Exception::class);
+        $this->expectException(TestException::class);
         $this->expectExceptionMessage('threw the error');
 
         return async($throwException);
@@ -91,19 +94,15 @@ public function testExpectingAnErrorThrown(): Future
         });
     }
 
-    public function argumentSupportProvider(): array
+    public function provideArguments(): array
     {
         return [
             ['foo', 42, true],
         ];
     }
 
     /**
-     * @param string $foo
-     * @param int    $bar
-     * @param bool   $baz
-     *
-     * @dataProvider argumentSupportProvider
+     * @dataProvider provideArguments
      */
     public function testArgumentSupport(string $foo, int $bar, bool $baz): void
     {
@@ -126,6 +125,7 @@ public function testSetTimeout(): void
     {
         $this->setTimeout(0.1);
         $this->expectNotToPerformAssertions();
+
         delay(0.05);
     }
 
@@ -158,8 +158,7 @@ public function testSetMinimumRunTime(): void
         $this->setMinimumRuntime(0.1);
 
         $this->expectException(AssertionFailedError::class);
-        $pattern = "/Expected test to take at least 0.100s but instead took 0.(\d+)s/";
-        $this->expectExceptionMessageMatches($pattern);
+        $this->expectExceptionMessageMatches("/Expected test to take at least 0.100s but instead took 0.\d{3}s/");
 
         delay(0.05);
     }
@@ -179,7 +178,7 @@ public function testThrowToEventLoop(): void
 
         EventLoop::queue(static fn () => throw new TestException('message'));
 
-        $this->expectException(LoopCaughtException::class);
+        $this->expectException(UnhandledException::class);
         $pattern = "/(.+) thrown to event loop error handler: (.*)/";
         $this->expectExceptionMessageMatches($pattern);