improve tests

Author: mvorisek

tests/mutex/MutexConcurrencyTest.php

@@ -197,18 +197,18 @@ function ($timeout = 3) use ($dsn, $user, $password) {
      */
     public function testExecutionIsSerializedWhenLocked(callable $mutexFactory)
     {
-        $timestamp = hrtime(true);
+        $time = \microtime(true);
 
-        $this->fork(5, function () use ($mutexFactory): void {
+        $this->fork(6, function () use ($mutexFactory): void {
             /** @var Mutex $mutex */
             $mutex = $mutexFactory();
             $mutex->synchronized(function (): void {
-                \usleep(200000);
+                \usleep(200 * 1000);
             });
         });
 
-        $delta = \hrtime(true) - $timestamp;
-        $this->assertGreaterThan(1e9, $delta);
+        $delta = \microtime(true) - $time;
+        $this->assertGreaterThan(1201 * 1000, $delta);
     }
 
     /**

tests/mutex/PredisMutexTest.php

@@ -40,7 +40,7 @@ protected function setUp(): void
             ->setMethods(array_merge(get_class_methods(ClientInterface::class), ['set', 'eval']))
             ->getMock();
 
-        $this->mutex = new PredisMutex([$this->client], 'test');
+        $this->mutex = new PredisMutex([$this->client], 'test', 2.5);
 
         $this->logger = $this->createMock(LoggerInterface::class);
         $this->mutex->setLogger($this->logger);
@@ -53,7 +53,7 @@ public function testAddFailsToSetKey()
     {
         $this->client->expects($this->atLeastOnce())
             ->method('set')
-            ->with('lock_test', $this->isType('string'), 'PX', 4000, 'NX')
+            ->with('lock_test', $this->isType('string'), 'PX', 3500, 'NX')
             ->willReturn(null);
 
         $this->logger->expects($this->never())
@@ -75,7 +75,7 @@ public function testAddErrors()
     {
         $this->client->expects($this->atLeastOnce())
             ->method('set')
-            ->with('lock_test', $this->isType('string'), 'PX', 4000, 'NX')
+            ->with('lock_test', $this->isType('string'), 'PX', 3500, 'NX')
             ->willThrowException($this->createMock(PredisException::class));
 
         $this->logger->expects($this->once())
@@ -95,7 +95,7 @@ public function testWorksNormally()
     {
         $this->client->expects($this->atLeastOnce())
             ->method('set')
-            ->with('lock_test', $this->isType('string'), 'PX', 4000, 'NX')
+            ->with('lock_test', $this->isType('string'), 'PX', 3500, 'NX')
             ->willReturnSelf();
 
         $this->client->expects($this->once())
@@ -119,7 +119,7 @@ public function testEvalScriptFails()
     {
         $this->client->expects($this->atLeastOnce())
             ->method('set')
-            ->with('lock_test', $this->isType('string'), 'PX', 4000, 'NX')
+            ->with('lock_test', $this->isType('string'), 'PX', 3500, 'NX')
             ->willReturnSelf();
 
         $this->client->expects($this->once())

tests/mutex/RedisMutexTest.php

@@ -196,8 +196,8 @@ public function provideTestTimingOut()
     {
         // count, timeout, delay
         return [
-            [1, 1, 2.001],
-            [2, 1, 1.001],
+            [1, 1.2 - 1, 1.201],
+            [2, 1.2 - 1, 1.401],
         ];
     }
 

tests/mutex/SpinlockMutexTest.php

@@ -72,7 +72,7 @@ public function testAcquireTimesOut()
     public function testExecuteTooLong()
     {
         /** @var SpinlockMutex|\PHPUnit\Framework\MockObject\MockObject $mutex */
-        $mutex = $this->getMockForAbstractClass(SpinlockMutex::class, ['test', 1]);
+        $mutex = $this->getMockForAbstractClass(SpinlockMutex::class, ['test', 0.5]);
         $mutex->expects($this->any())
             ->method('acquire')
             ->willReturn(true);
@@ -82,13 +82,13 @@ public function testExecuteTooLong()
             ->willReturn(true);
 
         $this->expectException(ExecutionOutsideLockException::class);
-//        $this->expectExceptionMessageRegExp(
-//            '/The code executed for \d+\.\d+ seconds. But the timeout is 1 ' .
-//            'seconds. The last \d+\.\d+ seconds were executed outside of the lock./'
-//        );
+        $this->expectExceptionMessageMatches(
+            '/The code executed for 0\.5\d+ seconds. But the timeout is 0\.5 ' .
+            'seconds. The last 0\.0\d+ seconds were executed outside of the lock./'
+        );
 
         $mutex->synchronized(function () {
-            usleep(1100 * 1000);
+            usleep(501 * 1000);
         });
     }
 
@@ -98,12 +98,12 @@ public function testExecuteTooLong()
      */
     public function testExecuteBarelySucceeds()
     {
-        $mutex = $this->getMockForAbstractClass(SpinlockMutex::class, ['test', 1]);
+        $mutex = $this->getMockForAbstractClass(SpinlockMutex::class, ['test', 0.5]);
         $mutex->expects($this->any())->method('acquire')->willReturn(true);
         $mutex->expects($this->once())->method('release')->willReturn(true);
 
         $mutex->synchronized(function () {
-            usleep(999999);
+            usleep(499 * 1000);
         });
     }
 
@@ -127,16 +127,16 @@ public function testFailReleasingLock()
      */
     public function testExecuteTimeoutLeavesOneSecondForKeyToExpire()
     {
-        $mutex = $this->getMockForAbstractClass(SpinlockMutex::class, ['test', 3]);
+        $mutex = $this->getMockForAbstractClass(SpinlockMutex::class, ['test', 0.2]);
         $mutex->expects($this->once())
             ->method('acquire')
-            ->with($this->anything(), 4)
+            ->with($this->anything(), 1.2)
             ->willReturn(true);
 
         $mutex->expects($this->once())->method('release')->willReturn(true);
 
         $mutex->synchronized(function () {
-            usleep(2999999);
+            usleep(199 * 1000);
         });
     }
 }

tests/util/LoopTest.php

@@ -43,23 +43,37 @@ public function testExecutionWithinTimeout()
     {
         $this->expectNotToPerformAssertions();
 
-        $loop = new Loop(1);
+        $loop = new Loop(0.5);
         $loop->execute(function () use ($loop): void {
-            usleep(999999);
+            usleep(499 * 1000);
             $loop->end();
         });
     }
 
+    /**
+     * Tests execution within the timeout without calling end().
+     */
+    public function testExecutionWithinTimeoutWithoutExplicitEnd()
+    {
+        $this->expectException(TimeoutException::class);
+        $this->expectExceptionMessage('Timeout of 0.5 seconds exceeded.');
+
+        $loop = new Loop(0.5);
+        $loop->execute(function (): void {
+            usleep(10 * 1000);
+        });
+    }
+
     /**
      * Tests exceeding the execution timeout.
      */
     public function testExceedTimeoutIsAcceptableIfEndWasCalled()
     {
         $this->expectNotToPerformAssertions();
 
-        $loop = new Loop(1);
+        $loop = new Loop(0.5);
         $loop->execute(function () use ($loop): void {
-            sleep(1);
+            usleep(501 * 1000);
             $loop->end();
         });
     }
@@ -70,11 +84,11 @@ public function testExceedTimeoutIsAcceptableIfEndWasCalled()
     public function testExceedTimeoutWithoutExplicitEnd()
     {
         $this->expectException(TimeoutException::class);
-        $this->expectExceptionMessage('Timeout of 1.0 seconds exceeded.');
+        $this->expectExceptionMessage('Timeout of 0.5 seconds exceeded.');
 
-        $loop = new Loop(1);
+        $loop = new Loop(0.5);
         $loop->execute(function (): void {
-            sleep(1);
+            usleep(501 * 1000);
         });
     }