PredisPhpRedisTest - Code Metrics - Inspection of "try out the new scrutinizer (#57)" - mmucklo/DtcQueueBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f67228...ea1bad )

by Matthew

created 2018-02-22 00:37 UTC

PredisPhpRedisTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	314
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
wmc	31
c	0
b	0
f	0
lcom	1
cbo	5
dl	0
loc	314
rs	9.8

<?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]);
    }

    private function prePopulateScan($redis, $type, $key, $hashKeyStart, array &$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);
            }
        }
    }

    public function scan(RedisInterface $redis, $type)
    {
        $key = 'testHash';
        $redis->del([$key]);
        $hashKeyStart = 'hash_key_';
        $hashKeys = [];
        $this->prePopulateScan($redis, $type, $key, $hashKeyStart, $hashKeys);

        $cursor = null;
        while (($results = $redis->$type($key, $cursor))) {
            $this->iterateScanResults($results, $hashKeys);
            if (0 === $cursor) {
                break;
            }
        }
        self::assertEmpty($hashKeys);
    }

    private function iterateScanResults(array $results, array &$hashKeys)
    {
        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]));
            }
        }
    }

    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			private function prePopulateScan($redis, $type, $key, $hashKeyStart, array &$hashKeys)
110			{
111			for ($i = 0; $i < 100; ++$i) {
112			$hashKey = $hashKeyStart.$i;
113			$hashKeys[$hashKey] = 2 * $i;
114			if ('hScan' == $type) {
115			$redis->hIncrBy($key, $hashKey, $i);
116			$redis->hIncrBy($key, $hashKey, $i);
117			}
118			if ('zScan' == $type) {
119			$redis->zAdd($key, $i * 2, $hashKey);
120			}
121			}
122			}
123
124			public function scan(RedisInterface $redis, $type)
125			{
126			$key = 'testHash';
127			$redis->del([$key]);
128			$hashKeyStart = 'hash_key_';
129			$hashKeys = [];
130			$this->prePopulateScan($redis, $type, $key, $hashKeyStart, $hashKeys);
131
132			$cursor = null;
133			while (($results = $redis->$type($key, $cursor))) {
134			$this->iterateScanResults($results, $hashKeys);
135			if (0 === $cursor) {
136			break;
137			}
138			}
139			self::assertEmpty($hashKeys);
140			}
141
142			private function iterateScanResults(array $results, array &$hashKeys)
143			{
144			foreach ($results as $key => $value) {
145			if (isset($hashKeys[$key]) && $hashKeys[$key] === intval($value)) {
146			unset($hashKeys[$key]);
147			} else {
148			self::assertFalse(true, "Unknown hash key value: $key -> $value - isset? ".isset($hashKeys[$key]));
149			}
150			}
151			}
152
153			public function mGet(RedisInterface $redis)
154			{
155			$redis->del(['testKey1', 'testKey2']);
156			$expectedResult = [false, false];
157			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
158			self::assertTrue($redis->set('testKey1', 1234));
159			self::assertTrue($redis->set('testKey2', 12345));
160			$expectedResult = [1234, 12345];
161			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
162			$redis->del(['testKey2']);
163			$expectedResult = [1234, false];
164			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
165
166			$redis->del(['testKey1']);
167			$expectedResult = [false, false];
168			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
169			self::assertTrue($redis->set('testKey2', 12345));
170			$expectedResult = [false, 12345];
171			self::assertEquals($expectedResult, $redis->mGet(['testKey1', 'testKey2']));
172			}
173
174			public function setEx(RedisInterface $redis)
175			{
176			self::assertTrue($redis->setEx('testKey', 1, 1234));
177			self::assertEquals(1234, $redis->get('testKey'));
178			sleep(2);
179			self::assertEquals(false, $redis->get('testKey'));
180			}
181
182			public function lPush(RedisInterface $redis)
183			{
184			$redis->del(['test_list']);
185			$result = $redis->lPush('test_list', ['a']);
186			self::assertEquals(1, $result);
187			$result = $redis->lPush('test_list', ['b']);
188			self::assertEquals(2, $result);
189			$result = $redis->lPush('test_list', ['c', 'd']);
190			self::assertEquals(4, $result);
191			}
192
193			public function lRem(RedisInterface $redis)
194			{
195			$redis->del(['test_list']);
196			$result = $redis->lPush('test_list', ['a']);
197			self::assertEquals(1, $result);
198			$result = $redis->lPush('test_list', ['b']);
199			self::assertEquals(2, $result);
200			$result = $redis->lRem('test_list', 1, 'a');
201			self::assertEquals(1, $result);
202			$result = $redis->lRem('test_list', 1, 'a');
203			self::assertEquals(false, $result);
204			$result = $redis->lPush('test_list', ['a', 'a', 'a']);
205			self::assertEquals(4, $result);
206			$result = $redis->lRem('test_list', 1, 'a');
207			self::assertEquals(1, $result);
208			$result = $redis->lRem('test_list', 3, 'a');
209			self::assertEquals(2, $result);
210			$result = $redis->lRem('test_list', 3, 'b');
211			self::assertEquals(1, $result);
212			}
213
214			public function lRange(RedisInterface $redis)
215			{
216			$redis->del(['test_list']);
217			$redis->lPush('test_list', ['a']);
218			$result = $redis->lRange('test_list', 0, 1);
219			self::assertEquals(['a'], $result);
220			$result = $redis->lRange('test_list', 0, 0);
221			self::assertEquals(['a'], $result);
222			$result = $redis->lRange('test_list', 0, 2);
223			self::assertEquals(['a'], $result);
224			$redis->lPush('test_list', ['b']);
225			$result = $redis->lRange('test_list', 0, 0);
226			self::assertEquals(['b'], $result);
227			$result = $redis->lRange('test_list', 0, 1);
228			self::assertEquals(['b', 'a'], $result);
229			$result = $redis->lRange('test_list', 0, -1);
230			self::assertEquals(['b', 'a'], $result);
231			$result = $redis->lRange('test_list', 0, -2);
232			self::assertEquals(['b'], $result);
233			}
234
235			public function del(RedisInterface $redis)
236			{
237			self::assertTrue($redis->set('testKey', 1234));
238			self::assertTrue($redis->set('testKey1', 12345));
239			$result = $redis->del(['testKey']);
240			self::assertEquals(1, $result);
241			$result = $redis->del(['testKey']);
242			self::assertEquals(0, $result);
243			self::assertTrue($redis->set('testKey1', 12345));
244			$result = $redis->del(['testKey', 'testKey1']);
245			self::assertEquals(1, $result);
246			$result = $redis->del(['testKey', 'testKey1']);
247			self::assertEquals(0, $result);
248			self::assertTrue($redis->set('testKey', 1234));
249			self::assertTrue($redis->set('testKey1', 12345));
250			$result = $redis->del(['testKey', 'testKey1']);
251			self::assertEquals(2, $result);
252			}
253
254			public function zAdd(RedisInterface $redis)
255			{
256			$redis->del(['test_zkey']);
257			$result = $redis->zAdd('test_zkey', 1, 'a');
258			self::assertEquals(1, $result);
259			$result = $redis->zAdd('test_zkey', 2, 'a');
260			self::assertEquals(0, $result);
261			}
262
263			public function zCount(RedisInterface $redis)
264			{
265			$redis->del(['test_zkey']);
266			$count = $redis->zCount('test_zkey', '-inf', '+inf');
267			self::assertEquals(0, $count);
268			$redis->zAdd('test_zkey', 1, 'a');
269			$count = $redis->zCount('test_zkey', '-inf', '+inf');
270			self::assertEquals(1, $count);
271			$count = $redis->zCount('test_zkey', 2, '+inf');
272			self::assertEquals(0, $count);
273			$redis->zAdd('test_zkey', 2, 'b');
274			$count = $redis->zCount('test_zkey', '-inf', '+inf');
275			self::assertEquals(2, $count);
276			$count = $redis->zCount('test_zkey', 2, '+inf');
277			self::assertEquals(1, $count);
278			$count = $redis->zCount('test_zkey', 0, 1);
279			self::assertEquals(1, $count);
280			}
281
282			public function zRem(RedisInterface $redis)
283			{
284			$redis->del(['test_zkey']);
285			$redis->zAdd('test_zkey', 1, 'a');
286			$result = $redis->zRem('test_zkey', 'a');
287			self::assertEquals(1, $result);
288			$result = $redis->zRem('test_zkey', 'a');
289			self::assertEquals(0, $result);
290			$redis->zAdd('test_zkey', 1, 'a');
291			$redis->zAdd('test_zkey', 1, 'b');
292			$result = $redis->zRem('test_zkey', 'a');
293			self::assertEquals(1, $result);
294			$result = $redis->zRem('test_zkey', 'b');
295			self::assertEquals(1, $result);
296			}
297
298			public function zPop(RedisInterface $redis)
299			{
300			$redis->del(['test_zkey']);
301			$redis->zAdd('test_zkey', 1, 'a');
302			$redis->zAdd('test_zkey', 2, 'b');
303			$result = $redis->zPop('test_zkey');
304			self::assertEquals('a', $result);
305			$result = $redis->zPop('test_zkey');
306			self::assertEquals('b', $result);
307			}
308
309			public function zPopByMaxScore(RedisInterface $redis)
310			{
311			$redis->del(['test_zkey']);
312			$redis->zAdd('test_zkey', 123456789, 'a');
313			$redis->zAdd('test_zkey', 212345678, 'b');
314			$result = $redis->zPopByMaxScore('test_zkey', 0);
315			self::assertEquals(false, $result);
316			$result = $redis->zPopByMaxScore('test_zkey', 200000000);
317			self::assertEquals('a', $result);
318			$result = $redis->zPopByMaxScore('test_zkey', 200000000);
319			self::assertEquals(false, $result);
320			$result = $redis->zPopByMaxScore('test_zkey', 213345678);
321			self::assertEquals('b', $result);
322			}
323			}
324

mmucklo / DtcQueueBundle

Push — master ( f67228...ea1bad )

PredisPhpRedisTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

Duplication Side-by-Side

Filter issues like