Added test for compression.

Author: TheLevti

classes/mutex/PHPRedisMutex.php

@@ -4,6 +4,7 @@
 
 use malkusch\lock\exception\LockAcquireException;
 use malkusch\lock\exception\LockReleaseException;
+use Redis;
 use RedisException;
 
 /**
@@ -70,14 +71,14 @@ protected function evalScript($redis, string $script, int $numkeys, array $argum
     {
         // Determine if we need to compress eval arguments.
         $lzfCompression = false;
-        if (\defined(\Redis::class . '::COMPRESSION_LZF') &&
-            \Redis::COMPRESSION_LZF === $redis->getOption(\Redis::OPT_COMPRESSION) &&
-            \function_exists('\lzf_compress')
+        if (defined("Redis::COMPRESSION_LZF") &&
+            constant("Redis::COMPRESSION_LZF") === $redis->getOption(Redis::OPT_COMPRESSION) &&
+            function_exists('lzf_compress')
         ) {
             $lzfCompression = true;
         }
 
-        for ($i = $numkeys, $iMax = \count($arguments); $i < $iMax; $i++) {
+        for ($i = $numkeys, $iMax = count($arguments); $i < $iMax; $i++) {
             /* If a serializion mode such as "php" or "igbinary" is enabled, the arguments must be
              * serialized by us, because phpredis does not do this for the eval command.
              */
@@ -87,7 +88,7 @@ protected function evalScript($redis, string $script, int $numkeys, array $argum
              * extension installed, compress the arguments as the final step.
              */
             if ($lzfCompression) {
-                $arguments[$i] = \lzf_compress($arguments[$i]);
+                $arguments[$i] = lzf_compress($arguments[$i]);
             }
         }
 

composer.json

@@ -46,6 +46,7 @@
         "psr/log": "^1"
     },
     "require-dev": {
+        "ext-lzf": "*",
         "ext-memcached": "*",
         "ext-pcntl": "*",
         "ext-pdo_mysql": "*",
@@ -62,9 +63,10 @@
         "squizlabs/php_codesniffer": "^3.3"
     },
     "suggest": {
+        "ext-lzf": "To use this library with PHP Redis lzf compression enabled.",
         "ext-pnctl": "Enables locking with flock without busy waiting in CLI scripts.",
-        "ext-sysvsem": "Enables locking using semaphores.",
         "ext-redis": "To use this library with the PHP Redis extension.",
+        "ext-sysvsem": "Enables locking using semaphores.",
         "predis/predis": "To use this library with predis."
     },
     "archive": {

tests/mutex/PHPRedisMutexTest.php

@@ -41,8 +41,7 @@ protected function setUp()
             $uri  = parse_url($redisUri);
 
             // original Redis::set and Redis::eval calls will reopen the connection
-            $connection = new class extends Redis
-            {
+            $connection = new class extends Redis {
                 private $is_closed = false;
 
                 public function close()
@@ -100,6 +99,9 @@ private function closeMinorityConnections()
         }
 
         $numberToClose = ceil(count($this->connections) / 2) - 1;
+        if (0 >= $numberToClose) {
+            return;
+        }
 
         foreach ((array) array_rand($this->connections, $numberToClose) as $keyToClose) {
             $this->connections[$keyToClose]->close();
@@ -132,27 +134,36 @@ public function testEvalScriptFails()
     }
 
     /**
-     * @param $serialization
-     * @dataProvider dpSerializationModes
+     * @dataProvider serializationAndCompressionModes
+     *
+     * @param array $serializer Serializer to test.
+     * @param array $compressor Compressor to test.
      */
-    public function testSynchronizedWorks($serialization)
+    public function testSerializersAndCompressors($serializer, $compressor)
     {
         foreach ($this->connections as $connection) {
-            $connection->setOption(Redis::OPT_SERIALIZER, $serialization);
+            $connection->setOption(Redis::OPT_SERIALIZER, $serializer);
+            $connection->setOption(Redis::OPT_COMPRESSION, $compressor);
         }
 
-        $this->assertSame("test", $this->mutex->synchronized(function (): string {
-            return "test";
-        }));
+        $this->assertSame(
+            "test",
+            $this->mutex->synchronized(function (): string {
+                return "test";
+            })
+        );
     }
 
     public function testResistantToPartialClusterFailuresForAcquiringLock()
     {
         $this->closeMinorityConnections();
 
-        $this->assertSame("test", $this->mutex->synchronized(function (): string {
-            return "test";
-        }));
+        $this->assertSame(
+            "test",
+            $this->mutex->synchronized(function (): string {
+                return "test";
+            })
+        );
     }
 
     public function testResistantToPartialClusterFailuresForReleasingLock()
@@ -163,21 +174,42 @@ public function testResistantToPartialClusterFailuresForReleasingLock()
         }));
     }
 
-    public function dpSerializationModes()
+    public function serializationAndCompressionModes()
     {
         if (!class_exists(Redis::class)) {
             return [];
         }
 
-        $serializers = [
-            [Redis::SERIALIZER_NONE],
-            [Redis::SERIALIZER_PHP],
+        $options = [
+            [Redis::SERIALIZER_NONE, Redis::COMPRESSION_NONE],
+            [Redis::SERIALIZER_PHP, Redis::COMPRESSION_NONE],
         ];
 
         if (defined("Redis::SERIALIZER_IGBINARY")) {
-            $serializers[] = [constant("Redis::SERIALIZER_IGBINARY")];
+            $options[] = [
+                constant("Redis::SERIALIZER_IGBINARY"),
+                Redis::COMPRESSION_NONE
+            ];
+        }
+
+        if (defined("Redis::COMPRESSION_LZF")) {
+            $options[] = [
+                Redis::SERIALIZER_NONE,
+                constant("Redis::COMPRESSION_LZF")
+            ];
+            $options[] = [
+                Redis::SERIALIZER_PHP,
+                constant("Redis::COMPRESSION_LZF")
+            ];
+
+            if (defined("Redis::SERIALIZER_IGBINARY")) {
+                $options[] = [
+                    constant("Redis::SERIALIZER_IGBINARY"),
+                    constant("Redis::COMPRESSION_LZF")
+                ];
+            }
         }
 
-        return $serializers;
+        return $options;
     }
 }