PredisPhpRedisTest::getSet() - 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 04:32 UTC

PredisPhpRedisTest::getSet() A

↳ Parent: PredisPhpRedisTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	7
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]);
    }

    private function prePopulateScan($type, $haskKeyStart, 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($type, $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($type, $haskKeyStart, array &$hashKeys)
			0 ignored issues – show Unused Code introduced 2018-01-22 04:47 UTC by Report Bug Copy Issue Report The parameter `$haskKeyStart` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
110			{
111			for ($i = 0; $i < 100; ++$i) {
112			$hashKey = $hashKeyStart.$i;
			0 ignored issues – show Bug introduced 2018-01-22 04:47 UTC by Report Bug Copy Issue Report The variable `$hashKeyStart` does not exist. Did you mean `$hashKeys`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
113			$hashKeys[$hashKey] = 2 * $i;
114			if ('hScan' == $type) {
115			$redis->hIncrBy($key, $hashKey, $i);
			0 ignored issues – show Bug introduced 2018-01-22 04:47 UTC by Report Bug Copy Issue Report The variable `$redis` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2018-01-22 04:47 UTC by Report Bug Copy Issue Report The variable `$key` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
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($type, $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

Pull Request — master (#44)

PredisPhpRedisTest::getSet() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like