* Tighten up `assertTrue` and `assertFalse` such that they test that
passed arguments `===` `true` and `===` `false` respectively, instead
of testing for truth-like or false-like.
* Start modernizing our unit tests to use explicit types for arguments,
return types, member variables, etc.
* Multiple assertion fixes that were exposed when making `assertTrue`
and `assertFalse` more explicit.
* Some formatting cleanup to style for incorrect indentation, etc, that
had crept in over many years.
* Add some more assertion helpers like `assertNull`, `assertGT`,
`assertGTE`, `assertLT`, and `assertLTE`.
Our tests have a ton of instances where we do something like:
```php
$this->assert(TRUE === $this->redis->command1());
$this->assert($this->redis->command2() === 42);
```
Which should be written like this:
```php
$this->assertTrue($this->command1());
$this->assertEquals(42, $this->command2());
```
Additionally it changes some assertions to use more relevant assertions
like `assertInArray` rather than `assertTrue(in_array())`.
* Add `assertEqualsCanonicalizing` assertion similar to what PHPUnit
has.
* Add `assertStringContains` helper assertion.
* Refactor session tests
* Update these external scripts to take formal arguments with `getopt` to
make it more straightforward what each of the currently positional
arguments are actually for.
* Create small helper classes for invoking these external scripts.
Instead of `startSessionProcess` that takes a dozen argument all but
three of which have defaults, we can use a construct like this:
```php
$runner = $this->sessionRunner()
->maxExecutionTime(300)
->lockingEnabled(true)
->lockWaitTime(-1)
->lockExpires(0)
->data($data)
->compression($name);
// Invokes startSession.php with above args.
$result = $runner->execFg();
// Invokes regenerateSessionId.php with above args
$new_id = $runner->regenerateId();
// Invokes getSessionData.php for this session ID.
$data = $runner->getData();
```
* Add a bit of logic to TestSuite to dump more information about the
source of an assertion to make it easier to track down problems when
we assert outside of a top level public `test_*` method.
* Create a few new assertions like `assertKeyExists` and
`assertKeyMissing` which will generate much nicer assertions as
opposed to
```php
$this->assertTrue($this->redis->exists($some_key));
```
* If our externally spawned session scripts fail output the exact call
that was made along with all arguments as well as the output that we
received to make it easier to narrow down.
* snake_case -> camelCase
This commit fixes our unit tests so they also pass against the KeyDB
server. We didn't ned to change all that much. Most of it was just
adding a version/keydb check.
The only change to PhpRedis itself was to relax the reply requirements
for XAUTOCLAIM. Redis 7.0.0 added a third "these elements were recently
removed" reply which KeyDB does not have.
Fixes#2466
* Add what value failed to pass our callback assertion so we can see
what we actually got from the server.
* WAITAOF requires Redis >= 7.2.0 so don't run it if the server is older
than that.
* We weren't properly passing `z_tab` through to the underlying OBJECT
handler, which was causing PhpRedis to crash if you tried to execute
the OBJECT command in a pipeline.
* Rework the `testTouch` unit test to try and avoid erroneous failures
due to CI instance CPU scheduling.
Instead of just checking whether or not something is listening on the
high ports, send a quick PING to make sure.
We're not just using another Redis instance because the point of the
test is to protect against a regression when connecting to high port
numbers.
Add a mechanism that allows users to specify an arbitrary class name, in
combination with a search path so that PhpRedis unit tests can be run
against a different client.
Additionally, this commit allows multiple classes to be invoked in one
test execution either by passing multiple `--class` arguments, or a
class argument with a comma separated value.
* Use our `redis_cmd_append_sstr_key_*` and `redis_cmd_append_sstr_zval`
wrappers, which handle key prefixing and serialization transparently.
* Rework ZADD so it can handle the bulk double response from the `INCR`
options.
* Implement `ZDIFF`, `ZINTER`, `ZUNION`, `ZMSCORE`, and
`ZRANDMEMBER` for `RedisCluster`.
* Refactor `ZUNIONSTORE` command and switch to using our centralized
zset option parsing handler.
See #1894
* Create inline wrappers of the low-level php_stream_* functions that
also keep track of the number of bytes written/read.
* Change the logic to aggregate network traffic until the user
explicitly "resets" it. I think this will be a more common use-case
(running many commands and then seeing overall network IO).
See #2106
- Finish adding docblocks with examples for all of the stream commands.
- Fix XAUTOCLAIM response handler (the reply has a slightly different
structure to XCLAIM.
Implement the TOUCH command and refactor several of our "variadic key"
commands, which were previously all using their own specific handlers.
While refactoring the code, I changed `EXISTS` to require one key (it
had previously been set to require zero keys).
Additonally, it looks like we had a disparity in two commands which
should be idential to PhpRedis: SINTERSTORE and SUNIONSTORE.
Previously, SINTERSTORE required only one argument but SUNIONSTORE 2.
I simply changed SUNIONSTORE to also only require a single argument,
since that argument could be an array.
```php
$redis->sInterStore(['dst', 'src1', 'src2']);
$redis->sUnionStore(['dst', 'src1', 'src2']);
```
Refactor XGROUP and implement the new DELCONSUMER (Redis 6.2.0) and
ENTRIESREAD (Redis 7.0.0) options. Additionally, add a proper phpdoc
block to the stub file.
See #2068
* Add ZRANGESTORE command.
* Add Redis 6.2's `REV`, `BYLEX`, and `BYSCORE` to ZRANGE options.
* Refactor several ZRANGE family commands into a single reply and
options handler, using PHP's new argument parsing macros.
* Extend our tests to use the new ZRANGE options.
See #1894
Refactor the slowlog command to use the new argument parsing API and
also change it so we no longer manually handle atomic/non-atomic
logic in the handler itself.
Redis 7.0.0 allows for getting and setting multiple config values as an
atomic operation. In order to support this while maintaining backward
compatibility, the CONFIG command is reworked to also accept an array of
values or keys and values.
See: #2068
Update BITPOS to use the new argument parsing macros as well as
implement Redis 7.0.0's BIT/BYTE modifier.
Additionally I changed `int $bit` to `bool $bit` as its a more
appropriate datatype.
See #2068
With this commit, I can now run the full `--class Redis` unit test suite
inside of a PHP8.2.x buiild tree and have them pass and not throw any
fatal zpp argument errors.
