PredisPhpRedisTest::zCount() - Code Metrics - Inspection of "Attempt to fix bin/console dtc:queue:count for all..." - mmucklo/DtcQueueBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#40)

by Matthew

created 2018-01-17 09:18 UTC

PredisPhpRedisTest::zCount() A

↳ Parent: PredisPhpRedisTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	18
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	18
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	16
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;
        $jobTimingClass = JobTiming::class;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $runClass = Run::class;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $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;
        $jobTimingClass = JobTiming::class;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $runClass = Run::class;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $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);
        }
    }

    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 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			$jobTimingClass = JobTiming::class;
			0 ignored issues – show Unused Code introduced 2018-01-15 00:23 UTC by Report Bug Copy Issue Report `$jobTimingClass` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
17			$runClass = Run::class;
			0 ignored issues – show Unused Code introduced 2018-01-15 00:23 UTC by Report Bug Copy Issue Report `$runClass` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
18			$redis = new \Redis();
19			$redis->connect($host, $port);
20			$redis->flushAll();
21			$phpredis = new PhpRedis($redis);
22
23			return $phpredis;
24			}
25
26			public function getPredis()
27			{
28			$host = getenv('REDIS_HOST');
29			$port = getenv('REDIS_PORT') ?: 6379;
30			$jobTimingClass = JobTiming::class;
			0 ignored issues – show Unused Code introduced 2018-01-15 00:23 UTC by Report Bug Copy Issue Report `$jobTimingClass` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
31			$runClass = Run::class;
			0 ignored issues – show Unused Code introduced 2018-01-15 00:23 UTC by Report Bug Copy Issue Report `$runClass` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
32			$predisClient = new Client(['scheme' => 'tcp', 'host' => $host, 'port' => $port]);
33			$predisClient->flushall();
34			$predis = new Predis($predisClient);
35
36			return $predis;
37			}
38
39			public function testPredisRedis()
40			{
41			$redisConnections = [$this->getPhpRedis(), $this->getPredis()];
42
43			foreach ($redisConnections as $connection) {
44			$this->getSet($connection);
45			$this->del($connection);
46			$this->setEx($connection);
47			$this->lPush($connection);
48			$this->lRem($connection);
49			$this->lRange($connection);
50			$this->zAdd($connection);
51			$this->zRem($connection);
52			$this->zPop($connection);
53			$this->zPopByMaxScore($connection);
54			$this->zCount($connection);
55			}
56			}
57
58			public function getSet(RedisInterface $redis)
59			{
60			$redis->del(['testKey']);
61			self::assertFalse($redis->get('testKey'));
62			self::assertTrue($redis->set('testKey', 1234));
63			self::assertEquals(1234, $redis->get('testKey'));
64			self::assertTrue($redis->set('testKey', 12345));
65			self::assertEquals(12345, $redis->get('testKey'));
66			}
67
68			public function setEx(RedisInterface $redis)
69			{
70			self::assertTrue($redis->setEx('testKey', 1, 1234));
71			self::assertEquals(1234, $redis->get('testKey'));
72			sleep(2);
73			self::assertEquals(false, $redis->get('testKey'));
74			}
75
76			public function lPush(RedisInterface $redis)
77			{
78			$redis->del(['test_list']);
79			$result = $redis->lPush('test_list', ['a']);
80			self::assertEquals(1, $result);
81			$result = $redis->lPush('test_list', ['b']);
82			self::assertEquals(2, $result);
83			$result = $redis->lPush('test_list', ['c', 'd']);
84			self::assertEquals(4, $result);
85			}
86
87			public function lRem(RedisInterface $redis)
88			{
89			$redis->del(['test_list']);
90			$result = $redis->lPush('test_list', ['a']);
91			self::assertEquals(1, $result);
92			$result = $redis->lPush('test_list', ['b']);
93			self::assertEquals(2, $result);
94			$result = $redis->lRem('test_list', 1, 'a');
95			self::assertEquals(1, $result);
96			$result = $redis->lRem('test_list', 1, 'a');
97			self::assertEquals(false, $result);
98			$result = $redis->lPush('test_list', ['a', 'a', 'a']);
99			self::assertEquals(4, $result);
100			$result = $redis->lRem('test_list', 1, 'a');
101			self::assertEquals(1, $result);
102			$result = $redis->lRem('test_list', 3, 'a');
103			self::assertEquals(2, $result);
104			$result = $redis->lRem('test_list', 3, 'b');
105			self::assertEquals(1, $result);
106			}
107
108			public function lRange(RedisInterface $redis)
109			{
110			$redis->del(['test_list']);
111			$redis->lPush('test_list', ['a']);
112			$result = $redis->lRange('test_list', 0, 1);
113			self::assertEquals(['a'], $result);
114			$result = $redis->lRange('test_list', 0, 0);
115			self::assertEquals(['a'], $result);
116			$result = $redis->lRange('test_list', 0, 2);
117			self::assertEquals(['a'], $result);
118			$redis->lPush('test_list', ['b']);
119			$result = $redis->lRange('test_list', 0, 0);
120			self::assertEquals(['b'], $result);
121			$result = $redis->lRange('test_list', 0, 1);
122			self::assertEquals(['b', 'a'], $result);
123			$result = $redis->lRange('test_list', 0, -1);
124			self::assertEquals(['b', 'a'], $result);
125			$result = $redis->lRange('test_list', 0, -2);
126			self::assertEquals(['b'], $result);
127			}
128
129			public function del(RedisInterface $redis)
130			{
131			self::assertTrue($redis->set('testKey', 1234));
132			self::assertTrue($redis->set('testKey1', 12345));
133			$result = $redis->del(['testKey']);
134			self::assertEquals(1, $result);
135			$result = $redis->del(['testKey']);
136			self::assertEquals(0, $result);
137			self::assertTrue($redis->set('testKey1', 12345));
138			$result = $redis->del(['testKey', 'testKey1']);
139			self::assertEquals(1, $result);
140			$result = $redis->del(['testKey', 'testKey1']);
141			self::assertEquals(0, $result);
142			self::assertTrue($redis->set('testKey', 1234));
143			self::assertTrue($redis->set('testKey1', 12345));
144			$result = $redis->del(['testKey', 'testKey1']);
145			self::assertEquals(2, $result);
146			}
147
148			public function zAdd(RedisInterface $redis)
149			{
150			$redis->del(['test_zkey']);
151			$result = $redis->zAdd('test_zkey', 1, 'a');
152			self::assertEquals(1, $result);
153			$result = $redis->zAdd('test_zkey', 2, 'a');
154			self::assertEquals(0, $result);
155			}
156
157			public function zCount(RedisInterface $redis)
158			{
159			$redis->del(['test_zkey']);
160			$count = $redis->zCount('test_zkey', '-inf', '+inf');
161			self::assertEquals(0, $count);
162			$redis->zAdd('test_zkey', 1, 'a');
163			$count = $redis->zCount('test_zkey', '-inf', '+inf');
164			self::assertEquals(1, $count);
165			$count = $redis->zCount('test_zkey', 2, '+inf');
166			self::assertEquals(0, $count);
167			$redis->zAdd('test_zkey', 2, 'b');
168			$count = $redis->zCount('test_zkey', '-inf', '+inf');
169			self::assertEquals(2, $count);
170			$count = $redis->zCount('test_zkey', 2, '+inf');
171			self::assertEquals(1, $count);
172			$count = $redis->zCount('test_zkey', 0, 1);
173			self::assertEquals(1, $count);
174			}
175
176			public function zRem(RedisInterface $redis)
177			{
178			$redis->del(['test_zkey']);
179			$redis->zAdd('test_zkey', 1, 'a');
180			$result = $redis->zRem('test_zkey', 'a');
181			self::assertEquals(1, $result);
182			$result = $redis->zRem('test_zkey', 'a');
183			self::assertEquals(0, $result);
184			$redis->zAdd('test_zkey', 1, 'a');
185			$redis->zAdd('test_zkey', 1, 'b');
186			$result = $redis->zRem('test_zkey', 'a');
187			self::assertEquals(1, $result);
188			$result = $redis->zRem('test_zkey', 'b');
189			self::assertEquals(1, $result);
190			}
191
192			public function zPop(RedisInterface $redis)
193			{
194			$redis->del(['test_zkey']);
195			$redis->zAdd('test_zkey', 1, 'a');
196			$redis->zAdd('test_zkey', 2, 'b');
197			$result = $redis->zPop('test_zkey');
198			self::assertEquals('a', $result);
199			$result = $redis->zPop('test_zkey');
200			self::assertEquals('b', $result);
201			}
202
203			public function zPopByMaxScore(RedisInterface $redis)
204			{
205			$redis->del(['test_zkey']);
206			$redis->zAdd('test_zkey', 123456789, 'a');
207			$redis->zAdd('test_zkey', 212345678, 'b');
208			$result = $redis->zPopByMaxScore('test_zkey', 0);
209			self::assertEquals(false, $result);
210			$result = $redis->zPopByMaxScore('test_zkey', 200000000);
211			self::assertEquals('a', $result);
212			$result = $redis->zPopByMaxScore('test_zkey', 200000000);
213			self::assertEquals(false, $result);
214			$result = $redis->zPopByMaxScore('test_zkey', 213345678);
215			self::assertEquals('b', $result);
216			}
217			}
218

mmucklo / DtcQueueBundle

Pull Request — master (#40)

PredisPhpRedisTest::zCount() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like