Add more coverage tests

Author: terremoth

src/Terremoth/Async/Process.php

@@ -14,7 +14,7 @@ class Process
     public function __construct(private int $shmopKey = 0)
     {
         if (!$this->shmopKey) {
-            $this->shmopKey = mt_rand(0, self::MAX_INT); // communication key
+            $this->shmopKey = mt_rand(0, self::MAX_INT);
         }
     }
 
@@ -31,24 +31,28 @@ public function send(Closure $asyncFunction): void
         });
 
         try {
-            $shmopInstance = shmop_open($this->shmopKey, 'n', 0660, $length);
+            try {
+                $shmopInstance = $this->openShmop($this->shmopKey, 'n', 0660, $length);
+            } catch (Exception) {
+                $shmopInstance = false;
+            }
 
             if ($shmopInstance === false) {
-                $existing = shmop_open($this->shmopKey, 'a', 0660, 0);
+                $existing = $this->openShmop($this->shmopKey, 'a', 0660, 0);
 
                 if ($existing === false) {
                     throw new Exception(
                         'Could not access existing shmop instance with key: ' . $this->shmopKey
                     );
                 }
 
-                if (shmop_delete($existing) === false) {
+                if ($this->deleteShmop($existing) === false) {
                     throw new Exception(
                         'Could not delete existing shmop instance with key: ' . $this->shmopKey
                     );
                 }
 
-                $shmopInstance = shmop_open($this->shmopKey, 'c', 0660, $length);
+                $shmopInstance = $this->openShmop($this->shmopKey, 'c', 0660, $length);
 
                 if ($shmopInstance === false) {
                     throw new Exception(
@@ -62,7 +66,7 @@ public function send(Closure $asyncFunction): void
 
         $bytesWritten = $this->writeToShmop($shmopInstance, $serialized, 0);
 
-        if ((bool)$bytesWritten === false) {
+        if ($bytesWritten === false) {
             throw new Exception(
                 'shmop_write failed when writing to shared memory with key: ' . $this->shmopKey
             );
@@ -71,7 +75,7 @@ public function send(Closure $asyncFunction): void
         if ($bytesWritten !== $length) {
             throw new Exception(
                 'Could not write all bytes to shared memory. Expected: '
-                . $length . ', Written: ' . (int)$bytesWritten
+                . $length . ', Written: ' . $bytesWritten
             );
         }
 
@@ -83,14 +87,18 @@ public function send(Closure $asyncFunction): void
         $file->run();
     }
 
-    /**
-     * @param Shmop $shmopInstance
-     * @param string $data
-     * @param int $offset
-     * @return int|false
-     */
     protected function writeToShmop(Shmop $shmopInstance, string $data, int $offset): int|false
     {
         return shmop_write($shmopInstance, $data, $offset);
     }
+
+    protected function openShmop(int $key, string $mode, int $permissions, int $size): Shmop|false
+    {
+        return shmop_open($key, $mode, $permissions, $size);
+    }
+
+    protected function deleteShmop(Shmop $shmopInstance): bool
+    {
+        return shmop_delete($shmopInstance);
+    }
 }

tests/Terremoth/AsyncTest/ProcessTest.php

@@ -4,6 +4,7 @@
 
 use PHPUnit\Framework\TestCase;
 use Random\RandomException;
+use Shmop;
 use Terremoth\Async\Process;
 use Exception;
 use Laravel\SerializableClosure\SerializableClosure;
@@ -26,20 +27,15 @@ protected function setUp(): void
     public function testConstructorGeneratesRandomKeyWhenZero(): void
     {
         $process = new Process(0);
-
         $ref = new ReflectionProperty(Process::class, 'shmopKey');
-
         $key = intval($ref->getValue($process));
-
         $this->assertGreaterThan(0, $key);
     }
 
     public function testConstructorKeepsProvidedKey(): void
     {
         $process = new Process(12345);
-
         $reflection = new ReflectionProperty(Process::class, 'shmopKey');
-
         $this->assertSame(12345, $reflection->getValue($process));
     }
 
@@ -53,7 +49,7 @@ public function testSendActuallyWritesSerializedClosureToShmop(): void
         $process = new Process($key);
 
         $closure = function (): int {
-            return (3 * 2 + 34 | 2 ^ 1) - 1; // this is whatever, just for phpmd stops crying, the result is 42
+            return 42;
         };
 
         $process->send($closure);
@@ -69,10 +65,7 @@ public function testSendActuallyWritesSerializedClosureToShmop(): void
         $unserialized = unserialize($data);
         $this->assertInstanceOf(SerializableClosure::class, $unserialized);
 
-        $unserialized->getClosure();
-
-        // shmop_delete($shmop);
-        // shmop_close($shmop); // deprecated
+        //shmop_delete($shmop);
     }
 
     /**
@@ -93,29 +86,68 @@ public function testSendThrowsWhenNotAllBytesAreWritten(): void
             ->willReturn(10);
 
         $this->expectException(Exception::class);
+        $this->expectExceptionMessage('Could not write all bytes');
+
+        $process->send(fn() => true);
+    }
+
+    public function testSendThrowsExceptionWhenWriteFailsCompletely(): void
+    {
+        $key = 123456;
+        $process = $this->getMockBuilder(Process::class)
+            ->setConstructorArgs([$key])
+            ->onlyMethods(['writeToShmop'])
+            ->getMock();
+
+        $process->expects($this->once())
+            ->method('writeToShmop')
+            ->willReturn(false);
+
+        $this->expectException(Exception::class);
+        $this->expectExceptionMessage('shmop_write failed');
 
-        $process->send(function () {
-        });
+        $process->send(fn() => true);
     }
 
     /**
-     * @throws RandomException
      * @throws Exception
      */
-    public function testSendDoesNotThrowOnSuccess(): void
+    public function testSendHandlesShmopCollisionAndRecreation(): void
     {
-        $key = ftok(__FILE__, 'c') ?: random_int(1, 1000000);
+        $key = 987654;
 
-        $process = new Process($key);
+        $process = $this->getMockBuilder(Process::class)
+            ->setConstructorArgs([$key])
+            ->onlyMethods(['openShmop', 'deleteShmop', 'writeToShmop'])
+            ->getMock();
 
-        $process->send(function (): int {
-            return 42;
-        });
+        $process->expects($this->exactly(3))
+            ->method('openShmop')
+            ->willReturnCallback(function (int $key, string $mode) {
+                unset($key);
+                if ($mode === 'n') {
+                    throw new Exception('shmop already exists');
+                }
 
-        $shmop = shmop_open($key, 'a', 0, 0);
-        $this->assertNotFalse($shmop, 'Shared memory should exist after send');
+                $tempKey = random_int(1000000, 9999999);
+                $dummyShmop = shmop_open($tempKey, 'c', 0660, 1);
 
-        $size = shmop_size($shmop);
-        $this->assertGreaterThan(0, $size, 'Shared memory should contain data');
+                $this->assertTrue(shmop_delete($dummyShmop));
+
+                return $dummyShmop;
+            });
+
+        $process->expects($this->once())
+            ->method('deleteShmop')
+            ->willReturn(true);
+
+        $process->expects($this->once())
+            ->method('writeToShmop')
+            ->willReturnCallback(function (Shmop $shmop, string $data) {
+                unset($shmop);
+                return mb_strlen($data);
+            });
+
+        $process->send(fn() => 'test');
     }
 }