PredisPhpRedisTest::hIncrBy() - Code Metrics - Inspection of "Issue #42 expand redis statistics for Count Comman..." - mmucklo/DtcQueueBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#44)

by Matthew

created 2018-01-22 02:22 UTC

PredisPhpRedisTest::hIncrBy() A

↳ Parent: PredisPhpRedisTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	15
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	15
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	13
nc	1
nop	1

<?php

namespace Dtc\QueueBundle\Tests\Redis;

use Dtc\QueueBundle\Redis\RedisInterface;
use Dtc\QueueBundle\Redis\Predis;
use Dtc\QueueBundle\Redis\PhpRedis;
use Predis\Client;

class PredisPhpRedisTest extends \PHPUnit\Framework\TestCase
{
    public function getPhpRedis()
    {
        $host = getenv('REDIS_HOST');
        $port = getenv('REDIS_PORT') ?: 6379;
        $redis = new \Redis();
        $redis->connect($host, $port);
        $redis->flushAll();
        $phpredis = new PhpRedis($redis);

        return $phpredis;
    }

    public function getPredis()
    {
        $host = getenv('REDIS_HOST');
        $port = getenv('REDIS_PORT') ?: 6379;
        $predisClient = new Client(['scheme' => 'tcp', 'host' => $host, 'port' => $port]);
        $predisClient->flushall();
        $predis = new Predis($predisClient);

        return $predis;
    }

    public function testPredisRedis()
    {
        $redisConnections = [$this->getPhpRedis(), $this->getPredis()];

        foreach ($redisConnections as $connection) {
            $this->getSet($connection);
            $this->del($connection);
            $this->setEx($connection);
            $this->lPush($connection);
            $this->lRem($connection);
            $this->lRange($connection);
            $this->zAdd($connection);
            $this->zRem($connection);
            $this->zPop($connection);
            $this->zPopByMaxScore($connection);
            $this->zCount($connection);
            $this->mGet($connection);
            $this->hIncrBy($connection);
            $this->hGetAll($connection);
            $this->scan($connection, 'hScan');
            $this->scan($connection, 'zScan');
        }
    }

    public function getSet(RedisInterface $redis)
    {
        $redis->del(['testKey']);
        self::assertFalse($redis->get('testKey'));
        self::assertTrue($redis->set('testKey', 1234));
        self::assertEquals(1234, $redis->get('testKey'));
        self::assertTrue($redis->set('testKey', 12345));
        self::assertEquals(12345, $redis->get('testKey'));
    }

    public function hIncrBy(RedisInterface $redis)
    {
        $key = 'testHKey';
        $redis->del([$key]);
        $hashKey1 = 'testHashKey1';
        $result = $redis->hIncrBy($key, $hashKey1, 1);
        self::assertEquals(1, $result);
        $result = $redis->hIncrBy($key, $hashKey1, 1);
        self::assertEquals(2, $result);
        $result = $redis->hIncrBy($key, $hashKey1, 3);
        self::assertEquals(5, $result);
        $hashKey2 = 'testHashKey2';
        $result = $redis->hIncrBy($key, $hashKey2, 3);
        self::assertEquals(3, $result);
    }

    public function hGetAll(RedisInterface $redis)
    {
        $key = 'testHKey';
        $redis->del([$key]);
        $result = $redis->hGetAll($key);
        self::assertEquals([], $result);

        $hashKey1 = 'testHashKey1';
        $redis->hIncrBy($key, $hashKey1, 1);
        $result = $redis->hGetAll($key);
        self::assertEquals([$hashKey1 => 1], $result);
        $redis->hIncrBy($key, $hashKey1, 1);
        $result = $redis->hGetAll($key);
        self::assertEquals([$hashKey1 => 2], $result);
        $hashKey2 = 'testHashKey2';
        $redis->hIncrBy($key, $hashKey2, 3);
        $result = $redis->hGetAll($key);
        self::assertCount(2, $result);
        self::assertArrayHasKey($hashKey1, $result);
        self::assertArrayHasKey($hashKey2, $result);
        self::assertEquals(2, $result[$hashKey1]);
        self::assertEquals(3, $result[$hashKey2]);
    }

