Extended Sorted Set support by adding ZINTER command (#859)

* Refactored zinterstore, zunionstore commands and command traits

* Merge conflicts resolve, update cluster strategy test with new arguments

* Updated assertion in case if command executed faster then duration minimal threshold

* Added support for ZINTER command

* Added command link and description

Co-authored-by: Vladyslav Vildanov <vladyslavvildanov@Vladyslav-Vildanov-MacBook-Pro.local>
This commit is contained in:
Vladyslav Vildanov
2022-12-14 18:54:30 +02:00
committed by GitHub
parent f26fd899f9
commit 72bc11eb63
4 changed files with 233 additions and 0 deletions
+1
View File
@@ -119,6 +119,7 @@ use Predis\Command\CommandInterface;
* @method $this zincrby($key, $increment, $member)
* @method $this zintercard(array $keys, int $limit = 0)
* @method $this zinterstore(string $destination, array $keys, int[] $weights = [], string $aggregate = 'sum')
* @method $this zinter(array $keys, int[] $weights = [], string $aggregate = 'sum', bool $withScores = false)
* @method $this zmpop(array $keys, string $modifier = 'min', int $count = 1)
* @method $this zmscore(string $key, string ...$member)
* @method $this zrandmember(string $key, int $count = 1, bool $withScores = false)
+1
View File
@@ -135,6 +135,7 @@ use Predis\Response\Status;
* @method string zincrby(string $key, int $increment, string $member)
* @method int zintercard(array $keys, int $limit = 0)
* @method int zinterstore(string $destination, array $keys, int[] $weights = [], string $aggregate = 'sum')
* @method array zinter(array $keys, int[] $weights = [], string $aggregate = 'sum', bool $withScores = false)
* @method array zmpop(array $keys, string $modifier = 'min', int $count = 1)
* @method array zmscore(string $key, string ...$member)
* @method array zpopmin(string $key, int $count = 1)
+25
View File
@@ -0,0 +1,25 @@
<?php
namespace Predis\Command\Redis;
use Predis\Command\Traits\WithScores;
/**
* @link https://redis.io/commands/zinter/
*
* This command is similar to ZINTERSTORE, but instead of
* storing the resulting sorted set, it is returned to the client.
*/
class ZINTER extends ZINTERSTORE
{
use WithScores;
protected static $keysArgumentPositionOffset = 0;
protected static $weightsArgumentPositionOffset = 1;
protected static $aggregateArgumentPositionOffset = 2;
public function getId()
{
return 'ZINTER';
}
}
+206
View File
@@ -0,0 +1,206 @@
<?php
namespace Predis\Command\Redis;
use Predis\Response\ServerException;
use UnexpectedValueException;
/**
* @group commands
* @group realm-zset
*/
class ZINTER_Test extends PredisCommandTestCase
{
/**
* @inheritDoc
*/
protected function getExpectedCommand(): string
{
return ZINTER::class;
}
/**
* @inheritDoc
*/
protected function getExpectedId(): string
{
return 'ZINTER';
}
/**
* @dataProvider argumentsProvider
* @group disconnected
*/
public function testFilterArguments(array $actualArguments, array $expectedArguments): void
{
$command = $this->getCommand();
$command->setArguments($actualArguments);
$this->assertSame($expectedArguments, $command->getArguments());
}
public function argumentsProvider(): array
{
return [
'with required arguments only' => [
[['key1', 'key2']],
[2, 'key1', 'key2'],
],
'with weights' => [
[['key1', 'key2'], [1, 2]],
[2, 'key1', 'key2', 'WEIGHTS', 1, 2],
],
'with aggregate' => [
[['key1', 'key2'], [], 'min'],
[2, 'key1', 'key2', 'AGGREGATE', 'MIN'],
],
'with withscores' => [
[['key1', 'key2'], [], 'min', true],
[2, 'key1', 'key2', 'AGGREGATE', 'MIN', 'WITHSCORES'],
],
'with all arguments' => [
[['key1', 'key2'], [1, 2], 'min', true],
[ 2, 'key1', 'key2', 'WEIGHTS', 1, 2, 'AGGREGATE', 'MIN', 'WITHSCORES'],
]
];
}
/**
* @group connected
* @dataProvider sortedSetsProvider
* @param array $firstSortedSet
* @param array $secondSortedSet
* @param array $weights
* @param string $aggregate
* @param bool $withScores
* @param array $expectedResponse
* @return void
* @requiresRedisVersion >= 6.2.0
*/
public function testReturnsIntersectedValuesOnSortedSets(
array $firstSortedSet,
array $secondSortedSet,
array $weights,
string $aggregate,
bool $withScores,
array $expectedResponse
): void {
$redis = $this->getClient();
$redis->zadd('test-zinter1', ...$firstSortedSet);
$redis->zadd('test-zinter2', ...$secondSortedSet);
$actualResponse = $redis->zinter(
['test-zinter1', 'test-zinter2'],
$weights,
$aggregate,
$withScores
);
$this->assertSame($expectedResponse, $actualResponse);
}
/**
* @group connected
* @requiresRedisVersion >= 6.2.0
*/
public function testThrowsExceptionOnWrongType(): void
{
$this->expectException(ServerException::class);
$this->expectExceptionMessage('Operation against a key holding the wrong kind of value');
$redis = $this->getClient();
$redis->set('foo', 'bar');
$redis->zinter(['foo']);
}
/**
* @dataProvider unexpectedValueProvider
* @param $keys
* @param $weights
* @param string $aggregate
* @param bool $withScores
* @param string $expectedExceptionMessage
* @return void
* @requiresRedisVersion >= 6.2.0
*/
public function testThrowsExceptionOnUnexpectedValueGiven(
$keys,
$weights,
string $aggregate,
bool $withScores,
string $expectedExceptionMessage
): void {
$redis = $this->getClient();
$this->expectException(UnexpectedValueException::class);
$this->expectExceptionMessage($expectedExceptionMessage);
$redis->zinter($keys, $weights, $aggregate, $withScores);
}
public function sortedSetsProvider(): array
{
return [
'with required arguments' => [
[1, 'member1', 2, 'member2', 3, 'member3'],
[1, 'member1', 2, 'member2'],
[],
'sum',
false,
['member1', 'member2'],
],
'with weights and withscores' => [
[1, 'member1', 2, 'member2', 3, 'member3'],
[1, 'member1', 2, 'member2'],
[2, 3],
'sum',
true,
['member1' => '5', 'member2' => '10'],
],
'with aggregate and withscores' => [
[1, 'member1', 4, 'member2', 3, 'member3'],
[2, 'member1', 2, 'member2'],
[],
'max',
true,
['member1' => '2', 'member2' => '4'],
],
'with all arguments' => [
[1, 'member1', 5, 'member2', 4, 'member3'],
[2, 'member1', 2, 'member2'],
[2, 3],
'max',
true,
['member1' => '6', 'member2' => '10'],
],
];
}
public function unexpectedValueProvider(): array
{
return [
'with unexpected keys argument' => [
1,
[],
'sum',
false,
'Wrong keys argument type or position offset'
],
'with unexpected weights argument' => [
['key1'],
1,
'sum',
false,
'Wrong weights argument type'
],
'with unexpected aggregate argument' => [
['key1'],
[],
'wrong',
false,
'Aggregate argument accepts only: min, max, sum values'
],
];
}
}