    public function scan(RedisInterface $redis, $type)
    {
        $key = 'testHash';
        $redis->del([$key]);
        $hashKeyStart = 'hash_key_';
        $hashKeys = [];
        for ($i = 0; $i < 100; ++$i) {
            $hashKey = $hashKeyStart.$i;
            $hashKeys[$hashKey] = 2 * $i;
            if ('hScan' == $type) {
                $redis->hIncrBy($key, $hashKey, $i);
                $redis->hIncrBy($key, $hashKey, $i);
            }
            if ('zScan' == $type) {
                $redis->zAdd($key, $i * 2, $hashKey);
            }
        }

        $cursor = null;
        while (($results = $redis->$type($key, $cursor))) {
            foreach ($results as $key => $value) {
                if (isset($hashKeys[$key]) && $hashKeys[$key] === intval($value)) {
                    unset($hashKeys[$key]);
                } else {
                    self::assertFalse(true, "Unknown hash key value: $key -> $value - isset? ".isset($hashKeys[$key]));
                }
            }
            if (0 === $cursor) {
                break;
            }
        }
        self::assertEmpty($hashKeys);
    }

    public function mGet(RedisInterface $redis)
    {
        $redis->del(['testKey1', 'testKey2']);
        $expectedResult = [false, false];
        self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
        self::assertTrue($redis->set('testKey1', 1234));
        self::assertTrue($redis->set('testKey2', 12345));
        $expectedResult = [1234, 12345];
        self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
        $redis->del(['testKey2']);
        $expectedResult = [1234, false];
        self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));

        $redis->del(['testKey1']);
        $expectedResult = [false, false];
        self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
        self::assertTrue($redis->set('testKey2', 12345));
        $expectedResult = [false, 12345];
        self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
    }

    public function setEx(RedisInterface $redis)
    {
        self::assertTrue($redis->setEx('testKey', 1, 1234));
        self::assertEquals(1234, $redis->get('testKey'));
        sleep(2);
        self::assertEquals(false, $redis->get('testKey'));
    }

    public function lPush(RedisInterface $redis)
    {
        $redis->del(['test_list']);
        $result = $redis->lPush('test_list', ['a']);
        self::assertEquals(1, $result);
        $result = $redis->lPush('test_list', ['b']);
        self::assertEquals(2, $result);
        $result = $redis->lPush('test_list', ['c', 'd']);
        self::assertEquals(4, $result);
    }

    public function lRem(RedisInterface $redis)
    {
        $redis->del(['test_list']);
        $result = $redis->lPush('test_list', ['a']);
        self::assertEquals(1, $result);
        $result = $redis->lPush('test_list', ['b']);
        self::assertEquals(2, $result);
        $result = $redis->lRem('test_list', 1, 'a');
        self::assertEquals(1, $result);
        $result = $redis->lRem('test_list', 1, 'a');
        self::assertEquals(false, $result);
        $result = $redis->lPush('test_list', ['a', 'a', 'a']);
        self::assertEquals(4, $result);
        $result = $redis->lRem('test_list', 1, 'a');
        self::assertEquals(1, $result);
        $result = $redis->lRem('test_list', 3, 'a');
        self::assertEquals(2, $result);
        $result = $redis->lRem('test_list', 3, 'b');
        self::assertEquals(1, $result);
    }

    public function lRange(RedisInterface $redis)
    {
        $redis->del(['test_list']);
        $redis->lPush('test_list', ['a']);
        $result = $redis->lRange('test_list', 0, 1);
        self::assertEquals(['a'], $result);
        $result = $redis->lRange('test_list', 0, 0);
        self::assertEquals(['a'], $result);
        $result = $redis->lRange('test_list', 0, 2);
        self::assertEquals(['a'], $result);
        $redis->lPush('test_list', ['b']);
        $result = $redis->lRange('test_list', 0, 0);
        self::assertEquals(['b'], $result);
        $result = $redis->lRange('test_list', 0, 1);
        self::assertEquals(['b', 'a'], $result);
        $result = $redis->lRange('test_list', 0, -1);
        self::assertEquals(['b', 'a'], $result);
        $result = $redis->lRange('test_list', 0, -2);
        self::assertEquals(['b'], $result);
    }

    public function del(RedisInterface $redis)
    {
        self::assertTrue($redis->set('testKey', 1234));
        self::assertTrue($redis->set('testKey1', 12345));
        $result = $redis->del(['testKey']);
        self::assertEquals(1, $result);
        $result = $redis->del(['testKey']);
        self::assertEquals(0, $result);
        self::assertTrue($redis->set('testKey1', 12345));
        $result = $redis->del(['testKey', 'testKey1']);
        self::assertEquals(1, $result);
        $result = $redis->del(['testKey', 'testKey1']);
        self::assertEquals(0, $result);
        self::assertTrue($redis->set('testKey', 1234));
        self::assertTrue($redis->set('testKey1', 12345));
        $result = $redis->del(['testKey', 'testKey1']);
        self::assertEquals(2, $result);
    }

    public function zAdd(RedisInterface $redis)
    {
        $redis->del(['test_zkey']);
        $result = $redis->zAdd('test_zkey', 1, 'a');
        self::assertEquals(1, $result);
        $result = $redis->zAdd('test_zkey', 2, 'a');
        self::assertEquals(0, $result);
    }

    public function zCount(RedisInterface $redis)
    {
        $redis->del(['test_zkey']);
        $count = $redis->zCount('test_zkey', '-inf', '+inf');
        self::assertEquals(0, $count);
        $redis->zAdd('test_zkey', 1, 'a');
        $count = $redis->zCount('test_zkey', '-inf', '+inf');
        self::assertEquals(1, $count);
        $count = $redis->zCount('test_zkey', 2, '+inf');
        self::assertEquals(0, $count);
        $redis->zAdd('test_zkey', 2, 'b');
        $count = $redis->zCount('test_zkey', '-inf', '+inf');
        self::assertEquals(2, $count);
        $count = $redis->zCount('test_zkey', 2, '+inf');
        self::assertEquals(1, $count);
        $count = $redis->zCount('test_zkey', 0, 1);
        self::assertEquals(1, $count);
    }

    public function zRem(RedisInterface $redis)
    {
        $redis->del(['test_zkey']);
        $redis->zAdd('test_zkey', 1, 'a');
        $result = $redis->zRem('test_zkey', 'a');
        self::assertEquals(1, $result);
        $result = $redis->zRem('test_zkey', 'a');
        self::assertEquals(0, $result);
        $redis->zAdd('test_zkey', 1, 'a');
        $redis->zAdd('test_zkey', 1, 'b');
        $result = $redis->zRem('test_zkey', 'a');
        self::assertEquals(1, $result);
        $result = $redis->zRem('test_zkey', 'b');
        self::assertEquals(1, $result);
    }

    public function zPop(RedisInterface $redis)
    {
        $redis->del(['test_zkey']);
        $redis->zAdd('test_zkey', 1, 'a');
        $redis->zAdd('test_zkey', 2, 'b');
        $result = $redis->zPop('test_zkey');
        self::assertEquals('a', $result);
        $result = $redis->zPop('test_zkey');
        self::assertEquals('b', $result);
    }

    public function zPopByMaxScore(RedisInterface $redis)
    {
        $redis->del(['test_zkey']);
        $redis->zAdd('test_zkey', 123456789, 'a');
        $redis->zAdd('test_zkey', 212345678, 'b');
        $result = $redis->zPopByMaxScore('test_zkey', 0);
        self::assertEquals(false, $result);
        $result = $redis->zPopByMaxScore('test_zkey', 200000000);
        self::assertEquals('a', $result);
        $result = $redis->zPopByMaxScore('test_zkey', 200000000);
        self::assertEquals(false, $result);
        $result = $redis->zPopByMaxScore('test_zkey', 213345678);
        self::assertEquals('b', $result);
    }
}


1			<?php
2
3			namespace Dtc\QueueBundle\Tests\Redis;
4
5			use Dtc\QueueBundle\Redis\RedisInterface;
6			use Dtc\QueueBundle\Redis\Predis;
7			use Dtc\QueueBundle\Redis\PhpRedis;
8			use Predis\Client;
9
10			class PredisPhpRedisTest extends \PHPUnit\Framework\TestCase
11			{
12			public function getPhpRedis()
13			{
14			$host = getenv('REDIS_HOST');
15			$port = getenv('REDIS_PORT') ?: 6379;
16			$redis = new \Redis();
17			$redis->connect($host, $port);
18			$redis->flushAll();
19			$phpredis = new PhpRedis($redis);
20
21			return $phpredis;
22			}
23
24			public function getPredis()
25			{
26			$host = getenv('REDIS_HOST');
27			$port = getenv('REDIS_PORT') ?: 6379;
28			$predisClient = new Client(['scheme' => 'tcp', 'host' => $host, 'port' => $port]);
29			$predisClient->flushall();
30			$predis = new Predis($predisClient);
31
32			return $predis;
33			}
34
35			public function testPredisRedis()
36			{
37			$redisConnections = [$this->getPhpRedis(), $this->getPredis()];
38
39			foreach ($redisConnections as $connection) {
40			$this->getSet($connection);
41			$this->del($connection);
42			$this->setEx($connection);
43			$this->lPush($connection);
44			$this->lRem($connection);
45			$this->lRange($connection);
46			$this->zAdd($connection);
47			$this->zRem($connection);
48			$this->zPop($connection);
49			$this->zPopByMaxScore($connection);
50			$this->zCount($connection);
51			$this->mGet($connection);
52			$this->hIncrBy($connection);
53			$this->hGetAll($connection);
54			$this->scan($connection, 'hScan');
55			$this->scan($connection, 'zScan');
56			}
57			}
58
59			public function getSet(RedisInterface $redis)
60			{
61			$redis->del(['testKey']);
62			self::assertFalse($redis->get('testKey'));
63			self::assertTrue($redis->set('testKey', 1234));
64			self::assertEquals(1234, $redis->get('testKey'));
65			self::assertTrue($redis->set('testKey', 12345));
66			self::assertEquals(12345, $redis->get('testKey'));
67			}
68
69			public function hIncrBy(RedisInterface $redis)
70			{
71			$key = 'testHKey';
72			$redis->del([$key]);
73			$hashKey1 = 'testHashKey1';
74			$result = $redis->hIncrBy($key, $hashKey1, 1);
75			self::assertEquals(1, $result);
76			$result = $redis->hIncrBy($key, $hashKey1, 1);
77			self::assertEquals(2, $result);
78			$result = $redis->hIncrBy($key, $hashKey1, 3);
79			self::assertEquals(5, $result);
80			$hashKey2 = 'testHashKey2';
81			$result = $redis->hIncrBy($key, $hashKey2, 3);
82			self::assertEquals(3, $result);
83			}
84
85			public function hGetAll(RedisInterface $redis)
86			{
87			$key = 'testHKey';
88			$redis->del([$key]);
89			$result = $redis->hGetAll($key);
90			self::assertEquals([], $result);
91
92			$hashKey1 = 'testHashKey1';
93			$redis->hIncrBy($key, $hashKey1, 1);
94			$result = $redis->hGetAll($key);
95			self::assertEquals([$hashKey1 => 1], $result);
96			$redis->hIncrBy($key, $hashKey1, 1);
97			$result = $redis->hGetAll($key);
98			self::assertEquals([$hashKey1 => 2], $result);
99			$hashKey2 = 'testHashKey2';
100			$redis->hIncrBy($key, $hashKey2, 3);
101			$result = $redis->hGetAll($key);
102			self::assertCount(2, $result);
103			self::assertArrayHasKey($hashKey1, $result);
104			self::assertArrayHasKey($hashKey2, $result);
105			self::assertEquals(2, $result[$hashKey1]);
106			self::assertEquals(3, $result[$hashKey2]);
107			}
108
109			public function scan(RedisInterface $redis, $type)
110			{
111			$key = 'testHash';
112			$redis->del([$key]);
113			$hashKeyStart = 'hash_key_';
114			$hashKeys = [];
115			for ($i = 0; $i < 100; ++$i) {
116			$hashKey = $hashKeyStart.$i;
117			$hashKeys[$hashKey] = 2 * $i;
118			if ('hScan' == $type) {
119			$redis->hIncrBy($key, $hashKey, $i);
120			$redis->hIncrBy($key, $hashKey, $i);
121			}
122			if ('zScan' == $type) {
123			$redis->zAdd($key, $i * 2, $hashKey);
124			}
125			}
126
127			$cursor = null;
128			while (($results = $redis->$type($key, $cursor))) {
129			foreach ($results as $key => $value) {
130			if (isset($hashKeys[$key]) && $hashKeys[$key] === intval($value)) {
131			unset($hashKeys[$key]);
132			} else {
133			self::assertFalse(true, "Unknown hash key value: $key -> $value - isset? ".isset($hashKeys[$key]));
134			}
135			}
136			if (0 === $cursor) {
137			break;
138			}
139			}
140			self::assertEmpty($hashKeys);
141			}
142
143			public function mGet(RedisInterface $redis)
144			{
145			$redis->del(['testKey1', 'testKey2']);
146			$expectedResult = [false, false];
147			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
148			self::assertTrue($redis->set('testKey1', 1234));
149			self::assertTrue($redis->set('testKey2', 12345));
150			$expectedResult = [1234, 12345];
151			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
152			$redis->del(['testKey2']);
153			$expectedResult = [1234, false];
154			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
155
156			$redis->del(['testKey1']);
157			$expectedResult = [false, false];
158			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
159			self::assertTrue($redis->set('testKey2', 12345));
160			$expectedResult = [false, 12345];
161			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
162			}
163
164			public function setEx(RedisInterface $redis)
165			{
166			self::assertTrue($redis->setEx('testKey', 1, 1234));
167			self::assertEquals(1234, $redis->get('testKey'));
168			sleep(2);
169			self::assertEquals(false, $redis->get('testKey'));
170			}
171
172			public function lPush(RedisInterface $redis)
173			{
174			$redis->del(['test_list']);
175			$result = $redis->lPush('test_list', ['a']);
176			self::assertEquals(1, $result);
177			$result = $redis->lPush('test_list', ['b']);
178			self::assertEquals(2, $result);
179			$result = $redis->lPush('test_list', ['c', 'd']);
180			self::assertEquals(4, $result);
181			}
182
183			public function lRem(RedisInterface $redis)
184			{
185			$redis->del(['test_list']);
186			$result = $redis->lPush('test_list', ['a']);
187			self::assertEquals(1, $result);
188			$result = $redis->lPush('test_list', ['b']);
189			self::assertEquals(2, $result);
190			$result = $redis->lRem('test_list', 1, 'a');
191			self::assertEquals(1, $result);
192			$result = $redis->lRem('test_list', 1, 'a');
193			self::assertEquals(false, $result);
194			$result = $redis->lPush('test_list', ['a', 'a', 'a']);
195			self::assertEquals(4, $result);
196			$result = $redis->lRem('test_list', 1, 'a');
197			self::assertEquals(1, $result);
198			$result = $redis->lRem('test_list', 3, 'a');
199			self::assertEquals(2, $result);
200			$result = $redis->lRem('test_list', 3, 'b');
201			self::assertEquals(1, $result);
202			}
203
204			public function lRange(RedisInterface $redis)
205			{
206			$redis->del(['test_list']);
207			$redis->lPush('test_list', ['a']);
208			$result = $redis->lRange('test_list', 0, 1);
209			self::assertEquals(['a'], $result);
210			$result = $redis->lRange('test_list', 0, 0);
211			self::assertEquals(['a'], $result);
212			$result = $redis->lRange('test_list', 0, 2);
213			self::assertEquals(['a'], $result);
214			$redis->lPush('test_list', ['b']);
215			$result = $redis->lRange('test_list', 0, 0);
216			self::assertEquals(['b'], $result);
217			$result = $redis->lRange('test_list', 0, 1);
218			self::assertEquals(['b', 'a'], $result);
219			$result = $redis->lRange('test_list', 0, -1);
220			self::assertEquals(['b', 'a'], $result);
221			$result = $redis->lRange('test_list', 0, -2);
222			self::assertEquals(['b'], $result);
223			}
224
225			public function del(RedisInterface $redis)
226			{
227			self::assertTrue($redis->set('testKey', 1234));
228			self::assertTrue($redis->set('testKey1', 12345));
229			$result = $redis->del(['testKey']);
230			self::assertEquals(1, $result);
231			$result = $redis->del(['testKey']);
232			self::assertEquals(0, $result);
233			self::assertTrue($redis->set('testKey1', 12345));
234			$result = $redis->del(['testKey', 'testKey1']);
235			self::assertEquals(1, $result);
236			$result = $redis->del(['testKey', 'testKey1']);
237			self::assertEquals(0, $result);
238			self::assertTrue($redis->set('testKey', 1234));
239			self::assertTrue($redis->set('testKey1', 12345));
240			$result = $redis->del(['testKey', 'testKey1']);
241			self::assertEquals(2, $result);
242			}
243
244			public function zAdd(RedisInterface $redis)
245			{
246			$redis->del(['test_zkey']);
247			$result = $redis->zAdd('test_zkey', 1, 'a');
248			self::assertEquals(1, $result);
249			$result = $redis->zAdd('test_zkey', 2, 'a');
250			self::assertEquals(0, $result);
251			}
252
253			public function zCount(RedisInterface $redis)
254			{
255			$redis->del(['test_zkey']);
256			$count = $redis->zCount('test_zkey', '-inf', '+inf');
257			self::assertEquals(0, $count);
258			$redis->zAdd('test_zkey', 1, 'a');
259			$count = $redis->zCount('test_zkey', '-inf', '+inf');
260			self::assertEquals(1, $count);
261			$count = $redis->zCount('test_zkey', 2, '+inf');
262			self::assertEquals(0, $count);
263			$redis->zAdd('test_zkey', 2, 'b');
264			$count = $redis->zCount('test_zkey', '-inf', '+inf');
265			self::assertEquals(2, $count);
266			$count = $redis->zCount('test_zkey', 2, '+inf');
267			self::assertEquals(1, $count);
268			$count = $redis->zCount('test_zkey', 0, 1);
269			self::assertEquals(1, $count);
270			}
271
272			public function zRem(RedisInterface $redis)
273			{
274			$redis->del(['test_zkey']);
275			$redis->zAdd('test_zkey', 1, 'a');
276			$result = $redis->zRem('test_zkey', 'a');
277			self::assertEquals(1, $result);
278			$result = $redis->zRem('test_zkey', 'a');
279			self::assertEquals(0, $result);
280			$redis->zAdd('test_zkey', 1, 'a');
281			$redis->zAdd('test_zkey', 1, 'b');
282			$result = $redis->zRem('test_zkey', 'a');
283			self::assertEquals(1, $result);
284			$result = $redis->zRem('test_zkey', 'b');
285			self::assertEquals(1, $result);
286			}
287
288			public function zPop(RedisInterface $redis)
289			{
290			$redis->del(['test_zkey']);
291			$redis->zAdd('test_zkey', 1, 'a');
292			$redis->zAdd('test_zkey', 2, 'b');
293			$result = $redis->zPop('test_zkey');
294			self::assertEquals('a', $result);
295			$result = $redis->zPop('test_zkey');
296			self::assertEquals('b', $result);
297			}
298
299			public function zPopByMaxScore(RedisInterface $redis)
300			{
301			$redis->del(['test_zkey']);
302			$redis->zAdd('test_zkey', 123456789, 'a');
303			$redis->zAdd('test_zkey', 212345678, 'b');
304			$result = $redis->zPopByMaxScore('test_zkey', 0);
305			self::assertEquals(false, $result);
306			$result = $redis->zPopByMaxScore('test_zkey', 200000000);
307			self::assertEquals('a', $result);
308			$result = $redis->zPopByMaxScore('test_zkey', 200000000);
309			self::assertEquals(false, $result);
310			$result = $redis->zPopByMaxScore('test_zkey', 213345678);
311			self::assertEquals('b', $result);
312			}
313			}
314

mmucklo / DtcQueueBundle

Pull Request — master (#44)

PredisPhpRedisTest::hIncrBy() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like