diff options
105 files changed, 8668 insertions, 12 deletions
@@ -10,3 +10,4 @@ tags .bundle/ custom_hooks hooks/*.d +/*.gem diff --git a/Makefile b/Makefile deleted file mode 100644 index 2a78178..0000000 --- a/Makefile +++ /dev/null @@ -1,12 +0,0 @@ -REDIS_RB_VERSION=v3.3.0 -REDIS_RB_VENDOR_DIR=lib/vendor/redis -PWD=`pwd` - -all: - -update-redis: - rm -rf $(REDIS_RB_VENDOR_DIR) - git clone -b $(REDIS_RB_VERSION) https://github.com/redis/redis-rb.git $(REDIS_RB_VENDOR_DIR) - rm -rf $(REDIS_RB_VENDOR_DIR)/.git - -.PHONY=update-redis diff --git a/lib/vendor/redis/.gitignore b/lib/vendor/redis/.gitignore new file mode 100644 index 0000000..9f59639 --- /dev/null +++ b/lib/vendor/redis/.gitignore @@ -0,0 +1,16 @@ +*.rdb +*.swp +Gemfile.lock +*.gem +/tmp/ +/.idea +/.yardoc +/coverage/* +/doc/ +/examples/sentinel/sentinel.conf +/nohup.out +/pkg/* +/rdsrv +/redis/* +/test/db +/test/test.conf diff --git a/lib/vendor/redis/.travis.yml b/lib/vendor/redis/.travis.yml new file mode 100644 index 0000000..5f97abf --- /dev/null +++ b/lib/vendor/redis/.travis.yml @@ -0,0 +1,65 @@ +language: ruby + +rvm: + - 1.8.7 + - 1.9.3 + - 2.0 + - 2.1 + - 2.2 + - 2.3.0 + - jruby-18mode + - jruby-19mode + - jruby-9.0.5.0 + - rbx-2 + +gemfile: ".travis/Gemfile" + +sudo: false + +env: + global: + - VERBOSE=true + - TIMEOUT=1 + matrix: + - conn=ruby REDIS_BRANCH=2.8 + - conn=hiredis REDIS_BRANCH=2.8 + - conn=synchrony REDIS_BRANCH=2.8 + - conn=ruby REDIS_BRANCH=unstable + +branches: + only: + - master + +matrix: + exclude: + # hiredis + - rvm: jruby-18mode + gemfile: .travis/Gemfile + env: conn=hiredis REDIS_BRANCH=2.8 + - rvm: jruby-19mode + gemfile: .travis/Gemfile + env: conn=hiredis REDIS_BRANCH=2.8 + - rvm: jruby-9.0.5.0 + gemfile: .travis/Gemfile + env: conn=hiredis REDIS_BRANCH=2.8 + + # synchrony + - rvm: 1.8.7 + gemfile: .travis/Gemfile + env: conn=synchrony REDIS_BRANCH=2.8 + - rvm: jruby-18mode + gemfile: .travis/Gemfile + env: conn=synchrony REDIS_BRANCH=2.8 + - rvm: jruby-19mode + gemfile: .travis/Gemfile + env: conn=synchrony REDIS_BRANCH=2.8 + - rvm: jruby-9.0.5.0 + gemfile: .travis/Gemfile + env: conn=synchrony REDIS_BRANCH=2.8 + allow_failures: + - rvm: rbx-2 + +notifications: + irc: + - irc.freenode.net#redis-rb + email: false diff --git a/lib/vendor/redis/.travis/Gemfile b/lib/vendor/redis/.travis/Gemfile new file mode 100644 index 0000000..3fd1163 --- /dev/null +++ b/lib/vendor/redis/.travis/Gemfile @@ -0,0 +1,11 @@ +source "https://rubygems.org" + +gemspec :path => "../" + +case ENV["conn"] +when "hiredis" + gem "hiredis" +when "synchrony" + gem "hiredis" + gem "em-synchrony" +end diff --git a/lib/vendor/redis/.yardopts b/lib/vendor/redis/.yardopts new file mode 100644 index 0000000..90e3cdc --- /dev/null +++ b/lib/vendor/redis/.yardopts @@ -0,0 +1,3 @@ +--exclude redis/connection +--exclude redis/compat +--markup markdown diff --git a/lib/vendor/redis/CHANGELOG.md b/lib/vendor/redis/CHANGELOG.md new file mode 100644 index 0000000..ae5506d --- /dev/null +++ b/lib/vendor/redis/CHANGELOG.md @@ -0,0 +1,363 @@ +# 4.x (unreleased) + +## Planned breaking changes: +* `Redis#client` will no longer expose the underlying `Redis::Client`; + it has not yet been determined how 4.0 will expose the underlying + functionality, but we will make every attempt to provide a final minor + release of 3.x that provides the new interfaces in order to facilitate + a smooth transition. + +* Ruby 1.8.7 (and the 1.8 modes of JRuby and Rubinius) will no longer be + supported; 1.8.x entered end-of-life in June of 2012 and stopped receiving + security updates in June of 2013; continuing to support it would prevent + the use of newer features of Ruby. + +# 3.3.0 + +* Added support for SSL/TLS. Redis doesn't support SSL natively, so you still + need to run a terminating proxy on Redis' side. See #496. + +* Added `read_timeout` and `write_timeout` options. See #437, #482. + +* Added support for pub/sub with timeouts. See #329. + +* Added `Redis#call`, `Redis#queue` and `Redis#commit` as a more minimal API to + the client. + +* Deprecated `Redis#disconnect!` in favor of `Redis#close`. + +# 3.2.2 + +* Added support for `ZADD` options `NX`, `XX`, `CH`, `INCR`. See #547. + +* Added support for sentinel commands. See #556. + +* New `:id` option allows you to identify the client against Redis. See #510. + +* `Redis::Distributed` will raise when adding two nodes with the same ID. + See #354. + +# 3.2.1 + +* Added support for `PUBSUB` command. + +* More low-level socket errors are now raised as `CannotConnectError`. + +* Added `:connect_timeout` option. + +* Added support for `:limit` option for `ZREVRANGEBYLEX`. + +* Fixed an issue where connections become inconsistent when using Ruby's + Timeout module outside of the client (see #501, #502). + +* Added `Redis#disconnect!` as a public-API way of disconnecting the client + (without needing to use `QUIT`). See #506. + +* Fixed Sentinel support with Hiredis. + +* Fixed Sentinel support when using authentication and databases. + +* Improved resilience when trying to contact sentinels. + +# 3.2.0 + +* Redis Sentinel support. + +# 3.1.0 + +* Added debug log sanitization (#428). + +* Added support for HyperLogLog commands (Redis 2.8.9, #432). + +* Added support for `BITPOS` command (Redis 2.9.11, #412). + +* The client will now automatically reconnect after a fork (#414). + +* If you want to disable the fork-safety check and prefer to share the + connection across child processes, you can now pass the `inherit_socket` + option (#409). + +* If you want the client to attempt to reconnect more than once, you can now + pass the `reconnect_attempts` option (#347) + +# 3.0.7 + +* Added method `Redis#dup` to duplicate a Redis connection. + +* IPv6 support. + +# 3.0.6 + +* Added support for `SCAN` and variants. + +# 3.0.5 + +* Fix calling #select from a pipeline (#309). + +* Added method `Redis#connected?`. + +* Added support for `MIGRATE` (Redis 2.6). + +* Support extended SET command (#343, thanks to @benubois). + +# 3.0.4 + +* Ensure #watch without a block returns "OK" (#332). + +* Make futures identifiable (#330). + +* Fix an issue preventing STORE in a SORT with multiple GETs (#328). + +# 3.0.3 + +* Blocking list commands (`BLPOP`, `BRPOP`, `BRPOPLPUSH`) use a socket + timeout equal to the sum of the command's timeout and the Redis + client's timeout, instead of disabling socket timeout altogether. + +* Ruby 2.0 compatibility. + +* Added support for `DUMP` and `RESTORE` (Redis 2.6). + +* Added support for `BITCOUNT` and `BITOP` (Redis 2.6). + +* Call `#to_s` on value argument for `SET`, `SETEX`, `PSETEX`, `GETSET`, + `SETNX`, and `SETRANGE`. + +# 3.0.2 + +* Unescape CGI escaped password in URL. + +* Fix test to check availability of `UNIXSocket`. + +* Fix handling of score = +/- infinity for sorted set commands. + +* Replace array splats with concatenation where possible. + +* Raise if `EXEC` returns an error. + +* Passing a nil value in options hash no longer overwrites the default. + +* Allow string keys in options hash passed to `Redis.new` or + `Redis.connect`. + +* Fix uncaught error triggering unrelated error (synchrony driver). + + See f7ffd5f1a628029691084de69e5b46699bb8b96d and #248. + +# 3.0.1 + +* Fix reconnect logic not kicking in on a write error. + + See 427dbd52928af452f35aa0a57b621bee56cdcb18 and #238. + +# 3.0.0 + +### Upgrading from 2.x to 3.0 + +The following items are the most important changes to review when +upgrading from redis-rb 2.x. A full list of changes can be found below. + +* The methods for the following commands have changed the arguments they + take, their return value, or both. + + * `BLPOP`, `BRPOP`, `BRPOPLPUSH` + * `SORT` + * `MSETNX` + * `ZRANGE`, `ZREVRANGE`, `ZRANGEBYSCORE`, `ZREVRANGEBYSCORE` + * `ZINCRBY`, `ZSCORE` + +* The return value from `#pipelined` and `#multi` no longer contains + unprocessed replies, but the same replies that would be returned if + the command had not been executed in these blocks. + +* The client raises custom errors on connection errors, instead of + `RuntimeError` and errors in the `Errno` family. + +### Changes + +* Added support for scripting commands (Redis 2.6). + + Scripts can be executed using `#eval` and `#evalsha`. Both can + commands can either take two arrays to specify `KEYS` and `ARGV`, or + take a hash containing `:keys` and `:argv` to specify `KEYS` and + `ARGV`. + + ```ruby + redis.eval("return ARGV[1] * ARGV[2]", :argv => [2, 3]) + # => 6 + ``` + + Subcommands of the `SCRIPT` command can be executed via the + `#script` method. + + For example: + + ```ruby + redis.script(:load, "return ARGV[1] * ARGV[2]") + # => "58db5d365a1922f32e7aa717722141ea9c2b0cf3" + redis.script(:exists, "58db5d365a1922f32e7aa717722141ea9c2b0cf3") + # => true + redis.script(:flush) + # => "OK" + ``` + +* The repository now lives at [https://github.com/redis/redis-rb](https://github.com/redis/redis-rb). + Thanks, Ezra! + +* Added support for `PEXPIRE`, `PEXPIREAT`, `PTTL`, `PSETEX`, + `INCRYBYFLOAT`, `HINCRYBYFLOAT` and `TIME` (Redis 2.6). + +* `Redis.current` is now thread unsafe, because the client itself is thread safe. + + In the future you'll be able to do something like: + + ```ruby + Redis.current = Redis::Pool.connect + ``` + + This makes `Redis.current` actually usable in multi-threaded environments, + while not affecting those running a single thread. + +* Change API for `BLPOP`, `BRPOP` and `BRPOPLPUSH`. + + Both `BLPOP` and `BRPOP` now take a single argument equal to a + string key, or an array with string keys, followed by an optional + hash with a `:timeout` key. When not specified, the timeout defaults + to `0` to not time out. + + ```ruby + redis.blpop(["list1", "list2"], :timeout => 1.0) + ``` + + `BRPOPLPUSH` also takes an optional hash with a `:timeout` key as + last argument for consistency. When not specified, the timeout + defaults to `0` to not time out. + + ```ruby + redis.brpoplpush("some_list", "another_list", :timeout => 1.0) + ``` + +* When `SORT` is passed multiple key patterns to get via the `:get` + option, it now returns an array per result element, holding all `GET` + substitutions. + +* The `MSETNX` command now returns a boolean. + +* The `ZRANGE`, `ZREVRANGE`, `ZRANGEBYSCORE` and `ZREVRANGEBYSCORE` commands + now return an array containing `[String, Float]` pairs when + `:with_scores => true` is passed. + + For example: + + ```ruby + redis.zrange("zset", 0, -1, :with_scores => true) + # => [["foo", 1.0], ["bar", 2.0]] + ``` + +* The `ZINCRBY` and `ZSCORE` commands now return a `Float` score instead + of a string holding a representation of the score. + +* The client now raises custom exceptions where it makes sense. + + If by any chance you were rescuing low-level exceptions (`Errno::*`), + you should now rescue as follows: + + Errno::ECONNRESET -> Redis::ConnectionError + Errno::EPIPE -> Redis::ConnectionError + Errno::ECONNABORTED -> Redis::ConnectionError + Errno::EBADF -> Redis::ConnectionError + Errno::EINVAL -> Redis::ConnectionError + Errno::EAGAIN -> Redis::TimeoutError + Errno::ECONNREFUSED -> Redis::CannotConnectError + +* Always raise exceptions originating from erroneous command invocation + inside pipelines and MULTI/EXEC blocks. + + The old behavior (swallowing exceptions) could cause application bugs + to go unnoticed. + +* Implement futures for assigning values inside pipelines and MULTI/EXEC + blocks. Futures are assigned their value after the pipeline or + MULTI/EXEC block has executed. + + ```ruby + $redis.pipelined do + @future = $redis.get "key" + end + + puts @future.value + ``` + +* Ruby 1.8.6 is officially not supported. + +* Support `ZCOUNT` in `Redis::Distributed` (Michael Dungan). + +* Pipelined commands now return the same replies as when called outside + a pipeline. + + In the past, pipelined replies were returned without post-processing. + +* Support `SLOWLOG` command (Michael Bernstein). + +* Calling `SHUTDOWN` effectively disconnects the client (Stefan Kaes). + +* Basic support for mapping commands so that they can be renamed on the + server. + +* Connecting using a URL now checks that a host is given. + + It's just a small sanity check, cf. #126 + +* Support variadic commands introduced in Redis 2.4. + +# 2.2.2 + +* Added method `Redis::Distributed#hsetnx`. + +# 2.2.1 + +* Internal API: Client#call and family are now called with a single array + argument, since splatting a large number of arguments (100K+) results in a + stack overflow on 1.9.2. + +* The `INFO` command can optionally take a subcommand. When the subcommand is + `COMMANDSTATS`, the client will properly format the returned statistics per + command. Subcommands for `INFO` are available since Redis v2.3.0 (unstable). + +* Change `IO#syswrite` back to the buffered `IO#write` since some Rubies do + short writes for large (1MB+) buffers and some don't (see issue #108). + +# 2.2.0 + +* Added method `Redis#without_reconnect` that ensures the client will not try + to reconnect when running the code inside the specified block. + +* Thread-safe by default. Thread safety can be explicitly disabled by passing + `:thread_safe => false` as argument. + +* Commands called inside a MULTI/EXEC no longer raise error replies, since a + successful EXEC means the commands inside the block were executed. + +* MULTI/EXEC blocks are pipelined. + +* Don't disconnect on error replies. + +* Use `IO#syswrite` instead of `IO#write` because write buffering is not + necessary. + +* Connect to a unix socket by passing the `:path` option as argument. + +* The timeout value is coerced into a float, allowing sub-second timeouts. + +* Accept both `:with_scores` _and_ `:withscores` as argument to sorted set + commands. + +* Use [hiredis](https://github.com/pietern/hiredis-rb) (v0.3 or higher) by + requiring "redis/connection/hiredis". + +* Use [em-synchrony](https://github.com/igrigorik/em-synchrony) by requiring + "redis/connection/synchrony". + +# 2.1.1 + +See commit log. diff --git a/lib/vendor/redis/Gemfile b/lib/vendor/redis/Gemfile new file mode 100644 index 0000000..73d38bc --- /dev/null +++ b/lib/vendor/redis/Gemfile @@ -0,0 +1,4 @@ +# encoding: utf-8 +source 'https://rubygems.org' + +gemspec diff --git a/lib/vendor/redis/LICENSE b/lib/vendor/redis/LICENSE new file mode 100644 index 0000000..5e648fa --- /dev/null +++ b/lib/vendor/redis/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2009 Ezra Zygmuntowicz + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file diff --git a/lib/vendor/redis/README.md b/lib/vendor/redis/README.md new file mode 100644 index 0000000..138bf9c --- /dev/null +++ b/lib/vendor/redis/README.md @@ -0,0 +1,410 @@ +# redis-rb [![Build Status][travis-image]][travis-link] [![Inline docs][inchpages-image]][inchpages-link] + +[travis-image]: https://secure.travis-ci.org/redis/redis-rb.png?branch=master +[travis-link]: http://travis-ci.org/redis/redis-rb +[travis-home]: http://travis-ci.org/ +[inchpages-image]: http://inch-ci.org/github/redis/redis-rb.png +[inchpages-link]: http://inch-ci.org/github/redis/redis-rb + +A Ruby client library for [Redis][redis-home]. + +[redis-home]: http://redis.io + +A Ruby client that tries to match Redis' API one-to-one, while still +providing an idiomatic interface. It features thread-safety, client-side +sharding, pipelining, and an obsession for performance. + +## Upgrading from 2.x to 3.0 + +Please refer to the [CHANGELOG][changelog-3.0.0] for a summary of the +most important changes, as well as a full list of changes. + +[changelog-3.0.0]: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md#300 + +## Getting started + +To install **redis-rb**, run the following command: + +``` + gem install redis +``` + +Or if you are using **bundler**, add + +``` + gem 'redis', '~>3.2' +``` + +to your `Gemfile`, and run `bundle install` + +As of version 2.0 this client only targets Redis version 2.0 and higher. +You can use an older version of this client if you need to interface +with a Redis instance older than 2.0, but this is no longer supported. + +You can connect to Redis by instantiating the `Redis` class: + +```ruby +require "redis" + +redis = Redis.new +``` + +This assumes Redis was started with a default configuration, and is +listening on `localhost`, port 6379. If you need to connect to a remote +server or a different port, try: + +```ruby +redis = Redis.new(:host => "10.0.1.1", :port => 6380, :db => 15) +``` + +You can also specify connection options as a [`redis://` URL][redis-url]: + +```ruby +redis = Redis.new(:url => "redis://:p4ssw0rd@10.0.1.1:6380/15") +``` + +[redis-url]: http://www.iana.org/assignments/uri-schemes/prov/redis + +By default, the client will try to read the `REDIS_URL` environment variable +and use that as URL to connect to. The above statement is therefore equivalent +to setting this environment variable and calling `Redis.new` without arguments. + +To connect to Redis listening on a Unix socket, try: + +```ruby +redis = Redis.new(:path => "/tmp/redis.sock") +``` + +To connect to a password protected Redis instance, use: + +```ruby +redis = Redis.new(:password => "mysecret") +``` + +The Redis class exports methods that are named identical to the commands +they execute. The arguments these methods accept are often identical to +the arguments specified on the [Redis website][redis-commands]. For +instance, the `SET` and `GET` commands can be called like this: + +[redis-commands]: http://redis.io/commands + +```ruby +redis.set("mykey", "hello world") +# => "OK" + +redis.get("mykey") +# => "hello world" +``` + +All commands, their arguments and return values are documented, and +available on [rdoc.info][rdoc]. + +[rdoc]: http://rdoc.info/github/redis/redis-rb/ + +## Sentinel support + +The client is able to perform automatic failovers by using [Redis +Sentinel](http://redis.io/topics/sentinel). Make sure to run Redis 2.8+ +if you want to use this feature. + +To connect using Sentinel, use: + +```ruby +SENTINELS = [{:host => "127.0.0.1", :port => 26380}, + {:host => "127.0.0.1", :port => 26381}] + +redis = Redis.new(:url => "redis://mymaster", :sentinels => SENTINELS, :role => :master) +``` + +* The master name identifies a group of Redis instances composed of a master +and one or more slaves (`mymaster` in the example). + +* It is possible to optionally provide a role. The allowed roles are `master` +and `slave`. When the role is `slave`, the client will try to connect to a +random slave of the specified master. If a role is not specified, the client +will connect to the master. + +* When using the Sentinel support you need to specify a list of sentinels to +connect to. The list does not need to enumerate all your Sentinel instances, +but a few so that if one is down the client will try the next one. The client +is able to remember the last Sentinel that was able to reply correctly and will +use it for the next requests. + +## Storing objects + +Redis only stores strings as values. If you want to store an object, you +can use a serialization mechanism such as JSON: + +```ruby +require "json" + +redis.set "foo", [1, 2, 3].to_json +# => OK + +JSON.parse(redis.get("foo")) +# => [1, 2, 3] +``` + +## Pipelining + +When multiple commands are executed sequentially, but are not dependent, +the calls can be *pipelined*. This means that the client doesn't wait +for reply of the first command before sending the next command. The +advantage is that multiple commands are sent at once, resulting in +faster overall execution. + +The client can be instructed to pipeline commands by using the +`#pipelined` method. After the block is executed, the client sends all +commands to Redis and gathers their replies. These replies are returned +by the `#pipelined` method. + +```ruby +redis.pipelined do + redis.set "foo", "bar" + redis.incr "baz" +end +# => ["OK", 1] +``` + +### Executing commands atomically + +You can use `MULTI/EXEC` to run a number of commands in an atomic +fashion. This is similar to executing a pipeline, but the commands are +preceded by a call to `MULTI`, and followed by a call to `EXEC`. Like +the regular pipeline, the replies to the commands are returned by the +`#multi` method. + +```ruby +redis.multi do + redis.set "foo", "bar" + redis.incr "baz" +end +# => ["OK", 1] +``` + +### Futures + +Replies to commands in a pipeline can be accessed via the *futures* they +emit (since redis-rb 3.0). All calls inside a pipeline block return a +`Future` object, which responds to the `#value` method. When the +pipeline has successfully executed, all futures are assigned their +respective replies and can be used. + +```ruby +redis.pipelined do + @set = redis.set "foo", "bar" + @incr = redis.incr "baz" +end + +@set.value +# => "OK" + +@incr.value +# => 1 +``` + +## Error Handling + +In general, if something goes wrong you'll get an exception. For example, if +it can't connect to the server a `Redis::CannotConnectError` error will be raised. + +```ruby +begin + redis.ping +rescue Exception => e + e.inspect +# => #<Redis::CannotConnectError: Timed out connecting to Redis on 10.0.1.1:6380> + + e.message +# => Timed out connecting to Redis on 10.0.1.1:6380 +end +``` + +See lib/redis/errors.rb for information about what exceptions are possible. + +## Timeouts + +The client allows you to configure connect, read, and write timeouts. +Passing a single `timeout` option will set all three values: + +```ruby +Redis.new(:timeout => 1) +``` + +But you can use specific values for each of them: + +```ruby +Redis.new( + :connect_timeout => 0.2, + :read_timeout => 1.0, + :write_timeout => 0.5 +) +``` + +All timeout values are specified in seconds. + +When using pub/sub, you can subscribe to a channel using a timeout as well: + +```ruby +redis.subscribe_with_timeout(5, "news") do |on| + on.message do |channel, message| + # ... + end +end +``` + +If no message is received after 5 seconds, the client will unsubscribe. + + +## SSL/TLS Support + +This library supports natively terminating client side SSL/TLS connections +when talking to Redis via a server-side proxy such as [stunnel], [hitch], +or [ghostunnel]. + +To enable SSL support, pass the `:ssl => :true` option when configuring the +Redis client, or pass in `:url => "rediss://..."` (like HTTPS for Redis). +You will also need to pass in an `:ssl_params => { ... }` hash used to +configure the `OpenSSL::SSL::SSLContext` object used for the connection: + +```ruby +redis = Redis.new( + :url => "rediss://:p4ssw0rd@10.0.1.1:6381/15", + :ssl_params => { + :ca_file => "/path/to/ca.crt" + } +) +``` + +The options given to `:ssl_params` are passed directly to the +`OpenSSL::SSL::SSLContext#set_params` method and can be any valid attribute +of the SSL context. Please see the [OpenSSL::SSL::SSLContext documentation] +for all of the available attributes. + +Here is an example of passing in params that can be used for SSL client +certificate authentication (a.k.a. mutual TLS): + +```ruby +redis = Redis.new( + :url => "rediss://:p4ssw0rd@10.0.1.1:6381/15", + :ssl_params => { + :ca_file => "/path/to/ca.crt", + :cert => OpenSSL::X509::Certificate.new(File.read("client.crt")), + :key => OpenSSL::PKey::RSA.new(File.read("client.key")) + } +) +``` + +[stunnel]: https://www.stunnel.org/ +[hitch]: https://hitch-tls.org/ +[ghostunnel]: https://github.com/square/ghostunnel +[OpenSSL::SSL::SSLContext documentation]: http://ruby-doc.org/stdlib-2.3.0/libdoc/openssl/rdoc/OpenSSL/SSL/SSLContext.html + +*NOTE:* SSL is only supported by the default "Ruby" driver + + +## Expert-Mode Options + + - `inherit_socket: true`: disable safety check that prevents a forked child + from sharing a socket with its parent; this is potentially useful in order to mitigate connection churn when: + - many short-lived forked children of one process need to talk + to redis, AND + - your own code prevents the parent process from using the redis + connection while a child is alive + + Improper use of `inherit_socket` will result in corrupted and/or incorrect + responses. + +## Alternate drivers + +By default, redis-rb uses Ruby's socket library to talk with Redis. +To use an alternative connection driver it should be specified as option +when instantiating the client object. These instructions are only valid +for **redis-rb 3.0**. For instructions on how to use alternate drivers from +**redis-rb 2.2**, please refer to an [older README][readme-2.2.2]. + +[readme-2.2.2]: https://github.com/redis/redis-rb/blob/v2.2.2/README.md + +### hiredis + +The hiredis driver uses the connection facility of hiredis-rb. In turn, +hiredis-rb is a binding to the official hiredis client library. It +optimizes for speed, at the cost of portability. Because it is a C +extension, JRuby is not supported (by default). + +It is best to use hiredis when you have large replies (for example: +`LRANGE`, `SMEMBERS`, `ZRANGE`, etc.) and/or use big pipelines. + +In your Gemfile, include hiredis: + +```ruby +gem "redis", "~> 3.0.1" +gem "hiredis", "~> 0.4.5" +``` + +When instantiating the client object, specify hiredis: + +```ruby +redis = Redis.new(:driver => :hiredis) +``` + +### synchrony + +The synchrony driver adds support for [em-synchrony][em-synchrony]. +This makes redis-rb work with EventMachine's asynchronous I/O, while not +changing the exposed API. The hiredis gem needs to be available as +well, because the synchrony driver uses hiredis for parsing the Redis +protocol. + +[em-synchrony]: https://github.com/igrigorik/em-synchrony + +In your Gemfile, include em-synchrony and hiredis: + +```ruby +gem "redis", "~> 3.0.1" +gem "hiredis", "~> 0.4.5" +gem "em-synchrony" +``` + +When instantiating the client object, specify synchrony: + +```ruby +redis = Redis.new(:driver => :synchrony) +``` + +## Testing + +This library is tested using [Travis][travis-home], where it is tested +against the following interpreters and drivers: + +* MRI 1.8.7 (drivers: ruby, hiredis) +* MRI 1.9.3 (drivers: ruby, hiredis, synchrony) +* MRI 2.0 (drivers: ruby, hiredis, synchrony) +* MRI 2.1 (drivers: ruby, hiredis, synchrony) +* MRI 2.2 (drivers: ruby, hiredis, synchrony) +* MRI 2.3 (drivers: ruby, hiredis, synchrony) +* JRuby 1.7 (1.8 mode) (drivers: ruby) +* JRuby 1.7 (1.9 mode) (drivers: ruby) + +## Contributors + +(ordered chronologically with more than 5 commits, see `git shortlog -sn` for +all contributors) + +* Ezra Zygmuntowicz +* Taylor Weibley +* Matthew Clark +* Brian McKinney +* Luca Guidi +* Salvatore Sanfilippo +* Chris Wanstrath +* Damian Janowski +* Michel Martens +* Nick Quaranto +* Pieter Noordhuis +* Ilya Grigorik + +## Contributing + +[Fork the project](https://github.com/redis/redis-rb) and send pull +requests. You can also ask for help at `#redis-rb` on Freenode. diff --git a/lib/vendor/redis/Rakefile b/lib/vendor/redis/Rakefile new file mode 100644 index 0000000..2d9e137 --- /dev/null +++ b/lib/vendor/redis/Rakefile @@ -0,0 +1,87 @@ +require "rake/testtask" + +ENV["REDIS_BRANCH"] ||= "unstable" + +REDIS_DIR = File.expand_path(File.join("..", "test"), __FILE__) +REDIS_CNF = File.join(REDIS_DIR, "test.conf") +REDIS_CNF_TEMPLATE = File.join(REDIS_DIR, "test.conf.erb") +REDIS_PID = File.join(REDIS_DIR, "db", "redis.pid") +REDIS_LOG = File.join(REDIS_DIR, "db", "redis.log") +REDIS_SOCKET = File.join(REDIS_DIR, "db", "redis.sock") +BINARY = "tmp/redis-#{ENV["REDIS_BRANCH"]}/src/redis-server" + +task :default => :run + +desc "Run tests and manage server start/stop" +task :run => [:start, :test, :stop] + +desc "Start the Redis server" +task :start => [BINARY, REDIS_CNF] do + sh "#{BINARY} --version" + + redis_running = \ + begin + File.exists?(REDIS_PID) && Process.kill(0, File.read(REDIS_PID).to_i) + rescue Errno::ESRCH + FileUtils.rm REDIS_PID + false + end + + unless redis_running + unless system("#{BINARY} #{REDIS_CNF}") + abort "could not start redis-server" + end + end + + at_exit do + Rake::Task["stop"].invoke + end +end + +desc "Stop the Redis server" +task :stop do + if File.exists?(REDIS_PID) + Process.kill "INT", File.read(REDIS_PID).to_i + FileUtils.rm REDIS_PID + end +end + +desc "Clean up testing artifacts" +task :clean do + FileUtils.rm_f(BINARY) + FileUtils.rm_f(REDIS_CNF) +end + +file BINARY do + branch = ENV.fetch("REDIS_BRANCH") + + sh <<-SH + mkdir -p tmp; + cd tmp; + rm -rf redis-#{branch}; + wget https://github.com/antirez/redis/archive/#{branch}.tar.gz -O #{branch}.tar.gz; + tar xf #{branch}.tar.gz; + cd redis-#{branch}; + make + SH +end + +file REDIS_CNF => [REDIS_CNF_TEMPLATE, __FILE__] do |t| + require 'erb' + + erb = t.prerequisites[0] + template = File.read(erb) + + File.open(REDIS_CNF, 'w') do |file| + file.puts "\# This file was auto-generated at #{Time.now}", + "\# from (#{erb})", + "\#" + conf = ERB.new(template).result + file << conf + end +end + +Rake::TestTask.new do |t| + t.options = "-v" if $VERBOSE + t.test_files = FileList["test/*_test.rb"] +end diff --git a/lib/vendor/redis/benchmarking/logging.rb b/lib/vendor/redis/benchmarking/logging.rb new file mode 100644 index 0000000..353e91b --- /dev/null +++ b/lib/vendor/redis/benchmarking/logging.rb @@ -0,0 +1,71 @@ +# Run with +# +# $ ruby -Ilib benchmarking/logging.rb +# + +begin + require "bench" +rescue LoadError + $stderr.puts "`gem install bench` and try again." + exit 1 +end + +require "redis" +require "logger" + +def log(level, namespace = nil) + logger = (namespace || Kernel).const_get(:Logger).new("/dev/null") + logger.level = (namespace || Logger).const_get(level) + logger +end + +def stress(redis) + redis.flushdb + + n = (ARGV.shift || 2000).to_i + + n.times do |i| + key = "foo:#{i}" + redis.set key, i + redis.get key + end +end + +default = Redis.new + +logging_redises = [ + Redis.new(:logger => log(:DEBUG)), + Redis.new(:logger => log(:INFO)), +] + +begin + require "log4r" + + logging_redises += [ + Redis.new(:logger => log(:DEBUG, Log4r)), + Redis.new(:logger => log(:INFO, Log4r)), + ] +rescue LoadError + $stderr.puts "Log4r not installed. `gem install log4r` if you want to compare it against Ruby's Logger (spoiler: it's much faster)." +end + +benchmark "Default options (no logger)" do + stress(default) +end + +logging_redises.each do |redis| + logger = redis.client.logger + + case logger + when Logger + level = Logger::SEV_LABEL[logger.level] + when Log4r::Logger + level = logger.levels[logger.level] + end + + benchmark "#{logger.class} on #{level}" do + stress(redis) + end +end + +run 10 diff --git a/lib/vendor/redis/benchmarking/pipeline.rb b/lib/vendor/redis/benchmarking/pipeline.rb new file mode 100644 index 0000000..ecc98ba --- /dev/null +++ b/lib/vendor/redis/benchmarking/pipeline.rb @@ -0,0 +1,51 @@ +require "benchmark" + +$:.push File.join(File.dirname(__FILE__), 'lib') + +require 'redis' + +ITERATIONS = 10000 + +@r = Redis.new + +Benchmark.bmbm do |benchmark| + benchmark.report("set") do + @r.flushdb + + ITERATIONS.times do |i| + @r.set("foo#{i}", "Hello world!") + @r.get("foo#{i}") + end + end + + benchmark.report("set (pipelined)") do + @r.flushdb + + @r.pipelined do + ITERATIONS.times do |i| + @r.set("foo#{i}", "Hello world!") + @r.get("foo#{i}") + end + end + end + + benchmark.report("lpush+ltrim") do + @r.flushdb + + ITERATIONS.times do |i| + @r.lpush "lpush#{i}", i + @r.ltrim "ltrim#{i}", 0, 30 + end + end + + benchmark.report("lpush+ltrim (pipelined)") do + @r.flushdb + + @r.pipelined do + ITERATIONS.times do |i| + @r.lpush "lpush#{i}", i + @r.ltrim "ltrim#{i}", 0, 30 + end + end + end +end diff --git a/lib/vendor/redis/benchmarking/speed.rb b/lib/vendor/redis/benchmarking/speed.rb new file mode 100644 index 0000000..3780bff --- /dev/null +++ b/lib/vendor/redis/benchmarking/speed.rb @@ -0,0 +1,21 @@ +# Run with +# +# $ ruby -Ilib benchmarking/speed.rb +# + +require "benchmark" +require "redis" + +r = Redis.new +n = (ARGV.shift || 20000).to_i + +elapsed = Benchmark.realtime do + # n sets, n gets + n.times do |i| + key = "foo#{i}" + r[key] = key * 10 + r[key] + end +end + +puts '%.2f Kops' % (2 * n / 1000 / elapsed) diff --git a/lib/vendor/redis/benchmarking/suite.rb b/lib/vendor/redis/benchmarking/suite.rb new file mode 100644 index 0000000..55fd1d6 --- /dev/null +++ b/lib/vendor/redis/benchmarking/suite.rb @@ -0,0 +1,24 @@ +require 'fileutils' + +def run_in_background(command) + fork { system command } +end + +def with_all_segments(&block) + 0.upto(9) do |segment_number| + block_size = 100000 + start_index = segment_number * block_size + end_index = start_index + block_size - 1 + block.call(start_index, end_index) + end +end + +#with_all_segments do |start_index, end_index| +# puts "Initializing keys from #{start_index} to #{end_index}" +# system "ruby worker.rb initialize #{start_index} #{end_index} 0" +#end + +with_all_segments do |start_index, end_index| + run_in_background "ruby worker.rb write #{start_index} #{end_index} 10" + run_in_background "ruby worker.rb read #{start_index} #{end_index} 1" +end diff --git a/lib/vendor/redis/benchmarking/worker.rb b/lib/vendor/redis/benchmarking/worker.rb new file mode 100644 index 0000000..836d03b --- /dev/null +++ b/lib/vendor/redis/benchmarking/worker.rb @@ -0,0 +1,71 @@ +BENCHMARK_ROOT = File.dirname(__FILE__) +REDIS_ROOT = File.join(BENCHMARK_ROOT, "..", "lib") + +$: << REDIS_ROOT +require 'redis' +require 'benchmark' + +def show_usage + puts <<-EOL + Usage: worker.rb [read:write] <start_index> <end_index> <sleep_msec> + EOL +end + +def shift_from_argv + value = ARGV.shift + unless value + show_usage + exit -1 + end + value +end + +operation = shift_from_argv.to_sym +start_index = shift_from_argv.to_i +end_index = shift_from_argv.to_i +sleep_msec = shift_from_argv.to_i +sleep_duration = sleep_msec/1000.0 + +redis = Redis.new + +case operation + when :initialize + + start_index.upto(end_index) do |i| + redis[i] = 0 + end + + when :clear + + start_index.upto(end_index) do |i| + redis.delete(i) + end + + when :read, :write + + puts "Starting to #{operation} at segment #{end_index + 1}" + + loop do + t1 = Time.now + start_index.upto(end_index) do |i| + case operation + when :read + redis.get(i) + when :write + redis.incr(i) + else + raise "Unknown operation: #{operation}" + end + sleep sleep_duration + end + t2 = Time.now + + requests_processed = end_index - start_index + time = t2 - t1 + puts "#{t2.strftime("%H:%M")} [segment #{end_index + 1}] : Processed #{requests_processed} requests in #{time} seconds - #{(requests_processed/time).round} requests/sec" + end + + else + raise "Unknown operation: #{operation}" +end + diff --git a/lib/vendor/redis/examples/basic.rb b/lib/vendor/redis/examples/basic.rb new file mode 100644 index 0000000..7800cf7 --- /dev/null +++ b/lib/vendor/redis/examples/basic.rb @@ -0,0 +1,15 @@ +require 'redis' + +r = Redis.new + +r.del('foo') + +puts + +p'set foo to "bar"' +r['foo'] = 'bar' + +puts + +p 'value of foo' +p r['foo'] diff --git a/lib/vendor/redis/examples/consistency.rb b/lib/vendor/redis/examples/consistency.rb new file mode 100644 index 0000000..df34e1a --- /dev/null +++ b/lib/vendor/redis/examples/consistency.rb @@ -0,0 +1,114 @@ +# This file implements a simple consistency test for Redis-rb (or any other +# Redis environment if you pass a different client object) where a client +# writes to the database using INCR in order to increment keys, but actively +# remember the value the key should have. Before every write a read is performed +# to check if the value in the database matches the value expected. +# +# In this way this program can check for lost writes, or acknowledged writes +# that were executed. +# +# Copyright (C) 2013-2014 Salvatore Sanfilippo <antirez@gmail.com> +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +require 'redis' + +class ConsistencyTester + def initialize(redis) + @r = redis + @working_set = 10000 + @keyspace = 100000 + @writes = 0 + @reads = 0 + @failed_writes = 0 + @failed_reads = 0 + @lost_writes = 0 + @not_ack_writes = 0 + @delay = 0 + @cached = {} # We take our view of data stored in the DB. + @prefix = [Process.pid.to_s,Time.now.usec,@r.object_id,""].join("|") + @errtime = {} + end + + def genkey + # Write more often to a small subset of keys + ks = rand() > 0.5 ? @keyspace : @working_set + @prefix+"key_"+rand(ks).to_s + end + + def check_consistency(key,value) + expected = @cached[key] + return if !expected # We lack info about previous state. + if expected > value + @lost_writes += expected-value + elsif expected < value + @not_ack_writes += value-expected + end + end + + def puterr(msg) + if !@errtime[msg] || Time.now.to_i != @errtime[msg] + puts msg + end + @errtime[msg] = Time.now.to_i + end + + def test + last_report = Time.now.to_i + while true + # Read + key = genkey + begin + val = @r.get(key) + check_consistency(key,val.to_i) + @reads += 1 + rescue => e + puterr "Reading: #{e.class}: #{e.message} (#{e.backtrace.first})" + @failed_reads += 1 + end + + # Write + begin + @cached[key] = @r.incr(key).to_i + @writes += 1 + rescue => e + puterr "Writing: #{e.class}: #{e.message} (#{e.backtrace.first})" + @failed_writes += 1 + end + + # Report + sleep @delay + if Time.now.to_i != last_report + report = "#{@reads} R (#{@failed_reads} err) | " + + "#{@writes} W (#{@failed_writes} err) | " + report += "#{@lost_writes} lost | " if @lost_writes > 0 + report += "#{@not_ack_writes} noack | " if @not_ack_writes > 0 + last_report = Time.now.to_i + puts report + end + end + end +end + +Sentinels = [{:host => "127.0.0.1", :port => 26379}, + {:host => "127.0.0.1", :port => 26380}] +r = Redis.new(:url => "redis://master1", :sentinels => Sentinels, :role => :master) +tester = ConsistencyTester.new(r) +tester.test diff --git a/lib/vendor/redis/examples/dist_redis.rb b/lib/vendor/redis/examples/dist_redis.rb new file mode 100644 index 0000000..fe1c5da --- /dev/null +++ b/lib/vendor/redis/examples/dist_redis.rb @@ -0,0 +1,43 @@ +require "redis" +require "redis/distributed" + +r = Redis::Distributed.new %w[redis://localhost:6379 redis://localhost:6380 redis://localhost:6381 redis://localhost:6382] + +r.flushdb + +r['urmom'] = 'urmom' +r['urdad'] = 'urdad' +r['urmom1'] = 'urmom1' +r['urdad1'] = 'urdad1' +r['urmom2'] = 'urmom2' +r['urdad2'] = 'urdad2' +r['urmom3'] = 'urmom3' +r['urdad3'] = 'urdad3' +p r['urmom'] +p r['urdad'] +p r['urmom1'] +p r['urdad1'] +p r['urmom2'] +p r['urdad2'] +p r['urmom3'] +p r['urdad3'] + +r.rpush 'listor', 'foo1' +r.rpush 'listor', 'foo2' +r.rpush 'listor', 'foo3' +r.rpush 'listor', 'foo4' +r.rpush 'listor', 'foo5' + +p r.rpop('listor') +p r.rpop('listor') +p r.rpop('listor') +p r.rpop('listor') +p r.rpop('listor') + +puts "key distribution:" + +r.ring.nodes.each do |node| + p [node.client, node.keys("*")] +end +r.flushdb +p r.keys('*') diff --git a/lib/vendor/redis/examples/incr-decr.rb b/lib/vendor/redis/examples/incr-decr.rb new file mode 100644 index 0000000..98ff9d1 --- /dev/null +++ b/lib/vendor/redis/examples/incr-decr.rb @@ -0,0 +1,17 @@ +require 'redis' + +r = Redis.new + +puts +p 'incr' +r.del 'counter' + +p r.incr('counter') +p r.incr('counter') +p r.incr('counter') + +puts +p 'decr' +p r.decr('counter') +p r.decr('counter') +p r.decr('counter') diff --git a/lib/vendor/redis/examples/list.rb b/lib/vendor/redis/examples/list.rb new file mode 100644 index 0000000..b2f25cb --- /dev/null +++ b/lib/vendor/redis/examples/list.rb @@ -0,0 +1,26 @@ +require 'rubygems' +require 'redis' + +r = Redis.new + +r.del 'logs' + +puts + +p "pushing log messages into a LIST" +r.rpush 'logs', 'some log message' +r.rpush 'logs', 'another log message' +r.rpush 'logs', 'yet another log message' +r.rpush 'logs', 'also another log message' + +puts +p 'contents of logs LIST' + +p r.lrange('logs', 0, -1) + +puts +p 'Trim logs LIST to last 2 elements(easy circular buffer)' + +r.ltrim('logs', -2, -1) + +p r.lrange('logs', 0, -1) diff --git a/lib/vendor/redis/examples/pubsub.rb b/lib/vendor/redis/examples/pubsub.rb new file mode 100644 index 0000000..9da1506 --- /dev/null +++ b/lib/vendor/redis/examples/pubsub.rb @@ -0,0 +1,37 @@ +require "redis" + +puts <<-EOS +To play with this example use redis-cli from another terminal, like this: + + $ redis-cli publish one hello + +Finally force the example to exit sending the 'exit' message with: + + $ redis-cli publish two exit + +EOS + +redis = Redis.new + +trap(:INT) { puts; exit } + +begin + redis.subscribe(:one, :two) do |on| + on.subscribe do |channel, subscriptions| + puts "Subscribed to ##{channel} (#{subscriptions} subscriptions)" + end + + on.message do |channel, message| + puts "##{channel}: #{message}" + redis.unsubscribe if message == "exit" + end + + on.unsubscribe do |channel, subscriptions| + puts "Unsubscribed from ##{channel} (#{subscriptions} subscriptions)" + end + end +rescue Redis::BaseConnectionError => error + puts "#{error}, retrying in 1s" + sleep 1 + retry +end diff --git a/lib/vendor/redis/examples/sentinel.rb b/lib/vendor/redis/examples/sentinel.rb new file mode 100644 index 0000000..62fc5a4 --- /dev/null +++ b/lib/vendor/redis/examples/sentinel.rb @@ -0,0 +1,41 @@ +require 'redis' + +# This example creates a master-slave setup with a sentinel, then connects to +# it and sends write commands in a loop. +# +# After 30 seconds, the master dies. You will be able to see how a new master +# is elected and things continue to work as if nothing happened. +# +# To run this example: +# +# $ ruby -I./lib examples/sentinel.rb +# + +at_exit do + begin + Process.kill(:INT, $redises) + rescue Errno::ESRCH + end + + Process.waitall +end + +$redises = spawn("examples/sentinel/start") + +Sentinels = [{:host => "127.0.0.1", :port => 26379}, + {:host => "127.0.0.1", :port => 26380}] +r = Redis.new(:url => "redis://master1", :sentinels => Sentinels, :role => :master) + +# Set keys into a loop. +# +# The example traps errors so that you can actually try to failover while +# running the script to see redis-rb reconfiguring. +(0..1000000).each{|i| + begin + r.set(i,i) + $stdout.write("SET (#{i} times)\n") if i % 100 == 0 + rescue => e + $stdout.write("E") + end + sleep(0.01) +} diff --git a/lib/vendor/redis/examples/sentinel/start b/lib/vendor/redis/examples/sentinel/start new file mode 100755 index 0000000..46567e1 --- /dev/null +++ b/lib/vendor/redis/examples/sentinel/start @@ -0,0 +1,49 @@ +#! /usr/bin/env ruby + +# This is a helper script used together with examples/sentinel.rb +# It runs two Redis masters, two slaves for each of them, and two sentinels. +# After 30 seconds, the first master dies. +# +# You don't need to run this script yourself. Rather, use examples/sentinel.rb. + +require "fileutils" + +$pids = [] + +at_exit do + $pids.each do |pid| + begin + Process.kill(:INT, pid) + rescue Errno::ESRCH + end + end + + Process.waitall +end + +base = File.expand_path(File.dirname(__FILE__)) + +# Masters +$pids << spawn("redis-server --port 6380 --loglevel warning") +$pids << spawn("redis-server --port 6381 --loglevel warning") + +# Slaves of Master 1 +$pids << spawn("redis-server --port 63800 --slaveof 127.0.0.1 6380 --loglevel warning") +$pids << spawn("redis-server --port 63801 --slaveof 127.0.0.1 6380 --loglevel warning") + +# Slaves of Master 2 +$pids << spawn("redis-server --port 63810 --slaveof 127.0.0.1 6381 --loglevel warning") +$pids << spawn("redis-server --port 63811 --slaveof 127.0.0.1 6381 --loglevel warning") + +FileUtils.cp(File.join(base, "sentinel.conf"), "tmp/sentinel1.conf") +FileUtils.cp(File.join(base, "sentinel.conf"), "tmp/sentinel2.conf") + +# Sentinels +$pids << spawn("redis-server tmp/sentinel1.conf --sentinel --port 26379") +$pids << spawn("redis-server tmp/sentinel2.conf --sentinel --port 26380") + +sleep 30 + +Process.kill(:KILL, $pids[0]) + +Process.waitall diff --git a/lib/vendor/redis/examples/sets.rb b/lib/vendor/redis/examples/sets.rb new file mode 100644 index 0000000..31c49c3 --- /dev/null +++ b/lib/vendor/redis/examples/sets.rb @@ -0,0 +1,36 @@ +require 'rubygems' +require 'redis' + +r = Redis.new + +r.del 'foo-tags' +r.del 'bar-tags' + +puts +p "create a set of tags on foo-tags" + +r.sadd 'foo-tags', 'one' +r.sadd 'foo-tags', 'two' +r.sadd 'foo-tags', 'three' + +puts +p "create a set of tags on bar-tags" + +r.sadd 'bar-tags', 'three' +r.sadd 'bar-tags', 'four' +r.sadd 'bar-tags', 'five' + +puts +p 'foo-tags' + +p r.smembers('foo-tags') + +puts +p 'bar-tags' + +p r.smembers('bar-tags') + +puts +p 'intersection of foo-tags and bar-tags' + +p r.sinter('foo-tags', 'bar-tags') diff --git a/lib/vendor/redis/examples/unicorn/config.ru b/lib/vendor/redis/examples/unicorn/config.ru new file mode 100644 index 0000000..ede5573 --- /dev/null +++ b/lib/vendor/redis/examples/unicorn/config.ru @@ -0,0 +1,3 @@ +run lambda { |env| + [200, {"Content-Type" => "text/plain"}, [Redis.current.randomkey]] +} diff --git a/lib/vendor/redis/examples/unicorn/unicorn.rb b/lib/vendor/redis/examples/unicorn/unicorn.rb new file mode 100644 index 0000000..957d384 --- /dev/null +++ b/lib/vendor/redis/examples/unicorn/unicorn.rb @@ -0,0 +1,20 @@ +require "redis" + +worker_processes 3 + +# If you set the connection to Redis *before* forking, +# you will cause forks to share a file descriptor. +# +# This causes a concurrency problem by which one fork +# can read or write to the socket while others are +# performing other operations. +# +# Most likely you'll be getting ProtocolError exceptions +# mentioning a wrong initial byte in the reply. +# +# Thus we need to connect to Redis after forking the +# worker processes. + +after_fork do |server, worker| + Redis.current.disconnect! +end diff --git a/lib/vendor/redis/redis.gemspec b/lib/vendor/redis/redis.gemspec new file mode 100644 index 0000000..3099b6d --- /dev/null +++ b/lib/vendor/redis/redis.gemspec @@ -0,0 +1,44 @@ +# -*- encoding: utf-8 -*- + +$:.unshift File.expand_path("../lib", __FILE__) + +require "redis/version" + +Gem::Specification.new do |s| + s.name = "redis" + + s.version = Redis::VERSION + + s.homepage = "https://github.com/redis/redis-rb" + + s.summary = "A Ruby client library for Redis" + + s.description = <<-EOS + A Ruby client that tries to match Redis' API one-to-one, while still + providing an idiomatic interface. It features thread-safety, + client-side sharding, pipelining, and an obsession for performance. + EOS + + s.license = "MIT" + + s.authors = [ + "Ezra Zygmuntowicz", + "Taylor Weibley", + "Matthew Clark", + "Brian McKinney", + "Salvatore Sanfilippo", + "Luca Guidi", + "Michel Martens", + "Damian Janowski", + "Pieter Noordhuis" + ] + + s.email = ["redis-db@googlegroups.com"] + + s.files = `git ls-files`.split("\n") + s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n") + s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) } + + s.add_development_dependency("rake", "<11.0.0") + s.add_development_dependency("test-unit", "3.1.5") +end diff --git a/lib/vendor/redis/test/bitpos_test.rb b/lib/vendor/redis/test/bitpos_test.rb new file mode 100644 index 0000000..118294d --- /dev/null +++ b/lib/vendor/redis/test/bitpos_test.rb @@ -0,0 +1,69 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +unless defined?(Enumerator) + Enumerator = Enumerable::Enumerator +end + +class TestBitpos < Test::Unit::TestCase + + include Helper::Client + + def test_bitpos_empty_zero + target_version "2.9.11" do + r.del "foo" + assert_equal 0, r.bitpos("foo", 0) + end + end + + def test_bitpos_empty_one + target_version "2.9.11" do + r.del "foo" + assert_equal -1, r.bitpos("foo", 1) + end + end + + def test_bitpos_zero + target_version "2.9.11" do + r.set "foo", "\xff\xf0\x00" + assert_equal 12, r.bitpos("foo", 0) + end + end + + def test_bitpos_one + target_version "2.9.11" do + r.set "foo", "\x00\x0f\x00" + assert_equal 12, r.bitpos("foo", 1) + end + end + + def test_bitpos_zero_end_is_given + target_version "2.9.11" do + r.set "foo", "\xff\xff\xff" + assert_equal 24, r.bitpos("foo", 0) + assert_equal 24, r.bitpos("foo", 0, 0) + assert_equal -1, r.bitpos("foo", 0, 0, -1) + end + end + + def test_bitpos_one_intervals + target_version "2.9.11" do + r.set "foo", "\x00\xff\x00" + assert_equal 8, r.bitpos("foo", 1, 0, -1) + assert_equal 8, r.bitpos("foo", 1, 1, -1) + assert_equal -1, r.bitpos("foo", 1, 2, -1) + assert_equal -1, r.bitpos("foo", 1, 2, 200) + assert_equal 8, r.bitpos("foo", 1, 1, 1) + end + end + + def test_bitpos_raise_exception_if_stop_not_start + target_version "2.9.11" do + assert_raises(ArgumentError) do + r.bitpos("foo", 0, nil, 2) + end + end + end + +end diff --git a/lib/vendor/redis/test/blocking_commands_test.rb b/lib/vendor/redis/test/blocking_commands_test.rb new file mode 100644 index 0000000..4a2a965 --- /dev/null +++ b/lib/vendor/redis/test/blocking_commands_test.rb @@ -0,0 +1,42 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/blocking_commands" + +class TestBlockingCommands < Test::Unit::TestCase + + include Helper::Client + include Lint::BlockingCommands + + def assert_takes_longer_than_client_timeout + timeout = OPTIONS[:timeout] + delay = timeout * 2 + + mock(:delay => delay) do |r| + t1 = Time.now + yield(r) + t2 = Time.now + + assert timeout == r.client.timeout + assert delay <= (t2 - t1) + end + end + + def test_blpop_disable_client_timeout + assert_takes_longer_than_client_timeout do |r| + assert_equal ["foo", "0"], r.blpop("foo") + end + end + + def test_brpop_disable_client_timeout + assert_takes_longer_than_client_timeout do |r| + assert_equal ["foo", "0"], r.brpop("foo") + end + end + + def test_brpoplpush_disable_client_timeout + assert_takes_longer_than_client_timeout do |r| + assert_equal "0", r.brpoplpush("foo", "bar") + end + end +end diff --git a/lib/vendor/redis/test/client_test.rb b/lib/vendor/redis/test/client_test.rb new file mode 100644 index 0000000..1d0b8d3 --- /dev/null +++ b/lib/vendor/redis/test/client_test.rb @@ -0,0 +1,59 @@ +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestClient < Test::Unit::TestCase + + include Helper::Client + + def test_call + result = r.call("PING") + assert_equal result, "PONG" + end + + def test_call_with_arguments + result = r.call("SET", "foo", "bar") + assert_equal result, "OK" + end + + def test_call_integers + result = r.call("INCR", "foo") + assert_equal result, 1 + end + + def test_call_raise + assert_raises(Redis::CommandError) do + r.call("INCR") + end + end + + def test_queue_commit + r.queue("SET", "foo", "bar") + r.queue("GET", "foo") + result = r.commit + + assert_equal result, ["OK", "bar"] + end + + def test_commit_raise + r.queue("SET", "foo", "bar") + r.queue("INCR") + + assert_raise(Redis::CommandError) do + r.commit + end + end + + def test_queue_after_error + r.queue("SET", "foo", "bar") + r.queue("INCR") + + assert_raise(Redis::CommandError) do + r.commit + end + + r.queue("SET", "foo", "bar") + r.queue("INCR", "baz") + result = r.commit + + assert_equal result, ["OK", 1] + end +end diff --git a/lib/vendor/redis/test/command_map_test.rb b/lib/vendor/redis/test/command_map_test.rb new file mode 100644 index 0000000..cb401db --- /dev/null +++ b/lib/vendor/redis/test/command_map_test.rb @@ -0,0 +1,30 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestCommandMap < Test::Unit::TestCase + + include Helper::Client + + def test_override_existing_commands + r.set("counter", 1) + + assert_equal 2, r.incr("counter") + + r.client.command_map[:incr] = :decr + + assert_equal 1, r.incr("counter") + end + + def test_override_non_existing_commands + r.set("key", "value") + + assert_raise Redis::CommandError do + r.idontexist("key") + end + + r.client.command_map[:idontexist] = :get + + assert_equal "value", r.idontexist("key") + end +end diff --git a/lib/vendor/redis/test/commands_on_hashes_test.rb b/lib/vendor/redis/test/commands_on_hashes_test.rb new file mode 100644 index 0000000..f3bbfa5 --- /dev/null +++ b/lib/vendor/redis/test/commands_on_hashes_test.rb @@ -0,0 +1,21 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/hashes" + +class TestCommandsOnHashes < Test::Unit::TestCase + + include Helper::Client + include Lint::Hashes + + def test_mapped_hmget_in_a_pipeline_returns_hash + r.hset("foo", "f1", "s1") + r.hset("foo", "f2", "s2") + + result = r.pipelined do + r.mapped_hmget("foo", "f1", "f2") + end + + assert_equal result[0], { "f1" => "s1", "f2" => "s2" } + end +end diff --git a/lib/vendor/redis/test/commands_on_hyper_log_log_test.rb b/lib/vendor/redis/test/commands_on_hyper_log_log_test.rb new file mode 100644 index 0000000..a2fc95b --- /dev/null +++ b/lib/vendor/redis/test/commands_on_hyper_log_log_test.rb @@ -0,0 +1,21 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/hyper_log_log" + +class TestCommandsOnHyperLogLog < Test::Unit::TestCase + + include Helper::Client + include Lint::HyperLogLog + + def test_pfmerge + target_version "2.8.9" do + r.pfadd "foo", "s1" + r.pfadd "bar", "s2" + + assert_equal true, r.pfmerge("res", "foo", "bar") + assert_equal 2, r.pfcount("res") + end + end + +end
\ No newline at end of file diff --git a/lib/vendor/redis/test/commands_on_lists_test.rb b/lib/vendor/redis/test/commands_on_lists_test.rb new file mode 100644 index 0000000..2916c28 --- /dev/null +++ b/lib/vendor/redis/test/commands_on_lists_test.rb @@ -0,0 +1,20 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/lists" + +class TestCommandsOnLists < Test::Unit::TestCase + + include Helper::Client + include Lint::Lists + + def test_rpoplpush + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal "s2", r.rpoplpush("foo", "bar") + assert_equal ["s2"], r.lrange("bar", 0, -1) + assert_equal "s1", r.rpoplpush("foo", "bar") + assert_equal ["s1", "s2"], r.lrange("bar", 0, -1) + end +end diff --git a/lib/vendor/redis/test/commands_on_sets_test.rb b/lib/vendor/redis/test/commands_on_sets_test.rb new file mode 100644 index 0000000..7ac2f4e --- /dev/null +++ b/lib/vendor/redis/test/commands_on_sets_test.rb @@ -0,0 +1,77 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/sets" + +class TestCommandsOnSets < Test::Unit::TestCase + + include Helper::Client + include Lint::Sets + + def test_smove + r.sadd "foo", "s1" + r.sadd "bar", "s2" + + assert r.smove("foo", "bar", "s1") + assert r.sismember("bar", "s1") + end + + def test_sinter + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + + assert_equal ["s2"], r.sinter("foo", "bar") + end + + def test_sinterstore + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + + r.sinterstore("baz", "foo", "bar") + + assert_equal ["s2"], r.smembers("baz") + end + + def test_sunion + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + r.sadd "bar", "s3" + + assert_equal ["s1", "s2", "s3"], r.sunion("foo", "bar").sort + end + + def test_sunionstore + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + r.sadd "bar", "s3" + + r.sunionstore("baz", "foo", "bar") + + assert_equal ["s1", "s2", "s3"], r.smembers("baz").sort + end + + def test_sdiff + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + r.sadd "bar", "s3" + + assert_equal ["s1"], r.sdiff("foo", "bar") + assert_equal ["s3"], r.sdiff("bar", "foo") + end + + def test_sdiffstore + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + r.sadd "bar", "s3" + + r.sdiffstore("baz", "foo", "bar") + + assert_equal ["s1"], r.smembers("baz") + end +end diff --git a/lib/vendor/redis/test/commands_on_sorted_sets_test.rb b/lib/vendor/redis/test/commands_on_sorted_sets_test.rb new file mode 100644 index 0000000..0a424be --- /dev/null +++ b/lib/vendor/redis/test/commands_on_sorted_sets_test.rb @@ -0,0 +1,137 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/sorted_sets" + +class TestCommandsOnSortedSets < Test::Unit::TestCase + + include Helper::Client + include Lint::SortedSets + + def test_zrangebylex + target_version "2.8.9" do + r.zadd "foo", 0, "aaren" + r.zadd "foo", 0, "abagael" + r.zadd "foo", 0, "abby" + r.zadd "foo", 0, "abbygail" + + assert_equal ["aaren", "abagael", "abby", "abbygail"], r.zrangebylex("foo", "[a", "[a\xff") + assert_equal ["aaren", "abagael"], r.zrangebylex("foo", "[a", "[a\xff", :limit => [0, 2]) + assert_equal ["abby", "abbygail"], r.zrangebylex("foo", "(abb", "(abb\xff") + assert_equal ["abbygail"], r.zrangebylex("foo", "(abby", "(abby\xff") + end + end + + def test_zrevrangebylex + target_version "2.9.9" do + r.zadd "foo", 0, "aaren" + r.zadd "foo", 0, "abagael" + r.zadd "foo", 0, "abby" + r.zadd "foo", 0, "abbygail" + + assert_equal ["abbygail", "abby", "abagael", "aaren"], r.zrevrangebylex("foo", "[a\xff", "[a") + assert_equal ["abbygail", "abby"], r.zrevrangebylex("foo", "[a\xff", "[a", :limit => [0, 2]) + assert_equal ["abbygail", "abby"], r.zrevrangebylex("foo", "(abb\xff", "(abb") + assert_equal ["abbygail"], r.zrevrangebylex("foo", "(abby\xff", "(abby") + end + end + + def test_zcount + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + + assert_equal 2, r.zcount("foo", 2, 3) + end + + def test_zunionstore + r.zadd "foo", 1, "s1" + r.zadd "bar", 2, "s2" + r.zadd "foo", 3, "s3" + r.zadd "bar", 4, "s4" + + assert_equal 4, r.zunionstore("foobar", ["foo", "bar"]) + assert_equal ["s1", "s2", "s3", "s4"], r.zrange("foobar", 0, -1) + end + + def test_zunionstore_with_weights + r.zadd "foo", 1, "s1" + r.zadd "foo", 3, "s3" + r.zadd "bar", 20, "s2" + r.zadd "bar", 40, "s4" + + assert_equal 4, r.zunionstore("foobar", ["foo", "bar"]) + assert_equal ["s1", "s3", "s2", "s4"], r.zrange("foobar", 0, -1) + + assert_equal 4, r.zunionstore("foobar", ["foo", "bar"], :weights => [10, 1]) + assert_equal ["s1", "s2", "s3", "s4"], r.zrange("foobar", 0, -1) + end + + def test_zunionstore_with_aggregate + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "bar", 4, "s2" + r.zadd "bar", 3, "s3" + + assert_equal 3, r.zunionstore("foobar", ["foo", "bar"]) + assert_equal ["s1", "s3", "s2"], r.zrange("foobar", 0, -1) + + assert_equal 3, r.zunionstore("foobar", ["foo", "bar"], :aggregate => :min) + assert_equal ["s1", "s2", "s3"], r.zrange("foobar", 0, -1) + + assert_equal 3, r.zunionstore("foobar", ["foo", "bar"], :aggregate => :max) + assert_equal ["s1", "s3", "s2"], r.zrange("foobar", 0, -1) + end + + def test_zinterstore + r.zadd "foo", 1, "s1" + r.zadd "bar", 2, "s1" + r.zadd "foo", 3, "s3" + r.zadd "bar", 4, "s4" + + assert_equal 1, r.zinterstore("foobar", ["foo", "bar"]) + assert_equal ["s1"], r.zrange("foobar", 0, -1) + end + + def test_zinterstore_with_weights + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + r.zadd "bar", 20, "s2" + r.zadd "bar", 30, "s3" + r.zadd "bar", 40, "s4" + + assert_equal 2, r.zinterstore("foobar", ["foo", "bar"]) + assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1) + + assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :weights => [10, 1]) + assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1) + + assert_equal 40.0, r.zscore("foobar", "s2") + assert_equal 60.0, r.zscore("foobar", "s3") + end + + def test_zinterstore_with_aggregate + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + r.zadd "bar", 20, "s2" + r.zadd "bar", 30, "s3" + r.zadd "bar", 40, "s4" + + assert_equal 2, r.zinterstore("foobar", ["foo", "bar"]) + assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1) + assert_equal 22.0, r.zscore("foobar", "s2") + assert_equal 33.0, r.zscore("foobar", "s3") + + assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :aggregate => :min) + assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1) + assert_equal 2.0, r.zscore("foobar", "s2") + assert_equal 3.0, r.zscore("foobar", "s3") + + assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :aggregate => :max) + assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1) + assert_equal 20.0, r.zscore("foobar", "s2") + assert_equal 30.0, r.zscore("foobar", "s3") + end +end diff --git a/lib/vendor/redis/test/commands_on_strings_test.rb b/lib/vendor/redis/test/commands_on_strings_test.rb new file mode 100644 index 0000000..9172aac --- /dev/null +++ b/lib/vendor/redis/test/commands_on_strings_test.rb @@ -0,0 +1,101 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/strings" + +class TestCommandsOnStrings < Test::Unit::TestCase + + include Helper::Client + include Lint::Strings + + def test_mget + r.set("foo", "s1") + r.set("bar", "s2") + + assert_equal ["s1", "s2"] , r.mget("foo", "bar") + assert_equal ["s1", "s2", nil], r.mget("foo", "bar", "baz") + end + + def test_mget_mapped + r.set("foo", "s1") + r.set("bar", "s2") + + response = r.mapped_mget("foo", "bar") + + assert_equal "s1", response["foo"] + assert_equal "s2", response["bar"] + + response = r.mapped_mget("foo", "bar", "baz") + + assert_equal "s1", response["foo"] + assert_equal "s2", response["bar"] + assert_equal nil , response["baz"] + end + + def test_mapped_mget_in_a_pipeline_returns_hash + r.set("foo", "s1") + r.set("bar", "s2") + + result = r.pipelined do + r.mapped_mget("foo", "bar") + end + + assert_equal result[0], { "foo" => "s1", "bar" => "s2" } + end + + def test_mset + r.mset(:foo, "s1", :bar, "s2") + + assert_equal "s1", r.get("foo") + assert_equal "s2", r.get("bar") + end + + def test_mset_mapped + r.mapped_mset(:foo => "s1", :bar => "s2") + + assert_equal "s1", r.get("foo") + assert_equal "s2", r.get("bar") + end + + def test_msetnx + r.set("foo", "s1") + assert_equal false, r.msetnx(:foo, "s2", :bar, "s3") + assert_equal "s1", r.get("foo") + assert_equal nil, r.get("bar") + + r.del("foo") + assert_equal true, r.msetnx(:foo, "s2", :bar, "s3") + assert_equal "s2", r.get("foo") + assert_equal "s3", r.get("bar") + end + + def test_msetnx_mapped + r.set("foo", "s1") + assert_equal false, r.mapped_msetnx(:foo => "s2", :bar => "s3") + assert_equal "s1", r.get("foo") + assert_equal nil, r.get("bar") + + r.del("foo") + assert_equal true, r.mapped_msetnx(:foo => "s2", :bar => "s3") + assert_equal "s2", r.get("foo") + assert_equal "s3", r.get("bar") + end + + def test_bitop + try_encoding("UTF-8") do + target_version "2.5.10" do + r.set("foo", "a") + r.set("bar", "b") + + r.bitop(:and, "foo&bar", "foo", "bar") + assert_equal "\x60", r.get("foo&bar") + r.bitop(:or, "foo|bar", "foo", "bar") + assert_equal "\x63", r.get("foo|bar") + r.bitop(:xor, "foo^bar", "foo", "bar") + assert_equal "\x03", r.get("foo^bar") + r.bitop(:not, "~foo", "foo") + assert_equal "\x9E", r.get("~foo") + end + end + end +end diff --git a/lib/vendor/redis/test/commands_on_value_types_test.rb b/lib/vendor/redis/test/commands_on_value_types_test.rb new file mode 100644 index 0000000..6b2f211 --- /dev/null +++ b/lib/vendor/redis/test/commands_on_value_types_test.rb @@ -0,0 +1,133 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/value_types" + +class TestCommandsOnValueTypes < Test::Unit::TestCase + + include Helper::Client + include Lint::ValueTypes + + def test_del + r.set "foo", "s1" + r.set "bar", "s2" + r.set "baz", "s3" + + assert_equal ["bar", "baz", "foo"], r.keys("*").sort + + assert_equal 1, r.del("foo") + + assert_equal ["bar", "baz"], r.keys("*").sort + + assert_equal 2, r.del("bar", "baz") + + assert_equal [], r.keys("*").sort + end + + def test_del_with_array_argument + r.set "foo", "s1" + r.set "bar", "s2" + r.set "baz", "s3" + + assert_equal ["bar", "baz", "foo"], r.keys("*").sort + + assert_equal 1, r.del(["foo"]) + + assert_equal ["bar", "baz"], r.keys("*").sort + + assert_equal 2, r.del(["bar", "baz"]) + + assert_equal [], r.keys("*").sort + end + + def test_randomkey + assert r.randomkey.to_s.empty? + + r.set("foo", "s1") + + assert_equal "foo", r.randomkey + + r.set("bar", "s2") + + 4.times do + assert ["foo", "bar"].include?(r.randomkey) + end + end + + def test_rename + r.set("foo", "s1") + r.rename "foo", "bar" + + assert_equal "s1", r.get("bar") + assert_equal nil, r.get("foo") + end + + def test_renamenx + r.set("foo", "s1") + r.set("bar", "s2") + + assert_equal false, r.renamenx("foo", "bar") + + assert_equal "s1", r.get("foo") + assert_equal "s2", r.get("bar") + end + + def test_dbsize + assert_equal 0, r.dbsize + + r.set("foo", "s1") + + assert_equal 1, r.dbsize + end + + def test_flushdb + r.set("foo", "s1") + r.set("bar", "s2") + + assert_equal 2, r.dbsize + + r.flushdb + + assert_equal 0, r.dbsize + end + + def test_flushall + redis_mock(:flushall => lambda { "+FLUSHALL" }) do |redis| + assert_equal "FLUSHALL", redis.flushall + end + end + + def test_migrate + redis_mock(:migrate => lambda { |*args| args }) do |redis| + options = { :host => "127.0.0.1", :port => 1234 } + + ex = assert_raise(RuntimeError) do + redis.migrate("foo", options.reject { |key, _| key == :host }) + end + assert ex.message =~ /host not specified/ + + ex = assert_raise(RuntimeError) do + redis.migrate("foo", options.reject { |key, _| key == :port }) + end + assert ex.message =~ /port not specified/ + + default_db = redis.client.db.to_i + default_timeout = redis.client.timeout.to_i + + # Test defaults + actual = redis.migrate("foo", options) + expected = ["127.0.0.1", "1234", "foo", default_db.to_s, default_timeout.to_s] + assert_equal expected, actual + + # Test db override + actual = redis.migrate("foo", options.merge(:db => default_db + 1)) + expected = ["127.0.0.1", "1234", "foo", (default_db + 1).to_s, default_timeout.to_s] + assert_equal expected, actual + + # Test timeout override + actual = redis.migrate("foo", options.merge(:timeout => default_timeout + 1)) + expected = ["127.0.0.1", "1234", "foo", default_db.to_s, (default_timeout + 1).to_s] + assert_equal expected, actual + end + end +end diff --git a/lib/vendor/redis/test/connection_handling_test.rb b/lib/vendor/redis/test/connection_handling_test.rb new file mode 100644 index 0000000..f11553b --- /dev/null +++ b/lib/vendor/redis/test/connection_handling_test.rb @@ -0,0 +1,277 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestConnectionHandling < Test::Unit::TestCase + + include Helper::Client + + def test_auth + commands = { + :auth => lambda { |password| $auth = password; "+OK" }, + :get => lambda { |key| $auth == "secret" ? "$3\r\nbar" : "$-1" }, + } + + redis_mock(commands, :password => "secret") do |redis| + assert_equal "bar", redis.get("foo") + end + end + + def test_id + commands = { + :client => lambda { |cmd, name| $name = [cmd, name]; "+OK" }, + :ping => lambda { "+PONG" }, + } + + redis_mock(commands, :id => "client-name") do |redis| + assert_equal "PONG", redis.ping + end + + assert_equal ["setname","client-name"], $name + end + + def test_ping + assert_equal "PONG", r.ping + end + + def test_select + r.set "foo", "bar" + + r.select 14 + assert_equal nil, r.get("foo") + + r.client.disconnect + + assert_equal nil, r.get("foo") + end + + def test_quit + r.quit + + assert !r.client.connected? + end + + def test_close + quit = 0 + + commands = { + :quit => lambda do + quit += 1 + "+OK" + end + } + + redis_mock(commands) do |redis| + assert_equal 0, quit + + redis.quit + + assert_equal 1, quit + + redis.ping + + redis.close + + assert_equal 1, quit + + assert !redis.connected? + end + end + + def test_disconnect + quit = 0 + + commands = { + :quit => lambda do + quit += 1 + "+OK" + end + } + + redis_mock(commands) do |redis| + assert_equal 0, quit + + redis.quit + + assert_equal 1, quit + + redis.ping + + redis.disconnect! + + assert_equal 1, quit + + assert !redis.connected? + end + end + + def test_shutdown + commands = { + :shutdown => lambda { :exit } + } + + redis_mock(commands) do |redis| + # SHUTDOWN does not reply: test that it does not raise here. + assert_equal nil, redis.shutdown + end + end + + def test_shutdown_with_error + connections = 0 + commands = { + :select => lambda { |*_| connections += 1; "+OK\r\n" }, + :connections => lambda { ":#{connections}\r\n" }, + :shutdown => lambda { "-ERR could not shutdown\r\n" } + } + + redis_mock(commands) do |redis| + connections = redis.connections + + # SHUTDOWN replies with an error: test that it gets raised + assert_raise Redis::CommandError do + redis.shutdown + end + + # The connection should remain in tact + assert_equal connections, redis.connections + end + end + + def test_shutdown_from_pipeline + commands = { + :shutdown => lambda { :exit } + } + + redis_mock(commands) do |redis| + result = redis.pipelined do + redis.shutdown + end + + assert_equal nil, result + assert !redis.client.connected? + end + end + + def test_shutdown_with_error_from_pipeline + connections = 0 + commands = { + :select => lambda { |*_| connections += 1; "+OK\r\n" }, + :connections => lambda { ":#{connections}\r\n" }, + :shutdown => lambda { "-ERR could not shutdown\r\n" } + } + + redis_mock(commands) do |redis| + connections = redis.connections + + # SHUTDOWN replies with an error: test that it gets raised + assert_raise Redis::CommandError do + redis.pipelined do + redis.shutdown + end + end + + # The connection should remain in tact + assert_equal connections, redis.connections + end + end + + def test_shutdown_from_multi_exec + commands = { + :multi => lambda { "+OK\r\n" }, + :shutdown => lambda { "+QUEUED\r\n" }, + :exec => lambda { :exit } + } + + redis_mock(commands) do |redis| + result = redis.multi do + redis.shutdown + end + + assert_equal nil, result + assert !redis.client.connected? + end + end + + def test_shutdown_with_error_from_multi_exec + connections = 0 + commands = { + :select => lambda { |*_| connections += 1; "+OK\r\n" }, + :connections => lambda { ":#{connections}\r\n" }, + :multi => lambda { "+OK\r\n" }, + :shutdown => lambda { "+QUEUED\r\n" }, + :exec => lambda { "*1\r\n-ERR could not shutdown\r\n" } + } + + redis_mock(commands) do |redis| + connections = redis.connections + + # SHUTDOWN replies with an error: test that it gets returned + # We should test for Redis::CommandError here, but hiredis doesn't yet do + # custom error classes. + err = nil + + begin + redis.multi { redis.shutdown } + rescue => err + end + + assert err.kind_of?(StandardError) + + # The connection should remain intact + assert_equal connections, redis.connections + end + end + + def test_slaveof + redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do |redis| + assert_equal "SLAVEOF somehost 6381", redis.slaveof("somehost", 6381) + end + end + + def test_bgrewriteaof + redis_mock(:bgrewriteaof => lambda { "+BGREWRITEAOF" }) do |redis| + assert_equal "BGREWRITEAOF", redis.bgrewriteaof + end + end + + def test_config_get + assert r.config(:get, "*")["timeout"] != nil + + config = r.config(:get, "timeout") + assert_equal ["timeout"], config.keys + assert config.values.compact.size > 0 + end + + def test_config_set + begin + assert_equal "OK", r.config(:set, "timeout", 200) + assert_equal "200", r.config(:get, "*")["timeout"] + + assert_equal "OK", r.config(:set, "timeout", 100) + assert_equal "100", r.config(:get, "*")["timeout"] + ensure + r.config :set, "timeout", 300 + end + end + + driver(:ruby, :hiredis) do + def test_consistency_on_multithreaded_env + t = nil + + commands = { + :set => lambda { |key, value| t.kill; "+OK\r\n" }, + :incr => lambda { |key| ":1\r\n" }, + } + + redis_mock(commands) do |redis| + t = Thread.new do + redis.set("foo", "bar") + end + + t.join + + assert_equal 1, redis.incr("baz") + end + end + end +end diff --git a/lib/vendor/redis/test/distributed_blocking_commands_test.rb b/lib/vendor/redis/test/distributed_blocking_commands_test.rb new file mode 100644 index 0000000..b28cf27 --- /dev/null +++ b/lib/vendor/redis/test/distributed_blocking_commands_test.rb @@ -0,0 +1,46 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/blocking_commands" + +class TestDistributedBlockingCommands < Test::Unit::TestCase + + include Helper::Distributed + include Lint::BlockingCommands + + def test_blpop_raises + assert_raises(Redis::Distributed::CannotDistribute) do + r.blpop(["foo", "bar"]) + end + end + + def test_blpop_raises_with_old_prototype + assert_raises(Redis::Distributed::CannotDistribute) do + r.blpop("foo", "bar", 0) + end + end + + def test_brpop_raises + assert_raises(Redis::Distributed::CannotDistribute) do + r.brpop(["foo", "bar"]) + end + end + + def test_brpop_raises_with_old_prototype + assert_raises(Redis::Distributed::CannotDistribute) do + r.brpop("foo", "bar", 0) + end + end + + def test_brpoplpush_raises + assert_raises(Redis::Distributed::CannotDistribute) do + r.brpoplpush("foo", "bar") + end + end + + def test_brpoplpush_raises_with_old_prototype + assert_raises(Redis::Distributed::CannotDistribute) do + r.brpoplpush("foo", "bar", 0) + end + end +end diff --git a/lib/vendor/redis/test/distributed_commands_on_hashes_test.rb b/lib/vendor/redis/test/distributed_commands_on_hashes_test.rb new file mode 100644 index 0000000..ffd14f5 --- /dev/null +++ b/lib/vendor/redis/test/distributed_commands_on_hashes_test.rb @@ -0,0 +1,10 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/hashes" + +class TestDistributedCommandsOnHashes < Test::Unit::TestCase + + include Helper::Distributed + include Lint::Hashes +end diff --git a/lib/vendor/redis/test/distributed_commands_on_hyper_log_log_test.rb b/lib/vendor/redis/test/distributed_commands_on_hyper_log_log_test.rb new file mode 100644 index 0000000..c118b95 --- /dev/null +++ b/lib/vendor/redis/test/distributed_commands_on_hyper_log_log_test.rb @@ -0,0 +1,33 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/hyper_log_log" + +class TestDistributedCommandsOnHyperLogLog < Test::Unit::TestCase + + include Helper::Distributed + include Lint::HyperLogLog + + def test_pfmerge + target_version "2.8.9" do + assert_raise Redis::Distributed::CannotDistribute do + r.pfadd "foo", "s1" + r.pfadd "bar", "s2" + + assert r.pfmerge("res", "foo", "bar") + end + end + end + + def test_pfcount_multiple_keys_diff_nodes + target_version "2.8.9" do + assert_raise Redis::Distributed::CannotDistribute do + r.pfadd "foo", "s1" + r.pfadd "bar", "s2" + + assert r.pfcount("res", "foo", "bar") + end + end + end + +end diff --git a/lib/vendor/redis/test/distributed_commands_on_lists_test.rb b/lib/vendor/redis/test/distributed_commands_on_lists_test.rb new file mode 100644 index 0000000..d22f3be --- /dev/null +++ b/lib/vendor/redis/test/distributed_commands_on_lists_test.rb @@ -0,0 +1,22 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/lists" + +class TestDistributedCommandsOnLists < Test::Unit::TestCase + + include Helper::Distributed + include Lint::Lists + + def test_rpoplpush + assert_raise Redis::Distributed::CannotDistribute do + r.rpoplpush("foo", "bar") + end + end + + def test_brpoplpush + assert_raise Redis::Distributed::CannotDistribute do + r.brpoplpush("foo", "bar", :timeout => 1) + end + end +end diff --git a/lib/vendor/redis/test/distributed_commands_on_sets_test.rb b/lib/vendor/redis/test/distributed_commands_on_sets_test.rb new file mode 100644 index 0000000..43a070c --- /dev/null +++ b/lib/vendor/redis/test/distributed_commands_on_sets_test.rb @@ -0,0 +1,83 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/sets" + +class TestDistributedCommandsOnSets < Test::Unit::TestCase + + include Helper::Distributed + include Lint::Sets + + def test_smove + assert_raise Redis::Distributed::CannotDistribute do + r.sadd "foo", "s1" + r.sadd "bar", "s2" + + r.smove("foo", "bar", "s1") + end + end + + def test_sinter + assert_raise Redis::Distributed::CannotDistribute do + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + + r.sinter("foo", "bar") + end + end + + def test_sinterstore + assert_raise Redis::Distributed::CannotDistribute do + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + + r.sinterstore("baz", "foo", "bar") + end + end + + def test_sunion + assert_raise Redis::Distributed::CannotDistribute do + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + r.sadd "bar", "s3" + + r.sunion("foo", "bar") + end + end + + def test_sunionstore + assert_raise Redis::Distributed::CannotDistribute do + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + r.sadd "bar", "s3" + + r.sunionstore("baz", "foo", "bar") + end + end + + def test_sdiff + assert_raise Redis::Distributed::CannotDistribute do + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + r.sadd "bar", "s3" + + r.sdiff("foo", "bar") + end + end + + def test_sdiffstore + assert_raise Redis::Distributed::CannotDistribute do + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "bar", "s2" + r.sadd "bar", "s3" + + r.sdiffstore("baz", "foo", "bar") + end + end +end diff --git a/lib/vendor/redis/test/distributed_commands_on_sorted_sets_test.rb b/lib/vendor/redis/test/distributed_commands_on_sorted_sets_test.rb new file mode 100644 index 0000000..a4150b8 --- /dev/null +++ b/lib/vendor/redis/test/distributed_commands_on_sorted_sets_test.rb @@ -0,0 +1,18 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/sorted_sets" + +class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase + + include Helper::Distributed + include Lint::SortedSets + + def test_zcount + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + + assert_equal 2, r.zcount("foo", 2, 3) + end +end diff --git a/lib/vendor/redis/test/distributed_commands_on_strings_test.rb b/lib/vendor/redis/test/distributed_commands_on_strings_test.rb new file mode 100644 index 0000000..ad83c12 --- /dev/null +++ b/lib/vendor/redis/test/distributed_commands_on_strings_test.rb @@ -0,0 +1,59 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/strings" + +class TestDistributedCommandsOnStrings < Test::Unit::TestCase + + include Helper::Distributed + include Lint::Strings + + def test_mget + assert_raise Redis::Distributed::CannotDistribute do + r.mget("foo", "bar") + end + end + + def test_mget_mapped + assert_raise Redis::Distributed::CannotDistribute do + r.mapped_mget("foo", "bar") + end + end + + def test_mset + assert_raise Redis::Distributed::CannotDistribute do + r.mset(:foo, "s1", :bar, "s2") + end + end + + def test_mset_mapped + assert_raise Redis::Distributed::CannotDistribute do + r.mapped_mset(:foo => "s1", :bar => "s2") + end + end + + def test_msetnx + assert_raise Redis::Distributed::CannotDistribute do + r.set("foo", "s1") + r.msetnx(:foo, "s2", :bar, "s3") + end + end + + def test_msetnx_mapped + assert_raise Redis::Distributed::CannotDistribute do + r.set("foo", "s1") + r.mapped_msetnx(:foo => "s2", :bar => "s3") + end + end + + def test_bitop + target_version "2.5.10" do + assert_raise Redis::Distributed::CannotDistribute do + r.set("foo", "a") + r.set("bar", "b") + + r.bitop(:and, "foo&bar", "foo", "bar") + end + end + end +end diff --git a/lib/vendor/redis/test/distributed_commands_on_value_types_test.rb b/lib/vendor/redis/test/distributed_commands_on_value_types_test.rb new file mode 100644 index 0000000..0be9ce2 --- /dev/null +++ b/lib/vendor/redis/test/distributed_commands_on_value_types_test.rb @@ -0,0 +1,95 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) +require "lint/value_types" + +class TestDistributedCommandsOnValueTypes < Test::Unit::TestCase + + include Helper::Distributed + include Lint::ValueTypes + + def test_del + r.set "foo", "s1" + r.set "bar", "s2" + r.set "baz", "s3" + + assert_equal ["bar", "baz", "foo"], r.keys("*").sort + + assert_equal 1, r.del("foo") + + assert_equal ["bar", "baz"], r.keys("*").sort + + assert_equal 2, r.del("bar", "baz") + + assert_equal [], r.keys("*").sort + end + + def test_del_with_array_argument + r.set "foo", "s1" + r.set "bar", "s2" + r.set "baz", "s3" + + assert_equal ["bar", "baz", "foo"], r.keys("*").sort + + assert_equal 1, r.del(["foo"]) + + assert_equal ["bar", "baz"], r.keys("*").sort + + assert_equal 2, r.del(["bar", "baz"]) + + assert_equal [], r.keys("*").sort + end + + def test_randomkey + assert_raise Redis::Distributed::CannotDistribute do + r.randomkey + end + end + + def test_rename + assert_raise Redis::Distributed::CannotDistribute do + r.set("foo", "s1") + r.rename "foo", "bar" + end + + assert_equal "s1", r.get("foo") + assert_equal nil, r.get("bar") + end + + def test_renamenx + assert_raise Redis::Distributed::CannotDistribute do + r.set("foo", "s1") + r.rename "foo", "bar" + end + + assert_equal "s1", r.get("foo") + assert_equal nil , r.get("bar") + end + + def test_dbsize + assert_equal [0], r.dbsize + + r.set("foo", "s1") + + assert_equal [1], r.dbsize + end + + def test_flushdb + r.set("foo", "s1") + r.set("bar", "s2") + + assert_equal [2], r.dbsize + + r.flushdb + + assert_equal [0], r.dbsize + end + + def test_migrate + r.set("foo", "s1") + + assert_raise Redis::Distributed::CannotDistribute do + r.migrate("foo", {}) + end + end +end diff --git a/lib/vendor/redis/test/distributed_commands_requiring_clustering_test.rb b/lib/vendor/redis/test/distributed_commands_requiring_clustering_test.rb new file mode 100644 index 0000000..da8063c --- /dev/null +++ b/lib/vendor/redis/test/distributed_commands_requiring_clustering_test.rb @@ -0,0 +1,164 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedCommandsRequiringClustering < Test::Unit::TestCase + + include Helper::Distributed + + def test_rename + r.set("{qux}foo", "s1") + r.rename "{qux}foo", "{qux}bar" + + assert_equal "s1", r.get("{qux}bar") + assert_equal nil, r.get("{qux}foo") + end + + def test_renamenx + r.set("{qux}foo", "s1") + r.set("{qux}bar", "s2") + + assert_equal false, r.renamenx("{qux}foo", "{qux}bar") + + assert_equal "s1", r.get("{qux}foo") + assert_equal "s2", r.get("{qux}bar") + end + + def test_brpoplpush + r.rpush "{qux}foo", "s1" + r.rpush "{qux}foo", "s2" + + assert_equal "s2", r.brpoplpush("{qux}foo", "{qux}bar", :timeout => 1) + assert_equal ["s2"], r.lrange("{qux}bar", 0, -1) + end + + def test_rpoplpush + r.rpush "{qux}foo", "s1" + r.rpush "{qux}foo", "s2" + + assert_equal "s2", r.rpoplpush("{qux}foo", "{qux}bar") + assert_equal ["s2"], r.lrange("{qux}bar", 0, -1) + assert_equal "s1", r.rpoplpush("{qux}foo", "{qux}bar") + assert_equal ["s1", "s2"], r.lrange("{qux}bar", 0, -1) + end + + def test_smove + r.sadd "{qux}foo", "s1" + r.sadd "{qux}bar", "s2" + + assert r.smove("{qux}foo", "{qux}bar", "s1") + assert r.sismember("{qux}bar", "s1") + end + + def test_sinter + r.sadd "{qux}foo", "s1" + r.sadd "{qux}foo", "s2" + r.sadd "{qux}bar", "s2" + + assert_equal ["s2"], r.sinter("{qux}foo", "{qux}bar") + end + + def test_sinterstore + r.sadd "{qux}foo", "s1" + r.sadd "{qux}foo", "s2" + r.sadd "{qux}bar", "s2" + + r.sinterstore("{qux}baz", "{qux}foo", "{qux}bar") + + assert_equal ["s2"], r.smembers("{qux}baz") + end + + def test_sunion + r.sadd "{qux}foo", "s1" + r.sadd "{qux}foo", "s2" + r.sadd "{qux}bar", "s2" + r.sadd "{qux}bar", "s3" + + assert_equal ["s1", "s2", "s3"], r.sunion("{qux}foo", "{qux}bar").sort + end + + def test_sunionstore + r.sadd "{qux}foo", "s1" + r.sadd "{qux}foo", "s2" + r.sadd "{qux}bar", "s2" + r.sadd "{qux}bar", "s3" + + r.sunionstore("{qux}baz", "{qux}foo", "{qux}bar") + + assert_equal ["s1", "s2", "s3"], r.smembers("{qux}baz").sort + end + + def test_sdiff + r.sadd "{qux}foo", "s1" + r.sadd "{qux}foo", "s2" + r.sadd "{qux}bar", "s2" + r.sadd "{qux}bar", "s3" + + assert_equal ["s1"], r.sdiff("{qux}foo", "{qux}bar") + assert_equal ["s3"], r.sdiff("{qux}bar", "{qux}foo") + end + + def test_sdiffstore + r.sadd "{qux}foo", "s1" + r.sadd "{qux}foo", "s2" + r.sadd "{qux}bar", "s2" + r.sadd "{qux}bar", "s3" + + r.sdiffstore("{qux}baz", "{qux}foo", "{qux}bar") + + assert_equal ["s1"], r.smembers("{qux}baz") + end + + def test_sort + r.set("{qux}foo:1", "s1") + r.set("{qux}foo:2", "s2") + + r.rpush("{qux}bar", "1") + r.rpush("{qux}bar", "2") + + assert_equal ["s1"], r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1]) + assert_equal ["s2"], r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1], :order => "desc alpha") + end + + def test_sort_with_an_array_of_gets + r.set("{qux}foo:1:a", "s1a") + r.set("{qux}foo:1:b", "s1b") + + r.set("{qux}foo:2:a", "s2a") + r.set("{qux}foo:2:b", "s2b") + + r.rpush("{qux}bar", "1") + r.rpush("{qux}bar", "2") + + assert_equal [["s1a", "s1b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1]) + assert_equal [["s2a", "s2b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1], :order => "desc alpha") + assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"]) + end + + def test_sort_with_store + r.set("{qux}foo:1", "s1") + r.set("{qux}foo:2", "s2") + + r.rpush("{qux}bar", "1") + r.rpush("{qux}bar", "2") + + r.sort("{qux}bar", :get => "{qux}foo:*", :store => "{qux}baz") + assert_equal ["s1", "s2"], r.lrange("{qux}baz", 0, -1) + end + + def test_bitop + target_version "2.5.10" do + r.set("{qux}foo", "a") + r.set("{qux}bar", "b") + + r.bitop(:and, "{qux}foo&bar", "{qux}foo", "{qux}bar") + assert_equal "\x60", r.get("{qux}foo&bar") + r.bitop(:or, "{qux}foo|bar", "{qux}foo", "{qux}bar") + assert_equal "\x63", r.get("{qux}foo|bar") + r.bitop(:xor, "{qux}foo^bar", "{qux}foo", "{qux}bar") + assert_equal "\x03", r.get("{qux}foo^bar") + r.bitop(:not, "{qux}~foo", "{qux}foo") + assert_equal "\x9E", r.get("{qux}~foo") + end + end +end diff --git a/lib/vendor/redis/test/distributed_connection_handling_test.rb b/lib/vendor/redis/test/distributed_connection_handling_test.rb new file mode 100644 index 0000000..3308860 --- /dev/null +++ b/lib/vendor/redis/test/distributed_connection_handling_test.rb @@ -0,0 +1,23 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedConnectionHandling < Test::Unit::TestCase + + include Helper::Distributed + + def test_ping + assert_equal ["PONG"], r.ping + end + + def test_select + r.set "foo", "bar" + + r.select 14 + assert_equal nil, r.get("foo") + + r.select 15 + + assert_equal "bar", r.get("foo") + end +end diff --git a/lib/vendor/redis/test/distributed_internals_test.rb b/lib/vendor/redis/test/distributed_internals_test.rb new file mode 100644 index 0000000..887881f --- /dev/null +++ b/lib/vendor/redis/test/distributed_internals_test.rb @@ -0,0 +1,79 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedInternals < Test::Unit::TestCase + + include Helper::Distributed + + def test_provides_a_meaningful_inspect + nodes = ["redis://localhost:#{PORT}/15", *NODES] + redis = Redis::Distributed.new nodes + + assert_equal "#<Redis client v#{Redis::VERSION} for #{redis.nodes.map(&:id).join(', ')}>", redis.inspect + end + + def test_default_as_urls + nodes = ["redis://localhost:#{PORT}/15", *NODES] + redis = Redis::Distributed.new nodes + assert_equal ["redis://localhost:#{PORT}/15", *NODES], redis.nodes.map { |node| node.client.id} + end + + def test_default_as_config_hashes + nodes = [OPTIONS.merge(:host => '127.0.0.1'), OPTIONS.merge(:host => 'somehost', :port => PORT.next)] + redis = Redis::Distributed.new nodes + assert_equal ["redis://127.0.0.1:#{PORT}/15","redis://somehost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id } + end + + def test_as_mix_and_match + nodes = ["redis://127.0.0.1:7389/15", OPTIONS.merge(:host => 'somehost'), OPTIONS.merge(:host => 'somehost', :port => PORT.next)] + redis = Redis::Distributed.new nodes + assert_equal ["redis://127.0.0.1:7389/15", "redis://somehost:#{PORT}/15", "redis://somehost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id } + end + + def test_override_id + nodes = [OPTIONS.merge(:host => '127.0.0.1', :id => "test"), OPTIONS.merge( :host => 'somehost', :port => PORT.next, :id => "test1")] + redis = Redis::Distributed.new nodes + assert_equal redis.nodes.first.client.id, "test" + assert_equal redis.nodes.last.client.id, "test1" + assert_equal "#<Redis client v#{Redis::VERSION} for #{redis.nodes.map(&:id).join(', ')}>", redis.inspect + end + + def test_can_be_duped_to_create_a_new_connection + redis = Redis::Distributed.new(NODES) + + clients = redis.info[0]["connected_clients"].to_i + + r2 = redis.dup + r2.ping + + assert_equal clients + 1, redis.info[0]["connected_clients"].to_i + end + + def test_keeps_options_after_dup + r1 = Redis::Distributed.new(NODES, :tag => /^(\w+):/) + + assert_raise(Redis::Distributed::CannotDistribute) do + r1.sinter("foo", "bar") + end + + assert_equal [], r1.sinter("baz:foo", "baz:bar") + + r2 = r1.dup + + assert_raise(Redis::Distributed::CannotDistribute) do + r2.sinter("foo", "bar") + end + + assert_equal [], r2.sinter("baz:foo", "baz:bar") + end + + def test_colliding_node_ids + nodes = ["redis://localhost:#{PORT}/15", "redis://localhost:#{PORT}/15", *NODES] + + assert_raise(RuntimeError) do + Redis::Distributed.new nodes + end + end + +end diff --git a/lib/vendor/redis/test/distributed_key_tags_test.rb b/lib/vendor/redis/test/distributed_key_tags_test.rb new file mode 100644 index 0000000..12b6d68 --- /dev/null +++ b/lib/vendor/redis/test/distributed_key_tags_test.rb @@ -0,0 +1,52 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedKeyTags < Test::Unit::TestCase + + include Helper + include Helper::Distributed + + def test_hashes_consistently + r1 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES] + r2 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES] + r3 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES] + + assert_equal r1.node_for("foo").id, r2.node_for("foo").id + assert_equal r1.node_for("foo").id, r3.node_for("foo").id + end + + def test_allows_clustering_of_keys + r = Redis::Distributed.new(NODES) + r.add_node("redis://127.0.0.1:#{PORT}/14") + r.flushdb + + 100.times do |i| + r.set "{foo}users:#{i}", i + end + + assert_equal [0, 100], r.nodes.map { |node| node.keys.size } + end + + def test_distributes_keys_if_no_clustering_is_used + r.add_node("redis://127.0.0.1:#{PORT}/14") + r.flushdb + + r.set "users:1", 1 + r.set "users:4", 4 + + assert_equal [1, 1], r.nodes.map { |node| node.keys.size } + end + + def test_allows_passing_a_custom_tag_extractor + r = Redis::Distributed.new(NODES, :tag => /^(.+?):/) + r.add_node("redis://127.0.0.1:#{PORT}/14") + r.flushdb + + 100.times do |i| + r.set "foo:users:#{i}", i + end + + assert_equal [0, 100], r.nodes.map { |node| node.keys.size } + end +end diff --git a/lib/vendor/redis/test/distributed_persistence_control_commands_test.rb b/lib/vendor/redis/test/distributed_persistence_control_commands_test.rb new file mode 100644 index 0000000..c243601 --- /dev/null +++ b/lib/vendor/redis/test/distributed_persistence_control_commands_test.rb @@ -0,0 +1,26 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedPersistenceControlCommands < Test::Unit::TestCase + + include Helper::Distributed + + def test_save + redis_mock(:save => lambda { "+SAVE" }) do |redis| + assert_equal ["SAVE"], redis.save + end + end + + def test_bgsave + redis_mock(:bgsave => lambda { "+BGSAVE" }) do |redis| + assert_equal ["BGSAVE"], redis.bgsave + end + end + + def test_lastsave + redis_mock(:lastsave => lambda { "+LASTSAVE" }) do |redis| + assert_equal ["LASTSAVE"], redis.lastsave + end + end +end diff --git a/lib/vendor/redis/test/distributed_publish_subscribe_test.rb b/lib/vendor/redis/test/distributed_publish_subscribe_test.rb new file mode 100644 index 0000000..df36506 --- /dev/null +++ b/lib/vendor/redis/test/distributed_publish_subscribe_test.rb @@ -0,0 +1,92 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedPublishSubscribe < Test::Unit::TestCase + + include Helper::Distributed + + def test_subscribe_and_unsubscribe + assert_raise Redis::Distributed::CannotDistribute do + r.subscribe("foo", "bar") { } + end + + assert_raise Redis::Distributed::CannotDistribute do + r.subscribe("{qux}foo", "bar") { } + end + end + + def test_subscribe_and_unsubscribe_with_tags + @subscribed = false + @unsubscribed = false + + wire = Wire.new do + r.subscribe("foo") do |on| + on.subscribe do |channel, total| + @subscribed = true + @t1 = total + end + + on.message do |channel, message| + if message == "s1" + r.unsubscribe + @message = message + end + end + + on.unsubscribe do |channel, total| + @unsubscribed = true + @t2 = total + end + end + end + + # Wait until the subscription is active before publishing + Wire.pass while !@subscribed + + Redis::Distributed.new(NODES).publish("foo", "s1") + + wire.join + + assert @subscribed + assert_equal 1, @t1 + assert @unsubscribed + assert_equal 0, @t2 + assert_equal "s1", @message + end + + def test_subscribe_within_subscribe + @channels = [] + + wire = Wire.new do + r.subscribe("foo") do |on| + on.subscribe do |channel, total| + @channels << channel + + r.subscribe("bar") if channel == "foo" + r.unsubscribe if channel == "bar" + end + end + end + + wire.join + + assert_equal ["foo", "bar"], @channels + end + + def test_other_commands_within_a_subscribe + assert_raise Redis::CommandError do + r.subscribe("foo") do |on| + on.subscribe do |channel, total| + r.set("bar", "s2") + end + end + end + end + + def test_subscribe_without_a_block + assert_raise LocalJumpError do + r.subscribe("foo") + end + end +end diff --git a/lib/vendor/redis/test/distributed_remote_server_control_commands_test.rb b/lib/vendor/redis/test/distributed_remote_server_control_commands_test.rb new file mode 100644 index 0000000..7799d4f --- /dev/null +++ b/lib/vendor/redis/test/distributed_remote_server_control_commands_test.rb @@ -0,0 +1,66 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedRemoteServerControlCommands < Test::Unit::TestCase + + include Helper::Distributed + + def test_info + keys = [ + "redis_version", + "uptime_in_seconds", + "uptime_in_days", + "connected_clients", + "used_memory", + "total_connections_received", + "total_commands_processed", + ] + + infos = r.info + + infos.each do |info| + keys.each do |k| + msg = "expected #info to include #{k}" + assert info.keys.include?(k), msg + end + end + end + + def test_info_commandstats + target_version "2.5.7" do + r.nodes.each { |n| n.config(:resetstat) } + r.ping # Executed on every node + + r.info(:commandstats).each do |info| + assert_equal "1", info["ping"]["calls"] + end + end + end + + def test_monitor + begin + r.monitor + rescue Exception => ex + ensure + assert ex.kind_of?(NotImplementedError) + end + end + + def test_echo + assert_equal ["foo bar baz\n"], r.echo("foo bar baz\n") + end + + def test_time + target_version "2.5.4" do + # Test that the difference between the time that Ruby reports and the time + # that Redis reports is minimal (prevents the test from being racy). + r.time.each do |rv| + redis_usec = rv[0] * 1_000_000 + rv[1] + ruby_usec = Integer(Time.now.to_f * 1_000_000) + + assert 500_000 > (ruby_usec - redis_usec).abs + end + end + end +end diff --git a/lib/vendor/redis/test/distributed_scripting_test.rb b/lib/vendor/redis/test/distributed_scripting_test.rb new file mode 100644 index 0000000..00bdaa6 --- /dev/null +++ b/lib/vendor/redis/test/distributed_scripting_test.rb @@ -0,0 +1,102 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedScripting < Test::Unit::TestCase + + include Helper::Distributed + + def to_sha(script) + r.script(:load, script).first + end + + def test_script_exists + target_version "2.5.9" do # 2.6-rc1 + a = to_sha("return 1") + b = a.succ + + assert_equal [true], r.script(:exists, a) + assert_equal [false], r.script(:exists, b) + assert_equal [[true]], r.script(:exists, [a]) + assert_equal [[false]], r.script(:exists, [b]) + assert_equal [[true, false]], r.script(:exists, [a, b]) + end + end + + def test_script_flush + target_version "2.5.9" do # 2.6-rc1 + sha = to_sha("return 1") + assert r.script(:exists, sha).first + assert_equal ["OK"], r.script(:flush) + assert !r.script(:exists, sha).first + end + end + + def test_script_kill + target_version "2.5.9" do # 2.6-rc1 + redis_mock(:script => lambda { |arg| "+#{arg.upcase}" }) do |redis| + assert_equal ["KILL"], redis.script(:kill) + end + end + end + + def test_eval + target_version "2.5.9" do # 2.6-rc1 + assert_raises(Redis::Distributed::CannotDistribute) do + r.eval("return #KEYS") + end + + assert_raises(Redis::Distributed::CannotDistribute) do + r.eval("return KEYS", ["k1", "k2"]) + end + + assert_equal ["k1"], r.eval("return KEYS", ["k1"]) + assert_equal ["a1", "a2"], r.eval("return ARGV", ["k1"], ["a1", "a2"]) + end + end + + def test_eval_with_options_hash + target_version "2.5.9" do # 2.6-rc1 + assert_raises(Redis::Distributed::CannotDistribute) do + r.eval("return #KEYS", {}) + end + + assert_raises(Redis::Distributed::CannotDistribute) do + r.eval("return KEYS", { :keys => ["k1", "k2"] }) + end + + assert_equal ["k1"], r.eval("return KEYS", { :keys => ["k1"] }) + assert_equal ["a1", "a2"], r.eval("return ARGV", { :keys => ["k1"], :argv => ["a1", "a2"] }) + end + end + + def test_evalsha + target_version "2.5.9" do # 2.6-rc1 + assert_raises(Redis::Distributed::CannotDistribute) do + r.evalsha(to_sha("return #KEYS")) + end + + assert_raises(Redis::Distributed::CannotDistribute) do + r.evalsha(to_sha("return KEYS"), ["k1", "k2"]) + end + + assert_equal ["k1"], r.evalsha(to_sha("return KEYS"), ["k1"]) + assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), ["k1"], ["a1", "a2"]) + end + end + + def test_evalsha_with_options_hash + target_version "2.5.9" do # 2.6-rc1 + assert_raises(Redis::Distributed::CannotDistribute) do + r.evalsha(to_sha("return #KEYS"), {}) + end + + assert_raises(Redis::Distributed::CannotDistribute) do + r.evalsha(to_sha("return KEYS"), { :keys => ["k1", "k2"] }) + end + + assert_equal ["k1"], r.evalsha(to_sha("return KEYS"), { :keys => ["k1"] }) + assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), { :keys => ["k1"], :argv => ["a1", "a2"] }) + end + end +end diff --git a/lib/vendor/redis/test/distributed_sorting_test.rb b/lib/vendor/redis/test/distributed_sorting_test.rb new file mode 100644 index 0000000..4ae3cf5 --- /dev/null +++ b/lib/vendor/redis/test/distributed_sorting_test.rb @@ -0,0 +1,20 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedSorting < Test::Unit::TestCase + + include Helper::Distributed + + def test_sort + assert_raise(Redis::Distributed::CannotDistribute) do + r.set("foo:1", "s1") + r.set("foo:2", "s2") + + r.rpush("bar", "1") + r.rpush("bar", "2") + + r.sort("bar", :get => "foo:*", :limit => [0, 1]) + end + end +end diff --git a/lib/vendor/redis/test/distributed_test.rb b/lib/vendor/redis/test/distributed_test.rb new file mode 100644 index 0000000..b55287b --- /dev/null +++ b/lib/vendor/redis/test/distributed_test.rb @@ -0,0 +1,58 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributed < Test::Unit::TestCase + + include Helper::Distributed + + def test_handle_multiple_servers + @r = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES] + + 100.times do |idx| + @r.set(idx.to_s, "foo#{idx}") + end + + 100.times do |idx| + assert_equal "foo#{idx}", @r.get(idx.to_s) + end + + assert_equal "0", @r.keys("*").sort.first + assert_equal "string", @r.type("1") + end + + def test_add_nodes + logger = Logger.new("/dev/null") + + @r = Redis::Distributed.new NODES, :logger => logger, :timeout => 10 + + assert_equal "127.0.0.1", @r.nodes[0].client.host + assert_equal PORT, @r.nodes[0].client.port + assert_equal 15, @r.nodes[0].client.db + assert_equal 10, @r.nodes[0].client.timeout + assert_equal logger, @r.nodes[0].client.logger + + @r.add_node("redis://127.0.0.1:6380/14") + + assert_equal "127.0.0.1", @r.nodes[1].client.host + assert_equal 6380, @r.nodes[1].client.port + assert_equal 14, @r.nodes[1].client.db + assert_equal 10, @r.nodes[1].client.timeout + assert_equal logger, @r.nodes[1].client.logger + end + + def test_pipelining_commands_cannot_be_distributed + assert_raise Redis::Distributed::CannotDistribute do + r.pipelined do + r.lpush "foo", "s1" + r.lpush "foo", "s2" + end + end + end + + def test_unknown_commands_does_not_work_by_default + assert_raise NoMethodError do + r.not_yet_implemented_command + end + end +end diff --git a/lib/vendor/redis/test/distributed_transactions_test.rb b/lib/vendor/redis/test/distributed_transactions_test.rb new file mode 100644 index 0000000..abfb8aa --- /dev/null +++ b/lib/vendor/redis/test/distributed_transactions_test.rb @@ -0,0 +1,32 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestDistributedTransactions < Test::Unit::TestCase + + include Helper::Distributed + + def test_multi_discard + @foo = nil + + assert_raise Redis::Distributed::CannotDistribute do + r.multi { @foo = 1 } + end + + assert_equal nil, @foo + + assert_raise Redis::Distributed::CannotDistribute do + r.discard + end + end + + def test_watch_unwatch + assert_raise Redis::Distributed::CannotDistribute do + r.watch("foo") + end + + assert_raise Redis::Distributed::CannotDistribute do + r.unwatch + end + end +end diff --git a/lib/vendor/redis/test/encoding_test.rb b/lib/vendor/redis/test/encoding_test.rb new file mode 100644 index 0000000..cb54bcb --- /dev/null +++ b/lib/vendor/redis/test/encoding_test.rb @@ -0,0 +1,18 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestEncoding < Test::Unit::TestCase + + include Helper::Client + + def test_returns_properly_encoded_strings + if defined?(Encoding) + with_external_encoding("UTF-8") do + r.set "foo", "שלום" + + assert_equal "Shalom שלום", "Shalom " + r.get("foo") + end + end + end +end diff --git a/lib/vendor/redis/test/error_replies_test.rb b/lib/vendor/redis/test/error_replies_test.rb new file mode 100644 index 0000000..08ec81e --- /dev/null +++ b/lib/vendor/redis/test/error_replies_test.rb @@ -0,0 +1,59 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestErrorReplies < Test::Unit::TestCase + + include Helper::Client + + # Every test shouldn't disconnect from the server. Also, when error replies are + # in play, the protocol should never get into an invalid state where there are + # pending replies in the connection. Calling INFO after every test ensures that + # the protocol is still in a valid state. + def with_reconnection_check + before = r.info["total_connections_received"] + yield(r) + after = r.info["total_connections_received"] + ensure + assert_equal before, after + end + + def test_error_reply_for_single_command + with_reconnection_check do + begin + r.unknown_command + rescue => ex + ensure + assert ex.message =~ /unknown command/i + end + end + end + + def test_raise_first_error_reply_in_pipeline + with_reconnection_check do + begin + r.pipelined do + r.set("foo", "s1") + r.incr("foo") # not an integer + r.lpush("foo", "value") # wrong kind of value + end + rescue => ex + ensure + assert ex.message =~ /not an integer/i + end + end + end + + def test_recover_from_raise_in__call_loop + with_reconnection_check do + begin + r.client.call_loop([:invalid_monitor]) do + assert false # Should never be executed + end + rescue => ex + ensure + assert ex.message =~ /unknown command/i + end + end + end +end diff --git a/lib/vendor/redis/test/fork_safety_test.rb b/lib/vendor/redis/test/fork_safety_test.rb new file mode 100644 index 0000000..a49d5b4 --- /dev/null +++ b/lib/vendor/redis/test/fork_safety_test.rb @@ -0,0 +1,65 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestForkSafety < Test::Unit::TestCase + + include Helper::Client + include Helper::Skipable + + driver(:ruby, :hiredis) do + def test_fork_safety + redis = Redis.new(OPTIONS) + redis.set "foo", 1 + + child_pid = fork do + begin + # InheritedError triggers a reconnect, + # so we need to disable reconnects to force + # the exception bubble up + redis.without_reconnect do + redis.set "foo", 2 + end + rescue Redis::InheritedError + exit 127 + end + end + + _, status = Process.wait2(child_pid) + + assert_equal 127, status.exitstatus + assert_equal "1", redis.get("foo") + + rescue NotImplementedError => error + raise unless error.message =~ /fork is not available/ + return skip(error.message) + end + + def test_fork_safety_with_enabled_inherited_socket + redis = Redis.new(OPTIONS.merge(:inherit_socket => true)) + redis.set "foo", 1 + + child_pid = fork do + begin + # InheritedError triggers a reconnect, + # so we need to disable reconnects to force + # the exception bubble up + redis.without_reconnect do + redis.set "foo", 2 + end + rescue Redis::InheritedError + exit 127 + end + end + + _, status = Process.wait2(child_pid) + + assert_equal 0, status.exitstatus + assert_equal "2", redis.get("foo") + + rescue NotImplementedError => error + raise unless error.message =~ /fork is not available/ + return skip(error.message) + end + end +end diff --git a/lib/vendor/redis/test/helper.rb b/lib/vendor/redis/test/helper.rb new file mode 100644 index 0000000..1694407 --- /dev/null +++ b/lib/vendor/redis/test/helper.rb @@ -0,0 +1,232 @@ +$:.unshift File.expand_path("../lib", File.dirname(__FILE__)) +$:.unshift File.expand_path(File.dirname(__FILE__)) + +require "test/unit" +require "logger" +require "stringio" + +(class Random; def self.rand(*args) super end; end) unless defined?(Random) + +begin + require "ruby-debug" +rescue LoadError +end + +$VERBOSE = true + +ENV["conn"] ||= "ruby" + +require "redis" +require "redis/distributed" +require "redis/connection/#{ENV["conn"]}" + +require "support/redis_mock" +require "support/connection/#{ENV["conn"]}" + +PORT = 6381 +OPTIONS = {:port => PORT, :db => 15, :timeout => Float(ENV["TIMEOUT"] || 0.1)} +NODES = ["redis://127.0.0.1:#{PORT}/15"] + +def init(redis) + begin + redis.select 14 + redis.flushdb + redis.select 15 + redis.flushdb + redis + rescue Redis::CannotConnectError + puts <<-EOS + + Cannot connect to Redis. + + Make sure Redis is running on localhost, port #{PORT}. + This testing suite connects to the database 15. + + Try this once: + + $ rake clean + + Then run the build again: + + $ rake + + EOS + exit 1 + end +end + +def driver(*drivers, &blk) + if drivers.map(&:to_s).include?(ENV["conn"]) + class_eval(&blk) + end +end + +module Helper + + def run(runner) + if respond_to?(:around) + around { super(runner) } + else + super + end + end + + def silent + verbose, $VERBOSE = $VERBOSE, false + + begin + yield + ensure + $VERBOSE = verbose + end + end + + def with_external_encoding(encoding) + original_encoding = Encoding.default_external + + begin + silent { Encoding.default_external = Encoding.find(encoding) } + yield + ensure + silent { Encoding.default_external = original_encoding } + end + end + + def try_encoding(encoding, &block) + if defined?(Encoding) + with_external_encoding(encoding, &block) + else + yield + end + end + + class Version + + include Comparable + + attr :parts + + def initialize(v) + case v + when Version + @parts = v.parts + else + @parts = v.to_s.split(".") + end + end + + def <=>(other) + other = Version.new(other) + length = [self.parts.length, other.parts.length].max + length.times do |i| + a, b = self.parts[i], other.parts[i] + + return -1 if a.nil? + return +1 if b.nil? + return a.to_i <=> b.to_i if a != b + end + + 0 + end + end + + module Generic + + include Helper + + attr_reader :log + attr_reader :redis + + alias :r :redis + + def setup + @log = StringIO.new + @redis = init _new_client + + # Run GC to make sure orphaned connections are closed. + GC.start + end + + def teardown + @redis.quit if @redis + end + + def redis_mock(commands, options = {}, &blk) + RedisMock.start(commands, options) do |port| + yield _new_client(options.merge(:port => port)) + end + end + + def redis_mock_with_handler(handler, options = {}, &blk) + RedisMock.start_with_handler(handler, options) do |port| + yield _new_client(options.merge(:port => port)) + end + end + + def assert_in_range(range, value) + assert range.include?(value), "expected #{value} to be in #{range.inspect}" + end + + def target_version(target) + if version < target + skip("Requires Redis > #{target}") if respond_to?(:skip) + else + yield + end + end + end + + module Client + + include Generic + + def version + Version.new(redis.info["redis_version"]) + end + + private + + def _format_options(options) + OPTIONS.merge(:logger => ::Logger.new(@log)).merge(options) + end + + def _new_client(options = {}) + Redis.new(_format_options(options).merge(:driver => ENV["conn"])) + end + end + + module Distributed + + include Generic + + def version + Version.new(redis.info.first["redis_version"]) + end + + private + + def _format_options(options) + { + :timeout => OPTIONS[:timeout], + :logger => ::Logger.new(@log), + }.merge(options) + end + + def _new_client(options = {}) + Redis::Distributed.new(NODES, _format_options(options).merge(:driver => ENV["conn"])) + end + end + + # Basic support for `skip` in 1.8.x + # Note: YOU MUST use `return skip(message)` in order to appropriately bail + # from a running test. + module Skipable + Skipped = Class.new(RuntimeError) + + def skip(message = nil, bt = caller) + return super if defined?(super) + + $stderr.puts("SKIPPED: #{self} #{message || 'no reason given'}") + end + end +end diff --git a/lib/vendor/redis/test/helper_test.rb b/lib/vendor/redis/test/helper_test.rb new file mode 100644 index 0000000..23da68d --- /dev/null +++ b/lib/vendor/redis/test/helper_test.rb @@ -0,0 +1,24 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestHelper < Test::Unit::TestCase + + include Helper + + def test_version_comparison + v = Version.new("2.0.1") + + assert v > "1" + assert v > "2" + assert v < "3" + assert v < "10" + + assert v < "2.1" + assert v < "2.0.2" + assert v < "2.0.1.1" + assert v < "2.0.10" + + assert v == "2.0.1" + end +end diff --git a/lib/vendor/redis/test/internals_test.rb b/lib/vendor/redis/test/internals_test.rb new file mode 100644 index 0000000..865c600 --- /dev/null +++ b/lib/vendor/redis/test/internals_test.rb @@ -0,0 +1,437 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestInternals < Test::Unit::TestCase + + include Helper::Client + + def test_logger + r.ping + + assert log.string["[Redis] command=PING"] + assert log.string =~ /\[Redis\] call_time=\d+\.\d+ ms/ + end + + def test_logger_with_pipelining + r.pipelined do + r.set "foo", "bar" + r.get "foo" + end + + assert log.string[" command=SET args=\"foo\" \"bar\""] + assert log.string[" command=GET args=\"foo\""] + end + + def test_recovers_from_failed_commands + # See https://github.com/redis/redis-rb/issues#issue/28 + + assert_raise(Redis::CommandError) do + r.command_that_doesnt_exist + end + + assert_nothing_raised do + r.info + end + end + + def test_raises_on_protocol_errors + redis_mock(:ping => lambda { |*_| "foo" }) do |redis| + assert_raise(Redis::ProtocolError) do + redis.ping + end + end + end + + def test_provides_a_meaningful_inspect + assert_equal "#<Redis client v#{Redis::VERSION} for redis://127.0.0.1:#{PORT}/15>", r.inspect + end + + def test_redis_current + assert_equal "127.0.0.1", Redis.current.client.host + assert_equal 6379, Redis.current.client.port + assert_equal 0, Redis.current.client.db + + Redis.current = Redis.new(OPTIONS.merge(:port => 6380, :db => 1)) + + t = Thread.new do + assert_equal "127.0.0.1", Redis.current.client.host + assert_equal 6380, Redis.current.client.port + assert_equal 1, Redis.current.client.db + end + + t.join + + assert_equal "127.0.0.1", Redis.current.client.host + assert_equal 6380, Redis.current.client.port + assert_equal 1, Redis.current.client.db + end + + def test_redis_connected? + fresh_client = _new_client + assert !fresh_client.connected? + + fresh_client.ping + assert fresh_client.connected? + + fresh_client.quit + assert !fresh_client.connected? + end + + def test_default_id_with_host_and_port + redis = Redis.new(OPTIONS.merge(:host => "host", :port => "1234", :db => 0)) + assert_equal "redis://host:1234/0", redis.client.id + end + + def test_default_id_with_host_and_port_and_explicit_scheme + redis = Redis.new(OPTIONS.merge(:host => "host", :port => "1234", :db => 0, :scheme => "foo")) + assert_equal "redis://host:1234/0", redis.client.id + end + + def test_default_id_with_path + redis = Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock", :db => 0)) + assert_equal "redis:///tmp/redis.sock/0", redis.client.id + end + + def test_default_id_with_path_and_explicit_scheme + redis = Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock", :db => 0, :scheme => "foo")) + assert_equal "redis:///tmp/redis.sock/0", redis.client.id + end + + def test_override_id + redis = Redis.new(OPTIONS.merge(:id => "test")) + assert_equal redis.client.id, "test" + end + + def test_timeout + assert_nothing_raised do + Redis.new(OPTIONS.merge(:timeout => 0)) + end + end + + def test_id_inside_multi + redis = Redis.new(OPTIONS) + id = nil + + redis.multi do + id = redis.id + end + + assert_equal id, "redis://127.0.0.1:6381/15" + end + + driver(:ruby) do + def test_tcp_keepalive + keepalive = {:time => 20, :intvl => 10, :probes => 5} + + redis = Redis.new(OPTIONS.merge(:tcp_keepalive => keepalive)) + redis.ping + + connection = redis.client.connection + actual_keepalive = connection.get_tcp_keepalive + + [:time, :intvl, :probes].each do |key| + if actual_keepalive.has_key?(key) + assert_equal actual_keepalive[key], keepalive[key] + end + end + end + end + + def test_time + target_version "2.5.4" do + # Test that the difference between the time that Ruby reports and the time + # that Redis reports is minimal (prevents the test from being racy). + rv = r.time + + redis_usec = rv[0] * 1_000_000 + rv[1] + ruby_usec = Integer(Time.now.to_f * 1_000_000) + + assert 500_000 > (ruby_usec - redis_usec).abs + end + end + + def test_connection_timeout + opts = OPTIONS.merge(:host => "10.255.255.254", :connect_timeout => 0.1, :timeout => 5.0) + start_time = Time.now + assert_raise Redis::CannotConnectError do + Redis.new(opts).ping + end + assert (Time.now - start_time) <= opts[:timeout] + end + + def close_on_ping(seq, options = {}) + $request = 0 + + command = lambda do + idx = $request + $request += 1 + + rv = "+%d" % idx + rv = nil if seq.include?(idx) + rv + end + + redis_mock({:ping => command}, {:timeout => 0.1}.merge(options)) do |redis| + yield(redis) + end + end + + def test_retry_by_default + close_on_ping([0]) do |redis| + assert_equal "1", redis.ping + end + end + + def test_retry_when_wrapped_in_with_reconnect_true + close_on_ping([0]) do |redis| + redis.with_reconnect(true) do + assert_equal "1", redis.ping + end + end + end + + def test_dont_retry_when_wrapped_in_with_reconnect_false + close_on_ping([0]) do |redis| + assert_raise Redis::ConnectionError do + redis.with_reconnect(false) do + redis.ping + end + end + end + end + + def test_dont_retry_when_wrapped_in_without_reconnect + close_on_ping([0]) do |redis| + assert_raise Redis::ConnectionError do + redis.without_reconnect do + redis.ping + end + end + end + end + + def test_retry_only_once_when_read_raises_econnreset + close_on_ping([0, 1]) do |redis| + assert_raise Redis::ConnectionError do + redis.ping + end + + assert !redis.client.connected? + end + end + + def test_retry_with_custom_reconnect_attempts + close_on_ping([0, 1], :reconnect_attempts => 2) do |redis| + assert_equal "2", redis.ping + end + end + + def test_retry_with_custom_reconnect_attempts_can_still_fail + close_on_ping([0, 1, 2], :reconnect_attempts => 2) do |redis| + assert_raise Redis::ConnectionError do + redis.ping + end + + assert !redis.client.connected? + end + end + + def test_don_t_retry_when_second_read_in_pipeline_raises_econnreset + close_on_ping([1]) do |redis| + assert_raise Redis::ConnectionError do + redis.pipelined do + redis.ping + redis.ping # Second #read times out + end + end + + assert !redis.client.connected? + end + end + + def close_on_connection(seq) + $n = 0 + + read_command = lambda do |session| + Array.new(session.gets[1..-3].to_i) do + bytes = session.gets[1..-3].to_i + arg = session.read(bytes) + session.read(2) # Discard \r\n + arg + end + end + + handler = lambda do |session| + n = $n + $n += 1 + + select = read_command.call(session) + if select[0].downcase == "select" + session.write("+OK\r\n") + else + raise "Expected SELECT" + end + + if !seq.include?(n) + while read_command.call(session) + session.write("+#{n}\r\n") + end + end + end + + redis_mock_with_handler(handler) do |redis| + yield(redis) + end + end + + def test_retry_on_write_error_by_default + close_on_connection([0]) do |redis| + assert_equal "1", redis.client.call(["x" * 128 * 1024]) + end + end + + def test_retry_on_write_error_when_wrapped_in_with_reconnect_true + close_on_connection([0]) do |redis| + redis.with_reconnect(true) do + assert_equal "1", redis.client.call(["x" * 128 * 1024]) + end + end + end + + def test_dont_retry_on_write_error_when_wrapped_in_with_reconnect_false + close_on_connection([0]) do |redis| + assert_raise Redis::ConnectionError do + redis.with_reconnect(false) do + redis.client.call(["x" * 128 * 1024]) + end + end + end + end + + def test_dont_retry_on_write_error_when_wrapped_in_without_reconnect + close_on_connection([0]) do |redis| + assert_raise Redis::ConnectionError do + redis.without_reconnect do + redis.client.call(["x" * 128 * 1024]) + end + end + end + end + + def test_connecting_to_unix_domain_socket + assert_nothing_raised do + Redis.new(OPTIONS.merge(:path => "./test/db/redis.sock")).ping + end + end + + driver(:ruby, :hiredis) do + def test_bubble_timeout_without_retrying + serv = TCPServer.new(6380) + + redis = Redis.new(:port => 6380, :timeout => 0.1) + + assert_raise(Redis::TimeoutError) do + redis.ping + end + + ensure + serv.close if serv + end + end + + def test_client_options + redis = Redis.new(OPTIONS.merge(:host => "host", :port => 1234, :db => 1, :scheme => "foo")) + + assert_equal "host", redis.client.options[:host] + assert_equal 1234, redis.client.options[:port] + assert_equal 1, redis.client.options[:db] + assert_equal "foo", redis.client.options[:scheme] + end + + def test_does_not_change_self_client_options + redis = Redis.new(OPTIONS.merge(:host => "host", :port => 1234, :db => 1, :scheme => "foo")) + options = redis.client.options + + options[:host] << "new_host" + options[:scheme] << "bar" + options.merge!(:db => 0) + + assert_equal "host", redis.client.options[:host] + assert_equal 1, redis.client.options[:db] + assert_equal "foo", redis.client.options[:scheme] + end + + def test_resolves_localhost + assert_nothing_raised do + Redis.new(OPTIONS.merge(:host => 'localhost')).ping + end + end + + class << self + def af_family_supported(af) + hosts = { + Socket::AF_INET => "127.0.0.1", + Socket::AF_INET6 => "::1", + } + + begin + s = Socket.new(af, Socket::SOCK_STREAM, 0) + begin + tries = 5 + begin + sa = Socket.pack_sockaddr_in(1024 + Random.rand(63076), hosts[af]) + s.bind(sa) + rescue Errno::EADDRINUSE + tries -= 1 + retry if tries > 0 + + raise + end + yield + rescue Errno::EADDRNOTAVAIL + ensure + s.close + end + rescue Errno::ESOCKTNOSUPPORT + end + end + end + + def af_test(host) + commands = { + :ping => lambda { |*_| "+pong" }, + } + + redis_mock(commands, :host => host) do |redis| + assert_nothing_raised do + redis.ping + end + end + end + + driver(:ruby) do + af_family_supported(Socket::AF_INET) do + def test_connect_ipv4 + af_test("127.0.0.1") + end + end + end + + driver(:ruby) do + af_family_supported(Socket::AF_INET6) do + def test_connect_ipv6 + af_test("::1") + end + end + end + + def test_can_be_duped_to_create_a_new_connection + clients = r.info["connected_clients"].to_i + + r2 = r.dup + r2.ping + + assert_equal clients + 1, r.info["connected_clients"].to_i + end +end diff --git a/lib/vendor/redis/test/lint/blocking_commands.rb b/lib/vendor/redis/test/lint/blocking_commands.rb new file mode 100644 index 0000000..531e8d9 --- /dev/null +++ b/lib/vendor/redis/test/lint/blocking_commands.rb @@ -0,0 +1,150 @@ +module Lint + + module BlockingCommands + + def setup + super + + r.rpush("{zap}foo", "s1") + r.rpush("{zap}foo", "s2") + r.rpush("{zap}bar", "s1") + r.rpush("{zap}bar", "s2") + end + + def to_protocol(obj) + case obj + when String + "$#{obj.length}\r\n#{obj}\r\n" + when Array + "*#{obj.length}\r\n" + obj.map { |e| to_protocol(e) }.join + else + fail + end + end + + def mock(options = {}, &blk) + commands = { + :blpop => lambda do |*args| + sleep options[:delay] if options.has_key?(:delay) + to_protocol([args.first, args.last]) + end, + :brpop => lambda do |*args| + sleep options[:delay] if options.has_key?(:delay) + to_protocol([args.first, args.last]) + end, + :brpoplpush => lambda do |*args| + sleep options[:delay] if options.has_key?(:delay) + to_protocol(args.last) + end + } + + redis_mock(commands, &blk) + end + + def test_blpop + assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo") + assert_equal ["{zap}foo", "s2"], r.blpop(["{zap}foo"]) + assert_equal ["{zap}bar", "s1"], r.blpop(["{zap}bar", "{zap}foo"]) + assert_equal ["{zap}bar", "s2"], r.blpop(["{zap}foo", "{zap}bar"]) + end + + def test_blpop_timeout + mock do |r| + assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo") + assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", :timeout => 1) + end + end + + def test_blpop_with_old_prototype + assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo", 0) + assert_equal ["{zap}foo", "s2"], r.blpop("{zap}foo", 0) + assert_equal ["{zap}bar", "s1"], r.blpop("{zap}bar", "{zap}foo", 0) + assert_equal ["{zap}bar", "s2"], r.blpop("{zap}foo", "{zap}bar", 0) + end + + def test_blpop_timeout_with_old_prototype + mock do |r| + assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo", 0) + assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", 1) + end + end + + def test_brpop + assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo") + assert_equal ["{zap}foo", "s1"], r.brpop(["{zap}foo"]) + assert_equal ["{zap}bar", "s2"], r.brpop(["{zap}bar", "{zap}foo"]) + assert_equal ["{zap}bar", "s1"], r.brpop(["{zap}foo", "{zap}bar"]) + end + + def test_brpop_timeout + mock do |r| + assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo") + assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", :timeout => 1) + end + end + + def test_brpop_with_old_prototype + assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo", 0) + assert_equal ["{zap}foo", "s1"], r.brpop("{zap}foo", 0) + assert_equal ["{zap}bar", "s2"], r.brpop("{zap}bar", "{zap}foo", 0) + assert_equal ["{zap}bar", "s1"], r.brpop("{zap}foo", "{zap}bar", 0) + end + + def test_brpop_timeout_with_old_prototype + mock do |r| + assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo", 0) + assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", 1) + end + end + + def test_brpoplpush + assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux") + assert_equal ["s2"], r.lrange("{zap}qux", 0, -1) + end + + def test_brpoplpush_timeout + mock do |r| + assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar") + assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1) + end + end + + def test_brpoplpush_with_old_prototype + assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux", 0) + assert_equal ["s2"], r.lrange("{zap}qux", 0, -1) + end + + def test_brpoplpush_timeout_with_old_prototype + mock do |r| + assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar", 0) + assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", 1) + end + end + + driver(:ruby, :hiredis) do + def test_blpop_socket_timeout + mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r| + assert_raises(Redis::TimeoutError) do + r.blpop("{zap}foo", :timeout => 1) + end + end + end + + def test_brpop_socket_timeout + mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r| + assert_raises(Redis::TimeoutError) do + r.brpop("{zap}foo", :timeout => 1) + end + end + end + + def test_brpoplpush_socket_timeout + mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r| + assert_raises(Redis::TimeoutError) do + r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1) + end + end + end + end + end +end diff --git a/lib/vendor/redis/test/lint/hashes.rb b/lib/vendor/redis/test/lint/hashes.rb new file mode 100644 index 0000000..649e667 --- /dev/null +++ b/lib/vendor/redis/test/lint/hashes.rb @@ -0,0 +1,162 @@ +module Lint + + module Hashes + + def test_hset_and_hget + r.hset("foo", "f1", "s1") + + assert_equal "s1", r.hget("foo", "f1") + end + + def test_hsetnx + r.hset("foo", "f1", "s1") + r.hsetnx("foo", "f1", "s2") + + assert_equal "s1", r.hget("foo", "f1") + + r.del("foo") + r.hsetnx("foo", "f1", "s2") + + assert_equal "s2", r.hget("foo", "f1") + end + + def test_hdel + r.hset("foo", "f1", "s1") + + assert_equal "s1", r.hget("foo", "f1") + + assert_equal 1, r.hdel("foo", "f1") + + assert_equal nil, r.hget("foo", "f1") + end + + def test_variadic_hdel + target_version "2.3.9" do + r.hset("foo", "f1", "s1") + r.hset("foo", "f2", "s2") + + assert_equal "s1", r.hget("foo", "f1") + assert_equal "s2", r.hget("foo", "f2") + + assert_equal 2, r.hdel("foo", ["f1", "f2"]) + + assert_equal nil, r.hget("foo", "f1") + assert_equal nil, r.hget("foo", "f2") + end + end + + def test_hexists + assert_equal false, r.hexists("foo", "f1") + + r.hset("foo", "f1", "s1") + + assert r.hexists("foo", "f1") + end + + def test_hlen + assert_equal 0, r.hlen("foo") + + r.hset("foo", "f1", "s1") + + assert_equal 1, r.hlen("foo") + + r.hset("foo", "f2", "s2") + + assert_equal 2, r.hlen("foo") + end + + def test_hkeys + assert_equal [], r.hkeys("foo") + + r.hset("foo", "f1", "s1") + r.hset("foo", "f2", "s2") + + assert_equal ["f1", "f2"], r.hkeys("foo") + end + + def test_hvals + assert_equal [], r.hvals("foo") + + r.hset("foo", "f1", "s1") + r.hset("foo", "f2", "s2") + + assert_equal ["s1", "s2"], r.hvals("foo") + end + + def test_hgetall + assert({} == r.hgetall("foo")) + + r.hset("foo", "f1", "s1") + r.hset("foo", "f2", "s2") + + assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo")) + end + + def test_hmset + r.hmset("hash", "foo1", "bar1", "foo2", "bar2") + + assert_equal "bar1", r.hget("hash", "foo1") + assert_equal "bar2", r.hget("hash", "foo2") + end + + def test_hmset_with_invalid_arguments + assert_raise(Redis::CommandError) do + r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3") + end + end + + def test_mapped_hmset + r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2") + + assert_equal "s1", r.hget("foo", "f1") + assert_equal "s2", r.hget("foo", "f2") + end + + def test_hmget + r.hset("foo", "f1", "s1") + r.hset("foo", "f2", "s2") + r.hset("foo", "f3", "s3") + + assert_equal ["s2", "s3"], r.hmget("foo", "f2", "f3") + end + + def test_hmget_mapped + r.hset("foo", "f1", "s1") + r.hset("foo", "f2", "s2") + r.hset("foo", "f3", "s3") + + assert({"f1" => "s1"} == r.mapped_hmget("foo", "f1")) + assert({"f1" => "s1", "f2" => "s2"} == r.mapped_hmget("foo", "f1", "f2")) + end + + def test_hincrby + r.hincrby("foo", "f1", 1) + + assert_equal "1", r.hget("foo", "f1") + + r.hincrby("foo", "f1", 2) + + assert_equal "3", r.hget("foo", "f1") + + r.hincrby("foo", "f1", -1) + + assert_equal "2", r.hget("foo", "f1") + end + + def test_hincrbyfloat + target_version "2.5.4" do + r.hincrbyfloat("foo", "f1", 1.23) + + assert_equal "1.23", r.hget("foo", "f1") + + r.hincrbyfloat("foo", "f1", 0.77) + + assert_equal "2", r.hget("foo", "f1") + + r.hincrbyfloat("foo", "f1", -0.1) + + assert_equal "1.9", r.hget("foo", "f1") + end + end + end +end diff --git a/lib/vendor/redis/test/lint/hyper_log_log.rb b/lib/vendor/redis/test/lint/hyper_log_log.rb new file mode 100644 index 0000000..5472e22 --- /dev/null +++ b/lib/vendor/redis/test/lint/hyper_log_log.rb @@ -0,0 +1,60 @@ +module Lint + + module HyperLogLog + + def test_pfadd + target_version "2.8.9" do + assert_equal true, r.pfadd("foo", "s1") + assert_equal true, r.pfadd("foo", "s2") + assert_equal false, r.pfadd("foo", "s1") + + assert_equal 2, r.pfcount("foo") + end + end + + def test_variadic_pfadd + target_version "2.8.9" do + assert_equal true, r.pfadd("foo", ["s1", "s2"]) + assert_equal true, r.pfadd("foo", ["s1", "s2", "s3"]) + + assert_equal 3, r.pfcount("foo") + end + end + + def test_pfcount + target_version "2.8.9" do + assert_equal 0, r.pfcount("foo") + + assert_equal true, r.pfadd("foo", "s1") + + assert_equal 1, r.pfcount("foo") + end + end + + def test_variadic_pfcount + target_version "2.8.9" do + assert_equal 0, r.pfcount(["{1}foo", "{1}bar"]) + + assert_equal true, r.pfadd("{1}foo", "s1") + assert_equal true, r.pfadd("{1}bar", "s1") + assert_equal true, r.pfadd("{1}bar", "s2") + + assert_equal 2, r.pfcount("{1}foo", "{1}bar") + end + end + + def test_variadic_pfcount_expanded + target_version "2.8.9" do + assert_equal 0, r.pfcount("{1}foo", "{1}bar") + + assert_equal true, r.pfadd("{1}foo", "s1") + assert_equal true, r.pfadd("{1}bar", "s1") + assert_equal true, r.pfadd("{1}bar", "s2") + + assert_equal 2, r.pfcount("{1}foo", "{1}bar") + end + end + + end + +end diff --git a/lib/vendor/redis/test/lint/lists.rb b/lib/vendor/redis/test/lint/lists.rb new file mode 100644 index 0000000..3a230f6 --- /dev/null +++ b/lib/vendor/redis/test/lint/lists.rb @@ -0,0 +1,143 @@ +module Lint + + module Lists + + def test_lpush + r.lpush "foo", "s1" + r.lpush "foo", "s2" + + assert_equal 2, r.llen("foo") + assert_equal "s2", r.lpop("foo") + end + + def test_variadic_lpush + target_version "2.3.9" do # 2.4-rc6 + assert_equal 3, r.lpush("foo", ["s1", "s2", "s3"]) + assert_equal 3, r.llen("foo") + assert_equal "s3", r.lpop("foo") + end + end + + def test_lpushx + r.lpushx "foo", "s1" + r.lpush "foo", "s2" + r.lpushx "foo", "s3" + + assert_equal 2, r.llen("foo") + assert_equal ["s3", "s2"], r.lrange("foo", 0, -1) + end + + def test_rpush + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal 2, r.llen("foo") + assert_equal "s2", r.rpop("foo") + end + + def test_variadic_rpush + target_version "2.3.9" do # 2.4-rc6 + assert_equal 3, r.rpush("foo", ["s1", "s2", "s3"]) + assert_equal 3, r.llen("foo") + assert_equal "s3", r.rpop("foo") + end + end + + def test_rpushx + r.rpushx "foo", "s1" + r.rpush "foo", "s2" + r.rpushx "foo", "s3" + + assert_equal 2, r.llen("foo") + assert_equal ["s2", "s3"], r.lrange("foo", 0, -1) + end + + def test_llen + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal 2, r.llen("foo") + end + + def test_lrange + r.rpush "foo", "s1" + r.rpush "foo", "s2" + r.rpush "foo", "s3" + + assert_equal ["s2", "s3"], r.lrange("foo", 1, -1) + assert_equal ["s1", "s2"], r.lrange("foo", 0, 1) + + assert_equal [], r.lrange("bar", 0, -1) + end + + def test_ltrim + r.rpush "foo", "s1" + r.rpush "foo", "s2" + r.rpush "foo", "s3" + + r.ltrim "foo", 0, 1 + + assert_equal 2, r.llen("foo") + assert_equal ["s1", "s2"], r.lrange("foo", 0, -1) + end + + def test_lindex + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal "s1", r.lindex("foo", 0) + assert_equal "s2", r.lindex("foo", 1) + end + + def test_lset + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal "s2", r.lindex("foo", 1) + assert r.lset("foo", 1, "s3") + assert_equal "s3", r.lindex("foo", 1) + + assert_raise Redis::CommandError do + r.lset("foo", 4, "s3") + end + end + + def test_lrem + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal 1, r.lrem("foo", 1, "s1") + assert_equal ["s2"], r.lrange("foo", 0, -1) + end + + def test_lpop + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal 2, r.llen("foo") + assert_equal "s1", r.lpop("foo") + assert_equal 1, r.llen("foo") + end + + def test_rpop + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal 2, r.llen("foo") + assert_equal "s2", r.rpop("foo") + assert_equal 1, r.llen("foo") + end + + def test_linsert + r.rpush "foo", "s1" + r.rpush "foo", "s3" + r.linsert "foo", :before, "s3", "s2" + + assert_equal ["s1", "s2", "s3"], r.lrange("foo", 0, -1) + + assert_raise(Redis::CommandError) do + r.linsert "foo", :anywhere, "s3", "s2" + end + end + end +end diff --git a/lib/vendor/redis/test/lint/sets.rb b/lib/vendor/redis/test/lint/sets.rb new file mode 100644 index 0000000..7342f13 --- /dev/null +++ b/lib/vendor/redis/test/lint/sets.rb @@ -0,0 +1,125 @@ +module Lint + + module Sets + + def test_sadd + assert_equal true, r.sadd("foo", "s1") + assert_equal true, r.sadd("foo", "s2") + assert_equal false, r.sadd("foo", "s1") + + assert_equal ["s1", "s2"], r.smembers("foo").sort + end + + def test_variadic_sadd + target_version "2.3.9" do # 2.4-rc6 + assert_equal 2, r.sadd("foo", ["s1", "s2"]) + assert_equal 1, r.sadd("foo", ["s1", "s2", "s3"]) + + assert_equal ["s1", "s2", "s3"], r.smembers("foo").sort + end + end + + def test_srem + r.sadd("foo", "s1") + r.sadd("foo", "s2") + + assert_equal true, r.srem("foo", "s1") + assert_equal false, r.srem("foo", "s3") + + assert_equal ["s2"], r.smembers("foo") + end + + def test_variadic_srem + target_version "2.3.9" do # 2.4-rc6 + r.sadd("foo", "s1") + r.sadd("foo", "s2") + r.sadd("foo", "s3") + + assert_equal 1, r.srem("foo", ["s1", "aaa"]) + assert_equal 0, r.srem("foo", ["bbb", "ccc" "ddd"]) + assert_equal 1, r.srem("foo", ["eee", "s3"]) + + assert_equal ["s2"], r.smembers("foo") + end + end + + def test_spop + r.sadd "foo", "s1" + r.sadd "foo", "s2" + + assert ["s1", "s2"].include?(r.spop("foo")) + assert ["s1", "s2"].include?(r.spop("foo")) + assert_equal nil, r.spop("foo") + end + + def test_scard + assert_equal 0, r.scard("foo") + + r.sadd "foo", "s1" + + assert_equal 1, r.scard("foo") + + r.sadd "foo", "s2" + + assert_equal 2, r.scard("foo") + end + + def test_sismember + assert_equal false, r.sismember("foo", "s1") + + r.sadd "foo", "s1" + + assert_equal true, r.sismember("foo", "s1") + assert_equal false, r.sismember("foo", "s2") + end + + def test_smembers + assert_equal [], r.smembers("foo") + + r.sadd "foo", "s1" + r.sadd "foo", "s2" + + assert_equal ["s1", "s2"], r.smembers("foo").sort + end + + def test_srandmember + r.sadd "foo", "s1" + r.sadd "foo", "s2" + + 4.times do + assert ["s1", "s2"].include?(r.srandmember("foo")) + end + + assert_equal 2, r.scard("foo") + end + + def test_srandmember_with_positive_count + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "foo", "s3" + r.sadd "foo", "s4" + + 4.times do + assert !(["s1", "s2", "s3", "s4"] & r.srandmember("foo", 3)).empty? + + assert_equal 3, r.srandmember("foo", 3).size + end + + assert_equal 4, r.scard("foo") + end + + def test_srandmember_with_negative_count + r.sadd "foo", "s1" + r.sadd "foo", "s2" + r.sadd "foo", "s3" + r.sadd "foo", "s4" + + 4.times do + assert !(["s1", "s2", "s3", "s4"] & r.srandmember("foo", -6)).empty? + assert_equal 6, r.srandmember("foo", -6).size + end + + assert_equal 4, r.scard("foo") + end + end +end diff --git a/lib/vendor/redis/test/lint/sorted_sets.rb b/lib/vendor/redis/test/lint/sorted_sets.rb new file mode 100644 index 0000000..9dc11e2 --- /dev/null +++ b/lib/vendor/redis/test/lint/sorted_sets.rb @@ -0,0 +1,316 @@ +module Lint + + module SortedSets + + Infinity = 1.0/0.0 + + def test_zadd + assert_equal 0, r.zcard("foo") + assert_equal true, r.zadd("foo", 1, "s1") + assert_equal false, r.zadd("foo", 1, "s1") + assert_equal 1, r.zcard("foo") + r.del "foo" + + target_version "3.0.2" do + # XX option + assert_equal 0, r.zcard("foo") + assert_equal false, r.zadd("foo", 1, "s1", :xx => true) + r.zadd("foo", 1, "s1") + assert_equal false, r.zadd("foo", 2, "s1", :xx => true) + assert_equal 2, r.zscore("foo", "s1") + r.del "foo" + + # NX option + assert_equal 0, r.zcard("foo") + assert_equal true, r.zadd("foo", 1, "s1", :nx => true) + assert_equal false, r.zadd("foo", 2, "s1", :nx => true) + assert_equal 1, r.zscore("foo", "s1") + assert_equal 1, r.zcard("foo") + r.del "foo" + + # CH option + assert_equal 0, r.zcard("foo") + assert_equal true, r.zadd("foo", 1, "s1", :ch => true) + assert_equal false, r.zadd("foo", 1, "s1", :ch => true) + assert_equal true, r.zadd("foo", 2, "s1", :ch => true) + assert_equal 1, r.zcard("foo") + r.del "foo" + + # INCR option + assert_equal 1.0, r.zadd("foo", 1, "s1", :incr => true) + assert_equal 11.0, r.zadd("foo", 10, "s1", :incr => true) + assert_equal(-Infinity, r.zadd("bar", "-inf", "s1", :incr => true)) + assert_equal(+Infinity, r.zadd("bar", "+inf", "s2", :incr => true)) + r.del "foo", "bar" + + # Incompatible options combination + assert_raise(Redis::CommandError) { r.zadd("foo", 1, "s1", :xx => true, :nx => true) } + end + end + + def test_variadic_zadd + target_version "2.3.9" do # 2.4-rc6 + # Non-nested array with pairs + assert_equal 0, r.zcard("foo") + assert_equal 2, r.zadd("foo", [1, "s1", 2, "s2"]) + assert_equal 1, r.zadd("foo", [4, "s1", 5, "s2", 6, "s3"]) + assert_equal 3, r.zcard("foo") + r.del "foo" + + # Nested array with pairs + assert_equal 0, r.zcard("foo") + assert_equal 2, r.zadd("foo", [[1, "s1"], [2, "s2"]]) + assert_equal 1, r.zadd("foo", [[4, "s1"], [5, "s2"], [6, "s3"]]) + assert_equal 3, r.zcard("foo") + r.del "foo" + + # Wrong number of arguments + assert_raise(Redis::CommandError) { r.zadd("foo", ["bar"]) } + assert_raise(Redis::CommandError) { r.zadd("foo", ["bar", "qux", "zap"]) } + end + + target_version "3.0.2" do + # XX option + assert_equal 0, r.zcard("foo") + assert_equal 0, r.zadd("foo", [1, "s1", 2, "s2"], :xx => true) + r.zadd("foo", [1, "s1", 2, "s2"]) + assert_equal 0, r.zadd("foo", [2, "s1", 3, "s2", 4, "s3"], :xx => true) + assert_equal 2, r.zscore("foo", "s1") + assert_equal 3, r.zscore("foo", "s2") + assert_equal nil, r.zscore("foo", "s3") + assert_equal 2, r.zcard("foo") + r.del "foo" + + # NX option + assert_equal 0, r.zcard("foo") + assert_equal 2, r.zadd("foo", [1, "s1", 2, "s2"], :nx => true) + assert_equal 1, r.zadd("foo", [2, "s1", 3, "s2", 4, "s3"], :nx => true) + assert_equal 1, r.zscore("foo", "s1") + assert_equal 2, r.zscore("foo", "s2") + assert_equal 4, r.zscore("foo", "s3") + assert_equal 3, r.zcard("foo") + r.del "foo" + + # CH option + assert_equal 0, r.zcard("foo") + assert_equal 2, r.zadd("foo", [1, "s1", 2, "s2"], :ch => true) + assert_equal 2, r.zadd("foo", [1, "s1", 3, "s2", 4, "s3"], :ch => true) + assert_equal 3, r.zcard("foo") + r.del "foo" + + # INCR option + assert_equal 1.0, r.zadd("foo", [1, "s1"], :incr => true) + assert_equal 11.0, r.zadd("foo", [10, "s1"], :incr => true) + assert_equal(-Infinity, r.zadd("bar", ["-inf", "s1"], :incr => true)) + assert_equal(+Infinity, r.zadd("bar", ["+inf", "s2"], :incr => true)) + assert_raise(Redis::CommandError) { r.zadd("foo", [1, "s1", 2, "s2"], :incr => true) } + r.del "foo", "bar" + + # Incompatible options combination + assert_raise(Redis::CommandError) { r.zadd("foo", [1, "s1"], :xx => true, :nx => true) } + end + end + + def test_zrem + r.zadd("foo", 1, "s1") + r.zadd("foo", 2, "s2") + + assert_equal 2, r.zcard("foo") + assert_equal true, r.zrem("foo", "s1") + assert_equal false, r.zrem("foo", "s1") + assert_equal 1, r.zcard("foo") + end + + def test_variadic_zrem + target_version "2.3.9" do # 2.4-rc6 + r.zadd("foo", 1, "s1") + r.zadd("foo", 2, "s2") + r.zadd("foo", 3, "s3") + + assert_equal 3, r.zcard("foo") + assert_equal 1, r.zrem("foo", ["s1", "aaa"]) + assert_equal 0, r.zrem("foo", ["bbb", "ccc" "ddd"]) + assert_equal 1, r.zrem("foo", ["eee", "s3"]) + assert_equal 1, r.zcard("foo") + end + end + + def test_zincrby + rv = r.zincrby "foo", 1, "s1" + assert_equal 1.0, rv + + rv = r.zincrby "foo", 10, "s1" + assert_equal 11.0, rv + + rv = r.zincrby "bar", "-inf", "s1" + assert_equal(-Infinity, rv) + + rv = r.zincrby "bar", "+inf", "s2" + assert_equal(+Infinity, rv) + end + + def test_zrank + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + + assert_equal 2, r.zrank("foo", "s3") + end + + def test_zrevrank + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + + assert_equal 0, r.zrevrank("foo", "s3") + end + + def test_zrange + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + + assert_equal ["s1", "s2"], r.zrange("foo", 0, 1) + assert_equal [["s1", 1.0], ["s2", 2.0]], r.zrange("foo", 0, 1, :with_scores => true) + assert_equal [["s1", 1.0], ["s2", 2.0]], r.zrange("foo", 0, 1, :withscores => true) + + r.zadd "bar", "-inf", "s1" + r.zadd "bar", "+inf", "s2" + assert_equal [["s1", -Infinity], ["s2", +Infinity]], r.zrange("bar", 0, 1, :with_scores => true) + assert_equal [["s1", -Infinity], ["s2", +Infinity]], r.zrange("bar", 0, 1, :withscores => true) + end + + def test_zrevrange + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + + assert_equal ["s3", "s2"], r.zrevrange("foo", 0, 1) + assert_equal [["s3", 3.0], ["s2", 2.0]], r.zrevrange("foo", 0, 1, :with_scores => true) + assert_equal [["s3", 3.0], ["s2", 2.0]], r.zrevrange("foo", 0, 1, :withscores => true) + + r.zadd "bar", "-inf", "s1" + r.zadd "bar", "+inf", "s2" + assert_equal [["s2", +Infinity], ["s1", -Infinity]], r.zrevrange("bar", 0, 1, :with_scores => true) + assert_equal [["s2", +Infinity], ["s1", -Infinity]], r.zrevrange("bar", 0, 1, :withscores => true) + end + + def test_zrangebyscore + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + + assert_equal ["s2", "s3"], r.zrangebyscore("foo", 2, 3) + end + + def test_zrevrangebyscore + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + + assert_equal ["s3", "s2"], r.zrevrangebyscore("foo", 3, 2) + end + + def test_zrangebyscore_with_limit + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + r.zadd "foo", 4, "s4" + + assert_equal ["s2"], r.zrangebyscore("foo", 2, 4, :limit => [0, 1]) + assert_equal ["s3"], r.zrangebyscore("foo", 2, 4, :limit => [1, 1]) + assert_equal ["s3", "s4"], r.zrangebyscore("foo", 2, 4, :limit => [1, 2]) + end + + def test_zrevrangebyscore_with_limit + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + r.zadd "foo", 4, "s4" + + assert_equal ["s4"], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1]) + assert_equal ["s3"], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1]) + assert_equal ["s3", "s2"], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 2]) + end + + def test_zrangebyscore_with_withscores + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + r.zadd "foo", 4, "s4" + + assert_equal [["s2", 2.0]], r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :with_scores => true) + assert_equal [["s3", 3.0]], r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :with_scores => true) + assert_equal [["s2", 2.0]], r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :withscores => true) + assert_equal [["s3", 3.0]], r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :withscores => true) + + r.zadd "bar", "-inf", "s1" + r.zadd "bar", "+inf", "s2" + assert_equal [["s1", -Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [0, 1], :with_scores => true) + assert_equal [["s2", +Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [1, 1], :with_scores => true) + assert_equal [["s1", -Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [0, 1], :withscores => true) + assert_equal [["s2", +Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [1, 1], :withscores => true) + end + + def test_zrevrangebyscore_with_withscores + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + r.zadd "foo", 4, "s4" + + assert_equal [["s4", 4.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :with_scores => true) + assert_equal [["s3", 3.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :with_scores => true) + assert_equal [["s4", 4.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :withscores => true) + assert_equal [["s3", 3.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :withscores => true) + + r.zadd "bar", "-inf", "s1" + r.zadd "bar", "+inf", "s2" + assert_equal [["s2", +Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [0, 1], :with_scores => true) + assert_equal [["s1", -Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [1, 1], :with_scores => true) + assert_equal [["s2", +Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [0, 1], :withscores => true) + assert_equal [["s1", -Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [1, 1], :withscores => true) + end + + def test_zcard + assert_equal 0, r.zcard("foo") + + r.zadd "foo", 1, "s1" + + assert_equal 1, r.zcard("foo") + end + + def test_zscore + r.zadd "foo", 1, "s1" + + assert_equal 1.0, r.zscore("foo", "s1") + + assert_equal nil, r.zscore("foo", "s2") + assert_equal nil, r.zscore("bar", "s1") + + r.zadd "bar", "-inf", "s1" + r.zadd "bar", "+inf", "s2" + assert_equal(-Infinity, r.zscore("bar", "s1")) + assert_equal(+Infinity, r.zscore("bar", "s2")) + end + + def test_zremrangebyrank + r.zadd "foo", 10, "s1" + r.zadd "foo", 20, "s2" + r.zadd "foo", 30, "s3" + r.zadd "foo", 40, "s4" + + assert_equal 3, r.zremrangebyrank("foo", 1, 3) + assert_equal ["s1"], r.zrange("foo", 0, -1) + end + + def test_zremrangebyscore + r.zadd "foo", 1, "s1" + r.zadd "foo", 2, "s2" + r.zadd "foo", 3, "s3" + r.zadd "foo", 4, "s4" + + assert_equal 3, r.zremrangebyscore("foo", 2, 4) + assert_equal ["s1"], r.zrange("foo", 0, -1) + end + end +end diff --git a/lib/vendor/redis/test/lint/strings.rb b/lib/vendor/redis/test/lint/strings.rb new file mode 100644 index 0000000..381df3c --- /dev/null +++ b/lib/vendor/redis/test/lint/strings.rb @@ -0,0 +1,260 @@ +module Lint + + module Strings + + def test_set_and_get + r.set("foo", "s1") + + assert_equal "s1", r.get("foo") + end + + def test_set_and_get_with_brackets + r["foo"] = "s1" + + assert_equal "s1", r["foo"] + end + + def test_set_and_get_with_brackets_and_symbol + r[:foo] = "s1" + + assert_equal "s1", r[:foo] + end + + def test_set_and_get_with_newline_characters + r.set("foo", "1\n") + + assert_equal "1\n", r.get("foo") + end + + def test_set_and_get_with_non_string_value + value = ["a", "b"] + + r.set("foo", value) + + assert_equal value.to_s, r.get("foo") + end + + def test_set_and_get_with_ascii_characters + if defined?(Encoding) + with_external_encoding("ASCII-8BIT") do + (0..255).each do |i| + str = "#{i.chr}---#{i.chr}" + r.set("foo", str) + + assert_equal str, r.get("foo") + end + end + end + end + + def test_set_with_ex + target_version "2.6.12" do + r.set("foo", "bar", :ex => 2) + assert_in_range 0..2, r.ttl("foo") + end + end + + def test_set_with_px + target_version "2.6.12" do + r.set("foo", "bar", :px => 2000) + assert_in_range 0..2, r.ttl("foo") + end + end + + def test_set_with_nx + target_version "2.6.12" do + r.set("foo", "qux", :nx => true) + assert !r.set("foo", "bar", :nx => true) + assert_equal "qux", r.get("foo") + + r.del("foo") + assert r.set("foo", "bar", :nx => true) + assert_equal "bar", r.get("foo") + end + end + + def test_set_with_xx + target_version "2.6.12" do + r.set("foo", "qux") + assert r.set("foo", "bar", :xx => true) + assert_equal "bar", r.get("foo") + + r.del("foo") + assert !r.set("foo", "bar", :xx => true) + end + end + + def test_setex + assert r.setex("foo", 1, "bar") + assert_equal "bar", r.get("foo") + assert [0, 1].include? r.ttl("foo") + end + + def test_setex_with_non_string_value + value = ["b", "a", "r"] + + assert r.setex("foo", 1, value) + assert_equal value.to_s, r.get("foo") + assert [0, 1].include? r.ttl("foo") + end + + def test_psetex + target_version "2.5.4" do + assert r.psetex("foo", 1000, "bar") + assert_equal "bar", r.get("foo") + assert [0, 1].include? r.ttl("foo") + end + end + + def test_psetex_with_non_string_value + target_version "2.5.4" do + value = ["b", "a", "r"] + + assert r.psetex("foo", 1000, value) + assert_equal value.to_s, r.get("foo") + assert [0, 1].include? r.ttl("foo") + end + end + + def test_getset + r.set("foo", "bar") + + assert_equal "bar", r.getset("foo", "baz") + assert_equal "baz", r.get("foo") + end + + def test_getset_with_non_string_value + r.set("foo", "zap") + + value = ["b", "a", "r"] + + assert_equal "zap", r.getset("foo", value) + assert_equal value.to_s, r.get("foo") + end + + def test_setnx + r.set("foo", "qux") + assert !r.setnx("foo", "bar") + assert_equal "qux", r.get("foo") + + r.del("foo") + assert r.setnx("foo", "bar") + assert_equal "bar", r.get("foo") + end + + def test_setnx_with_non_string_value + value = ["b", "a", "r"] + + r.set("foo", "qux") + assert !r.setnx("foo", value) + assert_equal "qux", r.get("foo") + + r.del("foo") + assert r.setnx("foo", value) + assert_equal value.to_s, r.get("foo") + end + + def test_incr + assert_equal 1, r.incr("foo") + assert_equal 2, r.incr("foo") + assert_equal 3, r.incr("foo") + end + + def test_incrby + assert_equal 1, r.incrby("foo", 1) + assert_equal 3, r.incrby("foo", 2) + assert_equal 6, r.incrby("foo", 3) + end + + def test_incrbyfloat + target_version "2.5.4" do + assert_equal 1.23, r.incrbyfloat("foo", 1.23) + assert_equal 2 , r.incrbyfloat("foo", 0.77) + assert_equal 1.9 , r.incrbyfloat("foo", -0.1) + end + end + + def test_decr + r.set("foo", 3) + + assert_equal 2, r.decr("foo") + assert_equal 1, r.decr("foo") + assert_equal 0, r.decr("foo") + end + + def test_decrby + r.set("foo", 6) + + assert_equal 3, r.decrby("foo", 3) + assert_equal 1, r.decrby("foo", 2) + assert_equal 0, r.decrby("foo", 1) + end + + def test_append + r.set "foo", "s" + r.append "foo", "1" + + assert_equal "s1", r.get("foo") + end + + def test_getbit + r.set("foo", "a") + + assert_equal 1, r.getbit("foo", 1) + assert_equal 1, r.getbit("foo", 2) + assert_equal 0, r.getbit("foo", 3) + assert_equal 0, r.getbit("foo", 4) + assert_equal 0, r.getbit("foo", 5) + assert_equal 0, r.getbit("foo", 6) + assert_equal 1, r.getbit("foo", 7) + end + + def test_setbit + r.set("foo", "a") + + r.setbit("foo", 6, 1) + + assert_equal "c", r.get("foo") + end + + def test_bitcount + target_version "2.5.10" do + r.set("foo", "abcde") + + assert_equal 10, r.bitcount("foo", 1, 3) + assert_equal 17, r.bitcount("foo", 0, -1) + end + end + + def test_getrange + r.set("foo", "abcde") + + assert_equal "bcd", r.getrange("foo", 1, 3) + assert_equal "abcde", r.getrange("foo", 0, -1) + end + + def test_setrange + r.set("foo", "abcde") + + r.setrange("foo", 1, "bar") + + assert_equal "abare", r.get("foo") + end + + def test_setrange_with_non_string_value + r.set("foo", "abcde") + + value = ["b", "a", "r"] + + r.setrange("foo", 2, value) + + assert_equal "ab#{value.to_s}", r.get("foo") + end + + def test_strlen + r.set "foo", "lorem" + + assert_equal 5, r.strlen("foo") + end + end +end diff --git a/lib/vendor/redis/test/lint/value_types.rb b/lib/vendor/redis/test/lint/value_types.rb new file mode 100644 index 0000000..c4deb23 --- /dev/null +++ b/lib/vendor/redis/test/lint/value_types.rb @@ -0,0 +1,122 @@ +module Lint + + module ValueTypes + + def test_exists + assert_equal false, r.exists("foo") + + r.set("foo", "s1") + + assert_equal true, r.exists("foo") + end + + def test_type + assert_equal "none", r.type("foo") + + r.set("foo", "s1") + + assert_equal "string", r.type("foo") + end + + def test_keys + r.set("f", "s1") + r.set("fo", "s2") + r.set("foo", "s3") + + assert_equal ["f","fo", "foo"], r.keys("f*").sort + end + + def test_expire + r.set("foo", "s1") + assert r.expire("foo", 2) + assert_in_range 0..2, r.ttl("foo") + end + + def test_pexpire + target_version "2.5.4" do + r.set("foo", "s1") + assert r.pexpire("foo", 2000) + assert_in_range 0..2, r.ttl("foo") + end + end + + def test_expireat + r.set("foo", "s1") + assert r.expireat("foo", (Time.now + 2).to_i) + assert_in_range 0..2, r.ttl("foo") + end + + def test_pexpireat + target_version "2.5.4" do + r.set("foo", "s1") + assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000) + assert_in_range 0..2, r.ttl("foo") + end + end + + def test_persist + r.set("foo", "s1") + r.expire("foo", 1) + r.persist("foo") + + assert(-1 == r.ttl("foo")) + end + + def test_ttl + r.set("foo", "s1") + r.expire("foo", 2) + assert_in_range 0..2, r.ttl("foo") + end + + def test_pttl + target_version "2.5.4" do + r.set("foo", "s1") + r.expire("foo", 2) + assert_in_range 1..2000, r.pttl("foo") + end + end + + def test_dump_and_restore + target_version "2.5.7" do + r.set("foo", "a") + v = r.dump("foo") + r.del("foo") + + assert r.restore("foo", 1000, v) + assert_equal "a", r.get("foo") + assert [0, 1].include? r.ttl("foo") + + r.rpush("bar", ["b", "c", "d"]) + w = r.dump("bar") + r.del("bar") + + assert r.restore("bar", 1000, w) + assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1) + assert [0, 1].include? r.ttl("bar") + end + end + + def test_move + r.select 14 + r.flushdb + + r.set "bar", "s3" + + r.select 15 + + r.set "foo", "s1" + r.set "bar", "s2" + + assert r.move("foo", 14) + assert_equal nil, r.get("foo") + + assert !r.move("bar", 14) + assert_equal "s2", r.get("bar") + + r.select 14 + + assert_equal "s1", r.get("foo") + assert_equal "s3", r.get("bar") + end + end +end diff --git a/lib/vendor/redis/test/persistence_control_commands_test.rb b/lib/vendor/redis/test/persistence_control_commands_test.rb new file mode 100644 index 0000000..2816571 --- /dev/null +++ b/lib/vendor/redis/test/persistence_control_commands_test.rb @@ -0,0 +1,26 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestPersistenceControlCommands < Test::Unit::TestCase + + include Helper::Client + + def test_save + redis_mock(:save => lambda { "+SAVE" }) do |redis| + assert_equal "SAVE", redis.save + end + end + + def test_bgsave + redis_mock(:bgsave => lambda { "+BGSAVE" }) do |redis| + assert_equal "BGSAVE", redis.bgsave + end + end + + def test_lastsave + redis_mock(:lastsave => lambda { "+LASTSAVE" }) do |redis| + assert_equal "LASTSAVE", redis.lastsave + end + end +end diff --git a/lib/vendor/redis/test/pipelining_commands_test.rb b/lib/vendor/redis/test/pipelining_commands_test.rb new file mode 100644 index 0000000..82cd92f --- /dev/null +++ b/lib/vendor/redis/test/pipelining_commands_test.rb @@ -0,0 +1,242 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestPipeliningCommands < Test::Unit::TestCase + + include Helper::Client + + def test_bulk_commands + r.pipelined do + r.lpush "foo", "s1" + r.lpush "foo", "s2" + end + + assert_equal 2, r.llen("foo") + assert_equal "s2", r.lpop("foo") + assert_equal "s1", r.lpop("foo") + end + + def test_multi_bulk_commands + r.pipelined do + r.mset("foo", "s1", "bar", "s2") + r.mset("baz", "s3", "qux", "s4") + end + + assert_equal "s1", r.get("foo") + assert_equal "s2", r.get("bar") + assert_equal "s3", r.get("baz") + assert_equal "s4", r.get("qux") + end + + def test_bulk_and_multi_bulk_commands_mixed + r.pipelined do + r.lpush "foo", "s1" + r.lpush "foo", "s2" + r.mset("baz", "s3", "qux", "s4") + end + + assert_equal 2, r.llen("foo") + assert_equal "s2", r.lpop("foo") + assert_equal "s1", r.lpop("foo") + assert_equal "s3", r.get("baz") + assert_equal "s4", r.get("qux") + end + + def test_multi_bulk_and_bulk_commands_mixed + r.pipelined do + r.mset("baz", "s3", "qux", "s4") + r.lpush "foo", "s1" + r.lpush "foo", "s2" + end + + assert_equal 2, r.llen("foo") + assert_equal "s2", r.lpop("foo") + assert_equal "s1", r.lpop("foo") + assert_equal "s3", r.get("baz") + assert_equal "s4", r.get("qux") + end + + def test_pipelined_with_an_empty_block + assert_nothing_raised do + r.pipelined do + end + end + + assert_equal 0, r.dbsize + end + + def test_returning_the_result_of_a_pipeline + result = r.pipelined do + r.set "foo", "bar" + r.get "foo" + r.get "bar" + end + + assert_equal ["OK", "bar", nil], result + end + + def test_assignment_of_results_inside_the_block + r.pipelined do + @first = r.sadd("foo", 1) + @second = r.sadd("foo", 1) + end + + assert_equal true, @first.value + assert_equal false, @second.value + end + + # Although we could support accessing the values in these futures, + # it doesn't make a lot of sense. + def test_assignment_of_results_inside_the_block_with_errors + assert_raise(Redis::CommandError) do + r.pipelined do + r.doesnt_exist + @first = r.sadd("foo", 1) + @second = r.sadd("foo", 1) + end + end + + assert_raise(Redis::FutureNotReady) { @first.value } + assert_raise(Redis::FutureNotReady) { @second.value } + end + + def test_assignment_of_results_inside_a_nested_block + r.pipelined do + @first = r.sadd("foo", 1) + + r.pipelined do + @second = r.sadd("foo", 1) + end + end + + assert_equal true, @first.value + assert_equal false, @second.value + end + + def test_futures_raise_when_confused_with_something_else + r.pipelined do + @result = r.sadd("foo", 1) + end + + assert_raise(NoMethodError) { @result.to_s } + end + + def test_futures_raise_when_trying_to_access_their_values_too_early + r.pipelined do + assert_raise(Redis::FutureNotReady) do + r.sadd("foo", 1).value + end + end + end + + def test_futures_can_be_identified + r.pipelined do + @result = r.sadd("foo", 1) + end + + assert_equal true, @result.is_a?(Redis::Future) + if defined?(::BasicObject) + assert_equal true, @result.is_a?(::BasicObject) + end + assert_equal Redis::Future, @result.class + end + + def test_returning_the_result_of_an_empty_pipeline + result = r.pipelined do + end + + assert_equal [], result + end + + def test_nesting_pipeline_blocks + r.pipelined do + r.set("foo", "s1") + r.pipelined do + r.set("bar", "s2") + end + end + + assert_equal "s1", r.get("foo") + assert_equal "s2", r.get("bar") + end + + def test_info_in_a_pipeline_returns_hash + result = r.pipelined do + r.info + end + + assert result.first.kind_of?(Hash) + end + + def test_config_get_in_a_pipeline_returns_hash + result = r.pipelined do + r.config(:get, "*") + end + + assert result.first.kind_of?(Hash) + end + + def test_hgetall_in_a_pipeline_returns_hash + r.hmset("hash", "field", "value") + result = r.pipelined do + r.hgetall("hash") + end + + assert_equal result.first, { "field" => "value" } + end + + def test_keys_in_a_pipeline + r.set("key", "value") + result = r.pipelined do + r.keys("*") + end + + assert_equal ["key"], result.first + end + + def test_pipeline_yields_a_connection + r.pipelined do |p| + p.set("foo", "bar") + end + + assert_equal "bar", r.get("foo") + end + + def test_pipeline_select + r.select 1 + r.set("db", "1") + + r.pipelined do |p| + p.select 2 + p.set("db", "2") + end + + r.select 1 + assert_equal "1", r.get("db") + + r.select 2 + assert_equal "2", r.get("db") + end + + def test_pipeline_select_client_db + r.select 1 + r.pipelined do |p2| + p2.select 2 + end + + assert_equal 2, r.client.db + end + + def test_nested_pipeline_select_client_db + r.select 1 + r.pipelined do |p2| + p2.select 2 + p2.pipelined do |p3| + p3.select 3 + end + end + + assert_equal 3, r.client.db + end +end diff --git a/lib/vendor/redis/test/publish_subscribe_test.rb b/lib/vendor/redis/test/publish_subscribe_test.rb new file mode 100644 index 0000000..e607e62 --- /dev/null +++ b/lib/vendor/redis/test/publish_subscribe_test.rb @@ -0,0 +1,282 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestPublishSubscribe < Test::Unit::TestCase + + include Helper::Client + + class TestError < StandardError + end + + def test_subscribe_and_unsubscribe + @subscribed = false + @unsubscribed = false + + wire = Wire.new do + r.subscribe("foo") do |on| + on.subscribe do |channel, total| + @subscribed = true + @t1 = total + end + + on.message do |channel, message| + if message == "s1" + r.unsubscribe + @message = message + end + end + + on.unsubscribe do |channel, total| + @unsubscribed = true + @t2 = total + end + end + end + + # Wait until the subscription is active before publishing + Wire.pass while !@subscribed + + Redis.new(OPTIONS).publish("foo", "s1") + + wire.join + + assert @subscribed + assert_equal 1, @t1 + assert @unsubscribed + assert_equal 0, @t2 + assert_equal "s1", @message + end + + def test_psubscribe_and_punsubscribe + @subscribed = false + @unsubscribed = false + + wire = Wire.new do + r.psubscribe("f*") do |on| + on.psubscribe do |pattern, total| + @subscribed = true + @t1 = total + end + + on.pmessage do |pattern, channel, message| + if message == "s1" + r.punsubscribe + @message = message + end + end + + on.punsubscribe do |pattern, total| + @unsubscribed = true + @t2 = total + end + end + end + + # Wait until the subscription is active before publishing + Wire.pass while !@subscribed + + Redis.new(OPTIONS).publish("foo", "s1") + + wire.join + + assert @subscribed + assert_equal 1, @t1 + assert @unsubscribed + assert_equal 0, @t2 + assert_equal "s1", @message + end + + def test_pubsub_with_numpat_subcommand + target_version("2.8.0") do + @subscribed = false + wire = Wire.new do + r.psubscribe("f*") do |on| + on.psubscribe { |channel, total| @subscribed = true } + on.pmessage { |pattern, channel, message| r.punsubscribe } + end + end + Wire.pass while !@subscribed + redis = Redis.new(OPTIONS) + numpat_result = redis.pubsub(:numpat) + + redis.publish("foo", "s1") + wire.join + + assert_equal redis.pubsub(:numpat), 0 + assert_equal numpat_result, 1 + end + end + + + def test_pubsub_with_channels_and_numsub_subcommnads + target_version("2.8.0") do + @subscribed = false + wire = Wire.new do + r.subscribe("foo") do |on| + on.subscribe { |channel, total| @subscribed = true } + on.message { |channel, message| r.unsubscribe } + end + end + Wire.pass while !@subscribed + redis = Redis.new(OPTIONS) + channels_result = redis.pubsub(:channels) + numsub_result = redis.pubsub(:numsub, 'foo', 'boo') + + redis.publish("foo", "s1") + wire.join + + assert_equal channels_result, ['foo'] + assert_equal numsub_result, ['foo', 1, 'boo', 0] + end + end + + def test_subscribe_connection_usable_after_raise + @subscribed = false + + wire = Wire.new do + begin + r.subscribe("foo") do |on| + on.subscribe do |channel, total| + @subscribed = true + end + + on.message do |channel, message| + raise TestError + end + end + rescue TestError + end + end + + # Wait until the subscription is active before publishing + Wire.pass while !@subscribed + + Redis.new(OPTIONS).publish("foo", "s1") + + wire.join + + assert_equal "PONG", r.ping + end + + def test_psubscribe_connection_usable_after_raise + @subscribed = false + + wire = Wire.new do + begin + r.psubscribe("f*") do |on| + on.psubscribe do |pattern, total| + @subscribed = true + end + + on.pmessage do |pattern, channel, message| + raise TestError + end + end + rescue TestError + end + end + + # Wait until the subscription is active before publishing + Wire.pass while !@subscribed + + Redis.new(OPTIONS).publish("foo", "s1") + + wire.join + + assert_equal "PONG", r.ping + end + + def test_subscribe_within_subscribe + @channels = [] + + wire = Wire.new do + r.subscribe("foo") do |on| + on.subscribe do |channel, total| + @channels << channel + + r.subscribe("bar") if channel == "foo" + r.unsubscribe if channel == "bar" + end + end + end + + wire.join + + assert_equal ["foo", "bar"], @channels + end + + def test_other_commands_within_a_subscribe + assert_raise Redis::CommandError do + r.subscribe("foo") do |on| + on.subscribe do |channel, total| + r.set("bar", "s2") + end + end + end + end + + def test_subscribe_without_a_block + assert_raise LocalJumpError do + r.subscribe("foo") + end + end + + def test_unsubscribe_without_a_subscribe + assert_raise RuntimeError do + r.unsubscribe + end + + assert_raise RuntimeError do + r.punsubscribe + end + end + + def test_subscribe_past_a_timeout + # For some reason, a thread here doesn't reproduce the issue. + sleep = %{sleep #{OPTIONS[:timeout] * 2}} + publish = %{ruby -rsocket -e 't=TCPSocket.new("127.0.0.1",#{OPTIONS[:port]});t.write("publish foo bar\\r\\n");t.read(4);t.close'} + cmd = [sleep, publish].join("; ") + + IO.popen(cmd, "r+") do |pipe| + received = false + + r.subscribe "foo" do |on| + on.message do |channel, message| + received = true + r.unsubscribe + end + end + + assert received + end + end + + def test_subscribe_with_timeout + received = false + + assert_raise Redis::TimeoutError do + r.subscribe_with_timeout(1, "foo") do |on| + on.message do |channel, message| + received = true + end + end + end + + assert !received + end + + def test_psubscribe_with_timeout + received = false + + assert_raise Redis::TimeoutError do + r.psubscribe_with_timeout(1, "f*") do |on| + on.message do |channel, message| + received = true + end + end + end + + assert !received + end +end diff --git a/lib/vendor/redis/test/remote_server_control_commands_test.rb b/lib/vendor/redis/test/remote_server_control_commands_test.rb new file mode 100644 index 0000000..b5cbd45 --- /dev/null +++ b/lib/vendor/redis/test/remote_server_control_commands_test.rb @@ -0,0 +1,118 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestRemoteServerControlCommands < Test::Unit::TestCase + + include Helper::Client + + def test_info + keys = [ + "redis_version", + "uptime_in_seconds", + "uptime_in_days", + "connected_clients", + "used_memory", + "total_connections_received", + "total_commands_processed", + ] + + info = r.info + + keys.each do |k| + msg = "expected #info to include #{k}" + assert info.keys.include?(k), msg + end + end + + def test_info_commandstats + target_version "2.5.7" do + r.config(:resetstat) + r.ping + + result = r.info(:commandstats) + assert_equal "1", result["ping"]["calls"] + end + end + + def test_monitor_redis_lt_2_5_0 + return unless version < "2.5.0" + + log = [] + + wire = Wire.new do + Redis.new(OPTIONS).monitor do |line| + log << line + break if log.size == 3 + end + end + + Wire.pass while log.empty? # Faster than sleep + + r.set "foo", "s1" + + wire.join + + assert log[-1][%q{(db 15) "set" "foo" "s1"}] + end + + def test_monitor_redis_gte_2_5_0 + return unless version >= "2.5.0" + + log = [] + + wire = Wire.new do + Redis.new(OPTIONS).monitor do |line| + log << line + break if line =~ /set/ + end + end + + Wire.pass while log.empty? # Faster than sleep + + r.set "foo", "s1" + + wire.join + + assert log[-1] =~ /\b15\b.* "set" "foo" "s1"/ + end + + def test_monitor_returns_value_for_break + result = r.monitor do |line| + break line + end + + assert_equal "OK", result + end + + def test_echo + assert_equal "foo bar baz\n", r.echo("foo bar baz\n") + end + + def test_debug + r.set "foo", "s1" + + assert r.debug(:object, "foo").kind_of?(String) + end + + def test_object + r.lpush "list", "value" + + assert_equal 1, r.object(:refcount, "list") + encoding = r.object(:encoding, "list") + assert "ziplist" == encoding || "quicklist" == encoding, "Wrong encoding for list" + assert r.object(:idletime, "list").kind_of?(Fixnum) + end + + def test_sync + redis_mock(:sync => lambda { "+OK" }) do |redis| + assert_equal "OK", redis.sync + end + end + + def test_slowlog + r.slowlog(:reset) + result = r.slowlog(:len) + assert_equal 0, result + end +end diff --git a/lib/vendor/redis/test/scanning_test.rb b/lib/vendor/redis/test/scanning_test.rb new file mode 100644 index 0000000..9a4cf7d --- /dev/null +++ b/lib/vendor/redis/test/scanning_test.rb @@ -0,0 +1,413 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +unless defined?(Enumerator) + Enumerator = Enumerable::Enumerator +end + +class TestScanning < Test::Unit::TestCase + + include Helper::Client + + def test_scan_basic + target_version "2.7.105" do + r.debug :populate, 1000 + + cursor = 0 + all_keys = [] + loop { + cursor, keys = r.scan cursor + all_keys += keys + break if cursor == "0" + } + + assert_equal 1000, all_keys.uniq.size + end + end + + def test_scan_count + target_version "2.7.105" do + r.debug :populate, 1000 + + cursor = 0 + all_keys = [] + loop { + cursor, keys = r.scan cursor, :count => 5 + all_keys += keys + break if cursor == "0" + } + + assert_equal 1000, all_keys.uniq.size + end + end + + def test_scan_match + target_version "2.7.105" do + r.debug :populate, 1000 + + cursor = 0 + all_keys = [] + loop { + cursor, keys = r.scan cursor, :match => "key:1??" + all_keys += keys + break if cursor == "0" + } + + assert_equal 100, all_keys.uniq.size + end + end + + def test_scan_each_enumerator + target_version "2.7.105" do + + r.debug :populate, 1000 + + scan_enumerator = r.scan_each + assert_equal true, scan_enumerator.is_a?(::Enumerator) + + keys_from_scan = scan_enumerator.to_a.uniq + all_keys = r.keys "*" + + assert all_keys.sort == keys_from_scan.sort + end + end + + def test_scan_each_enumerator_match + target_version "2.7.105" do + + r.debug :populate, 1000 + + keys_from_scan = r.scan_each(:match => "key:1??").to_a.uniq + all_keys = r.keys "key:1??" + + assert all_keys.sort == keys_from_scan.sort + end + end + + def test_scan_each_block + target_version "2.7.105" do + + r.debug :populate, 100 + + keys_from_scan = [] + r.scan_each {|key| + keys_from_scan << key + } + + all_keys = r.keys "*" + + assert all_keys.sort == keys_from_scan.uniq.sort + end + end + + def test_scan_each_block_match + target_version "2.7.105" do + + r.debug :populate, 100 + + keys_from_scan = [] + r.scan_each(:match => "key:1?") {|key| + keys_from_scan << key + } + + all_keys = r.keys "key:1?" + + assert all_keys.sort == keys_from_scan.uniq.sort + end + end + + def test_sscan_with_encoding + target_version "2.7.105" do + [:intset, :hashtable].each do |enc| + r.del "set" + + prefix = "" + prefix = "ele:" if enc == :hashtable + + elements = [] + 100.times { |j| elements << "#{prefix}#{j}" } + + r.sadd "set", elements + + assert_equal enc.to_s, r.object("encoding", "set") + + cursor = 0 + all_keys = [] + loop { + cursor, keys = r.sscan "set", cursor + all_keys += keys + break if cursor == "0" + } + + assert_equal 100, all_keys.uniq.size + end + end + end + + def test_sscan_each_enumerator + target_version "2.7.105" do + elements = [] + 100.times { |j| elements << "ele:#{j}" } + r.sadd "set", elements + + scan_enumerator = r.sscan_each("set") + assert_equal true, scan_enumerator.is_a?(::Enumerator) + + keys_from_scan = scan_enumerator.to_a.uniq + all_keys = r.smembers("set") + + assert all_keys.sort == keys_from_scan.sort + end + end + + def test_sscan_each_enumerator_match + target_version "2.7.105" do + elements = [] + 100.times { |j| elements << "ele:#{j}" } + r.sadd "set", elements + + keys_from_scan = r.sscan_each("set", :match => "ele:1?").to_a.uniq + + all_keys = r.smembers("set").grep(/^ele:1.$/) + + assert all_keys.sort == keys_from_scan.sort + end + end + + def test_sscan_each_enumerator_block + target_version "2.7.105" do + elements = [] + 100.times { |j| elements << "ele:#{j}" } + r.sadd "set", elements + + keys_from_scan = [] + r.sscan_each("set") do |key| + keys_from_scan << key + end + + all_keys = r.smembers("set") + + assert all_keys.sort == keys_from_scan.uniq.sort + end + end + + def test_sscan_each_enumerator_block_match + target_version "2.7.105" do + elements = [] + 100.times { |j| elements << "ele:#{j}" } + r.sadd "set", elements + + keys_from_scan = [] + r.sscan_each("set", :match => "ele:1?") do |key| + keys_from_scan << key + end + + all_keys = r.smembers("set").grep(/^ele:1.$/) + + assert all_keys.sort == keys_from_scan.uniq.sort + end + end + + def test_hscan_with_encoding + target_version "2.7.105" do + [:ziplist, :hashtable].each do |enc| + r.del "set" + + count = 1000 + count = 30 if enc == :ziplist + + elements = [] + count.times { |j| elements << "key:#{j}" << j.to_s } + + r.hmset "hash", *elements + + assert_equal enc.to_s, r.object("encoding", "hash") + + cursor = 0 + all_key_values = [] + loop { + cursor, key_values = r.hscan "hash", cursor + all_key_values.concat key_values + break if cursor == "0" + } + + keys2 = [] + all_key_values.each do |k, v| + assert_equal "key:#{v}", k + keys2 << k + end + + assert_equal count, keys2.uniq.size + end + end + end + + def test_hscan_each_enumerator + target_version "2.7.105" do + count = 1000 + elements = [] + count.times { |j| elements << "key:#{j}" << j.to_s } + r.hmset "hash", *elements + + scan_enumerator = r.hscan_each("hash") + assert_equal true, scan_enumerator.is_a?(::Enumerator) + + keys_from_scan = scan_enumerator.to_a.uniq + all_keys = r.hgetall("hash").to_a + + assert all_keys.sort == keys_from_scan.sort + end + end + + def test_hscan_each_enumerator_match + target_version "2.7.105" do + count = 100 + elements = [] + count.times { |j| elements << "key:#{j}" << j.to_s } + r.hmset "hash", *elements + + keys_from_scan = r.hscan_each("hash", :match => "key:1?").to_a.uniq + all_keys = r.hgetall("hash").to_a.select{|k,v| k =~ /^key:1.$/} + + assert all_keys.sort == keys_from_scan.sort + end + end + + def test_hscan_each_block + target_version "2.7.105" do + count = 1000 + elements = [] + count.times { |j| elements << "key:#{j}" << j.to_s } + r.hmset "hash", *elements + + keys_from_scan = [] + r.hscan_each("hash") do |field, value| + keys_from_scan << [field, value] + end + all_keys = r.hgetall("hash").to_a + + assert all_keys.sort == keys_from_scan.uniq.sort + end + end + + def test_hscan_each_block_match + target_version "2.7.105" do + count = 1000 + elements = [] + count.times { |j| elements << "key:#{j}" << j.to_s } + r.hmset "hash", *elements + + keys_from_scan = [] + r.hscan_each("hash", :match => "key:1?") do |field, value| + keys_from_scan << [field, value] + end + all_keys = r.hgetall("hash").to_a.select{|k,v| k =~ /^key:1.$/} + + assert all_keys.sort == keys_from_scan.uniq.sort + end + end + + def test_zscan_with_encoding + target_version "2.7.105" do + [:ziplist, :skiplist].each do |enc| + r.del "zset" + + count = 1000 + count = 30 if enc == :ziplist + + elements = [] + count.times { |j| elements << j << "key:#{j}" } + + r.zadd "zset", elements + + assert_equal enc.to_s, r.object("encoding", "zset") + + cursor = 0 + all_key_scores = [] + loop { + cursor, key_scores = r.zscan "zset", cursor + all_key_scores.concat key_scores + break if cursor == "0" + } + + keys2 = [] + all_key_scores.each do |k, v| + assert_equal true, v.is_a?(Float) + assert_equal "key:#{Integer(v)}", k + keys2 << k + end + + assert_equal count, keys2.uniq.size + end + end + end + + def test_zscan_each_enumerator + target_version "2.7.105" do + count = 1000 + elements = [] + count.times { |j| elements << j << "key:#{j}" } + r.zadd "zset", elements + + scan_enumerator = r.zscan_each "zset" + assert_equal true, scan_enumerator.is_a?(::Enumerator) + + scores_from_scan = scan_enumerator.to_a.uniq + member_scores = r.zrange("zset", 0, -1, :with_scores => true) + + assert member_scores.sort == scores_from_scan.sort + end + end + + def test_zscan_each_enumerator_match + target_version "2.7.105" do + count = 1000 + elements = [] + count.times { |j| elements << j << "key:#{j}" } + r.zadd "zset", elements + + scores_from_scan = r.zscan_each("zset", :match => "key:1??").to_a.uniq + member_scores = r.zrange("zset", 0, -1, :with_scores => true) + filtered_members = member_scores.select{|k,s| k =~ /^key:1..$/} + + assert filtered_members.sort == scores_from_scan.sort + end + end + + def test_zscan_each_block + target_version "2.7.105" do + count = 1000 + elements = [] + count.times { |j| elements << j << "key:#{j}" } + r.zadd "zset", elements + + scores_from_scan = [] + r.zscan_each("zset") do |member, score| + scores_from_scan << [member, score] + end + member_scores = r.zrange("zset", 0, -1, :with_scores => true) + + assert member_scores.sort == scores_from_scan.sort + end + end + + def test_zscan_each_block_match + target_version "2.7.105" do + count = 1000 + elements = [] + count.times { |j| elements << j << "key:#{j}" } + r.zadd "zset", elements + + scores_from_scan = [] + r.zscan_each("zset", :match => "key:1??") do |member, score| + scores_from_scan << [member, score] + end + member_scores = r.zrange("zset", 0, -1, :with_scores => true) + filtered_members = member_scores.select{|k,s| k =~ /^key:1..$/} + + assert filtered_members.sort == scores_from_scan.sort + end + end + +end diff --git a/lib/vendor/redis/test/scripting_test.rb b/lib/vendor/redis/test/scripting_test.rb new file mode 100644 index 0000000..82d0d89 --- /dev/null +++ b/lib/vendor/redis/test/scripting_test.rb @@ -0,0 +1,78 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestScripting < Test::Unit::TestCase + + include Helper::Client + + def to_sha(script) + r.script(:load, script) + end + + def test_script_exists + target_version "2.5.9" do # 2.6-rc1 + a = to_sha("return 1") + b = a.succ + + assert_equal true, r.script(:exists, a) + assert_equal false, r.script(:exists, b) + assert_equal [true], r.script(:exists, [a]) + assert_equal [false], r.script(:exists, [b]) + assert_equal [true, false], r.script(:exists, [a, b]) + end + end + + def test_script_flush + target_version "2.5.9" do # 2.6-rc1 + sha = to_sha("return 1") + assert r.script(:exists, sha) + assert_equal "OK", r.script(:flush) + assert !r.script(:exists, sha) + end + end + + def test_script_kill + target_version "2.5.9" do # 2.6-rc1 + redis_mock(:script => lambda { |arg| "+#{arg.upcase}" }) do |redis| + assert_equal "KILL", redis.script(:kill) + end + end + end + + def test_eval + target_version "2.5.9" do # 2.6-rc1 + assert_equal 0, r.eval("return #KEYS") + assert_equal 0, r.eval("return #ARGV") + assert_equal ["k1", "k2"], r.eval("return KEYS", ["k1", "k2"]) + assert_equal ["a1", "a2"], r.eval("return ARGV", [], ["a1", "a2"]) + end + end + + def test_eval_with_options_hash + target_version "2.5.9" do # 2.6-rc1 + assert_equal 0, r.eval("return #KEYS", {}) + assert_equal 0, r.eval("return #ARGV", {}) + assert_equal ["k1", "k2"], r.eval("return KEYS", { :keys => ["k1", "k2"] }) + assert_equal ["a1", "a2"], r.eval("return ARGV", { :argv => ["a1", "a2"] }) + end + end + + def test_evalsha + target_version "2.5.9" do # 2.6-rc1 + assert_equal 0, r.evalsha(to_sha("return #KEYS")) + assert_equal 0, r.evalsha(to_sha("return #ARGV")) + assert_equal ["k1", "k2"], r.evalsha(to_sha("return KEYS"), ["k1", "k2"]) + assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), [], ["a1", "a2"]) + end + end + + def test_evalsha_with_options_hash + target_version "2.5.9" do # 2.6-rc1 + assert_equal 0, r.evalsha(to_sha("return #KEYS"), {}) + assert_equal 0, r.evalsha(to_sha("return #ARGV"), {}) + assert_equal ["k1", "k2"], r.evalsha(to_sha("return KEYS"), { :keys => ["k1", "k2"] }) + assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), { :argv => ["a1", "a2"] }) + end + end +end diff --git a/lib/vendor/redis/test/sentinel_command_test.rb b/lib/vendor/redis/test/sentinel_command_test.rb new file mode 100644 index 0000000..d61fa07 --- /dev/null +++ b/lib/vendor/redis/test/sentinel_command_test.rb @@ -0,0 +1,80 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class SentinalCommandsTest < Test::Unit::TestCase + + include Helper::Client + + def test_sentinel_command_master + + handler = lambda do |id| + { + :sentinel => lambda do |command, *args| + ["name", "master1", "ip", "127.0.0.1"] + end + } + end + + RedisMock.start(handler.call(:s1)) do |port| + redis = Redis.new(:host => "127.0.0.1", :port => port) + + result = redis.sentinel('master', 'master1') + assert_equal result, { "name" => "master1", "ip" => "127.0.0.1" } + end + end + + def test_sentinel_command_masters + + handler = lambda do |id| + { + :sentinel => lambda do |command, *args| + [%w[name master1 ip 127.0.0.1 port 6381], %w[name master1 ip 127.0.0.1 port 6382]] + end + } + end + + RedisMock.start(handler.call(:s1)) do |port| + redis = Redis.new(:host => "127.0.0.1", :port => port) + + result = redis.sentinel('masters') + assert_equal result[0], { "name" => "master1", "ip" => "127.0.0.1", "port" => "6381" } + assert_equal result[1], { "name" => "master1", "ip" => "127.0.0.1", "port" => "6382" } + end + end + + def test_sentinel_command_get_master_by_name + + handler = lambda do |id| + { + :sentinel => lambda do |command, *args| + ["127.0.0.1", "6381"] + end + } + end + + RedisMock.start(handler.call(:s1)) do |port| + redis = Redis.new(:host => "127.0.0.1", :port => port) + + result = redis.sentinel('get-master-addr-by-name', 'master1') + assert_equal result, ["127.0.0.1", "6381"] + end + end + + def test_sentinel_command_ckquorum + handler = lambda do |id| + { + :sentinel => lambda do |command, *args| + "+OK 2 usable Sentinels. Quorum and failover authorization can be reached" + end + } + end + + RedisMock.start(handler.call(:s1)) do |port| + redis = Redis.new(:host => "127.0.0.1", :port => port) + + result = redis.sentinel('ckquorum', 'master1') + assert_equal result, "OK 2 usable Sentinels. Quorum and failover authorization can be reached" + end + end +end diff --git a/lib/vendor/redis/test/sentinel_test.rb b/lib/vendor/redis/test/sentinel_test.rb new file mode 100644 index 0000000..1eff251 --- /dev/null +++ b/lib/vendor/redis/test/sentinel_test.rb @@ -0,0 +1,255 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class SentinalTest < Test::Unit::TestCase + + include Helper::Client + + def test_sentinel_connection + sentinels = [{:host => "127.0.0.1", :port => 26381}, + {:host => "127.0.0.1", :port => 26382}] + + commands = { + :s1 => [], + :s2 => [], + } + + handler = lambda do |id| + { + :sentinel => lambda do |command, *args| + commands[id] << [command, *args] + ["127.0.0.1", "6381"] + end + } + end + + RedisMock.start(handler.call(:s1)) do |s1_port| + RedisMock.start(handler.call(:s2)) do |s2_port| + sentinels[0][:port] = s1_port + sentinels[1][:port] = s2_port + redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master) + + assert redis.ping + end + end + + assert_equal commands[:s1], [%w[get-master-addr-by-name master1]] + assert_equal commands[:s2], [] + end + + def test_sentinel_failover + sentinels = [{:host => "127.0.0.1", :port => 26381}, + {:host => "127.0.0.1", :port => 26382}] + + commands = { + :s1 => [], + :s2 => [], + } + + s1 = { + :sentinel => lambda do |command, *args| + commands[:s1] << [command, *args] + "$-1" # Nil + end + } + + s2 = { + :sentinel => lambda do |command, *args| + commands[:s2] << [command, *args] + ["127.0.0.1", "6381"] + end + } + + RedisMock.start(s1) do |s1_port| + RedisMock.start(s2) do |s2_port| + sentinels[0][:port] = s1_port + sentinels[1][:port] = s2_port + redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master) + + assert redis.ping + end + end + + assert_equal commands[:s1], [%w[get-master-addr-by-name master1]] + assert_equal commands[:s2], [%w[get-master-addr-by-name master1]] + end + + def test_sentinel_failover_prioritize_healthy_sentinel + sentinels = [{:host => "127.0.0.1", :port => 26381}, + {:host => "127.0.0.1", :port => 26382}] + + commands = { + :s1 => [], + :s2 => [], + } + + s1 = { + :sentinel => lambda do |command, *args| + commands[:s1] << [command, *args] + "$-1" # Nil + end + } + + s2 = { + :sentinel => lambda do |command, *args| + commands[:s2] << [command, *args] + ["127.0.0.1", "6381"] + end + } + + RedisMock.start(s1) do |s1_port| + RedisMock.start(s2) do |s2_port| + sentinels[0][:port] = s1_port + sentinels[1][:port] = s2_port + redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master) + + assert redis.ping + + redis.quit + + assert redis.ping + end + end + + assert_equal commands[:s1], [%w[get-master-addr-by-name master1]] + assert_equal commands[:s2], [%w[get-master-addr-by-name master1], %w[get-master-addr-by-name master1]] + end + + def test_sentinel_with_non_sentinel_options + sentinels = [{:host => "127.0.0.1", :port => 26381}] + + commands = { + :s1 => [], + :m1 => [] + } + + sentinel = lambda do |port| + { + :auth => lambda do |pass| + commands[:s1] << ["auth", pass] + "-ERR unknown command 'auth'" + end, + :select => lambda do |db| + commands[:s1] << ["select", db] + "-ERR unknown command 'select'" + end, + :sentinel => lambda do |command, *args| + commands[:s1] << [command, *args] + ["127.0.0.1", port.to_s] + end + } + end + + master = { + :auth => lambda do |pass| + commands[:m1] << ["auth", pass] + "+OK" + end, + :role => lambda do + commands[:m1] << ["role"] + ["master"] + end + } + + RedisMock.start(master) do |master_port| + RedisMock.start(sentinel.call(master_port)) do |sen_port| + sentinels[0][:port] = sen_port + redis = Redis.new(:url => "redis://:foo@master1/15", :sentinels => sentinels, :role => :master) + + assert redis.ping + end + end + + assert_equal [%w[get-master-addr-by-name master1]], commands[:s1] + assert_equal [%w[auth foo], %w[role]], commands[:m1] + end + + def test_sentinel_role_mismatch + sentinels = [{:host => "127.0.0.1", :port => 26381}] + + sentinel = lambda do |port| + { + :sentinel => lambda do |command, *args| + ["127.0.0.1", port.to_s] + end + } + end + + master = { + :role => lambda do + ["slave"] + end + } + + ex = assert_raise(Redis::ConnectionError) do + RedisMock.start(master) do |master_port| + RedisMock.start(sentinel.call(master_port)) do |sen_port| + sentinels[0][:port] = sen_port + redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master) + + assert redis.ping + end + end + end + + assert_match(/Instance role mismatch/, ex.message) + end + + def test_sentinel_retries + sentinels = [{:host => "127.0.0.1", :port => 26381}, + {:host => "127.0.0.1", :port => 26382}] + + connections = [] + + handler = lambda do |id, port| + { + :sentinel => lambda do |command, *args| + connections << id + + if connections.count(id) < 2 + :close + else + ["127.0.0.1", port.to_s] + end + end + } + end + + master = { + :role => lambda do + ["master"] + end + } + + RedisMock.start(master) do |master_port| + RedisMock.start(handler.call(:s1, master_port)) do |s1_port| + RedisMock.start(handler.call(:s2, master_port)) do |s2_port| + sentinels[0][:port] = s1_port + sentinels[1][:port] = s2_port + redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master, :reconnect_attempts => 1) + + assert redis.ping + end + end + end + + assert_equal [:s1, :s2, :s1], connections + + connections.clear + + ex = assert_raise(Redis::CannotConnectError) do + RedisMock.start(master) do |master_port| + RedisMock.start(handler.call(:s1, master_port)) do |s1_port| + RedisMock.start(handler.call(:s2, master_port)) do |s2_port| + redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master, :reconnect_attempts => 0) + + assert redis.ping + end + end + end + end + + assert_match(/No sentinels available/, ex.message) + end +end diff --git a/lib/vendor/redis/test/sorting_test.rb b/lib/vendor/redis/test/sorting_test.rb new file mode 100644 index 0000000..e8aec56 --- /dev/null +++ b/lib/vendor/redis/test/sorting_test.rb @@ -0,0 +1,59 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestSorting < Test::Unit::TestCase + + include Helper::Client + + def test_sort + r.set("foo:1", "s1") + r.set("foo:2", "s2") + + r.rpush("bar", "1") + r.rpush("bar", "2") + + assert_equal ["s1"], r.sort("bar", :get => "foo:*", :limit => [0, 1]) + assert_equal ["s2"], r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha") + end + + def test_sort_with_an_array_of_gets + r.set("foo:1:a", "s1a") + r.set("foo:1:b", "s1b") + + r.set("foo:2:a", "s2a") + r.set("foo:2:b", "s2b") + + r.rpush("bar", "1") + r.rpush("bar", "2") + + assert_equal [["s1a", "s1b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1]) + assert_equal [["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha") + assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"]) + end + + def test_sort_with_store + r.set("foo:1", "s1") + r.set("foo:2", "s2") + + r.rpush("bar", "1") + r.rpush("bar", "2") + + r.sort("bar", :get => "foo:*", :store => "baz") + assert_equal ["s1", "s2"], r.lrange("baz", 0, -1) + end + + def test_sort_with_an_array_of_gets_and_with_store + r.set("foo:1:a", "s1a") + r.set("foo:1:b", "s1b") + + r.set("foo:2:a", "s2a") + r.set("foo:2:b", "s2b") + + r.rpush("bar", "1") + r.rpush("bar", "2") + + r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :store => 'baz') + assert_equal ["s1a", "s1b", "s2a", "s2b"], r.lrange("baz", 0, -1) + end +end diff --git a/lib/vendor/redis/test/ssl_test.rb b/lib/vendor/redis/test/ssl_test.rb new file mode 100644 index 0000000..3800dd8 --- /dev/null +++ b/lib/vendor/redis/test/ssl_test.rb @@ -0,0 +1,66 @@ +# encoding: UTF-8 + +if RUBY_VERSION >= "1.9.3" + require File.expand_path("helper", File.dirname(__FILE__)) + + class SslTest < Test::Unit::TestCase + + include Helper::Client + + driver(:ruby) do + + def test_verified_ssl_connection + RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port| + redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file }) + assert_equal redis.ping, "PONG" + end + end + + def test_unverified_ssl_connection + assert_raise(OpenSSL::SSL::SSLError) do + RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("untrusted")) do |port| + redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file }) + redis.ping + end + end + end + + end + + driver(:hiredis, :synchrony) do + + def test_ssl_not_implemented_exception + assert_raise(NotImplementedError) do + RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port| + redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file }) + redis.ping + end + end + end + + end + + private + + def ssl_server_opts(prefix) + ssl_cert = File.join(cert_path, "#{prefix}-cert.crt") + ssl_key = File.join(cert_path, "#{prefix}-cert.key") + + { + :ssl => true, + :ssl_params => { + :cert => OpenSSL::X509::Certificate.new(File.read(ssl_cert)), + :key => OpenSSL::PKey::RSA.new(File.read(ssl_key)) + } + } + end + + def ssl_ca_file + File.join(cert_path, "trusted-ca.crt") + end + + def cert_path + File.expand_path("../support/ssl/", __FILE__) + end + end +end diff --git a/lib/vendor/redis/test/support/connection/hiredis.rb b/lib/vendor/redis/test/support/connection/hiredis.rb new file mode 100644 index 0000000..f2ccbca --- /dev/null +++ b/lib/vendor/redis/test/support/connection/hiredis.rb @@ -0,0 +1 @@ +require "support/wire/thread" diff --git a/lib/vendor/redis/test/support/connection/ruby.rb b/lib/vendor/redis/test/support/connection/ruby.rb new file mode 100644 index 0000000..f2ccbca --- /dev/null +++ b/lib/vendor/redis/test/support/connection/ruby.rb @@ -0,0 +1 @@ +require "support/wire/thread" diff --git a/lib/vendor/redis/test/support/connection/synchrony.rb b/lib/vendor/redis/test/support/connection/synchrony.rb new file mode 100644 index 0000000..80acb0a --- /dev/null +++ b/lib/vendor/redis/test/support/connection/synchrony.rb @@ -0,0 +1,17 @@ +require "support/wire/synchrony" + +module Helper + def around + rv = nil + + EM.synchrony do + begin + rv = yield + ensure + EM.stop + end + end + + rv + end +end diff --git a/lib/vendor/redis/test/support/redis_mock.rb b/lib/vendor/redis/test/support/redis_mock.rb new file mode 100644 index 0000000..8034df6 --- /dev/null +++ b/lib/vendor/redis/test/support/redis_mock.rb @@ -0,0 +1,130 @@ +require "socket" + +module RedisMock + class Server + def initialize(options = {}, &block) + tcp_server = TCPServer.new(options[:host] || "127.0.0.1", 0) + tcp_server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true) + + if options[:ssl] + ctx = OpenSSL::SSL::SSLContext.new + + ssl_params = options.fetch(:ssl_params, {}) + ctx.set_params(ssl_params) unless ssl_params.empty? + + @server = OpenSSL::SSL::SSLServer.new(tcp_server, ctx) + else + @server = tcp_server + end + end + + def port + @server.addr[1] + end + + def start(&block) + @thread = Thread.new { run(&block) } + end + + def shutdown + @thread.kill + end + + def run + begin + loop do + session = @server.accept + + begin + return if yield(session) == :exit + ensure + session.close + end + end + rescue => ex + $stderr.puts "Error running mock server: #{ex.message}" + $stderr.puts ex.backtrace + retry + ensure + @server.close + end + end + end + + # Starts a mock Redis server in a thread. + # + # The server will use the lambda handler passed as argument to handle + # connections. For example: + # + # handler = lambda { |session| session.close } + # RedisMock.start_with_handler(handler) do + # # Every connection will be closed immediately + # end + # + def self.start_with_handler(blk, options = {}) + server = Server.new(options) + port = server.port + + begin + server.start(&blk) + yield(port) + ensure + server.shutdown + end + end + + # Starts a mock Redis server in a thread. + # + # The server will reply with a `+OK` to all commands, but you can + # customize it by providing a hash. For example: + # + # RedisMock.start(:ping => lambda { "+PONG" }) do |port| + # assert_equal "PONG", Redis.new(:port => port).ping + # end + # + def self.start(commands, options = {}, &blk) + handler = lambda do |session| + while line = session.gets + argv = Array.new(line[1..-3].to_i) do + bytes = session.gets[1..-3].to_i + arg = session.read(bytes) + session.read(2) # Discard \r\n + arg + end + + command = argv.shift + blk = commands[command.to_sym] + blk ||= lambda { |*_| "+OK" } + + response = blk.call(*argv) + + # Convert a nil response to :close + response ||= :close + + if response == :exit + break :exit + elsif response == :close + break :close + elsif response.is_a?(Array) + session.write("*%d\r\n" % response.size) + + response.each do |resp| + if resp.is_a?(Array) + session.write("*%d\r\n" % resp.size) + resp.each do |r| + session.write("$%d\r\n%s\r\n" % [r.length, r]) + end + else + session.write("$%d\r\n%s\r\n" % [resp.length, resp]) + end + end + else + session.write(response) + session.write("\r\n") unless response.end_with?("\r\n") + end + end + end + + start_with_handler(handler, options, &blk) + end +end diff --git a/lib/vendor/redis/test/support/ssl/gen_certs.sh b/lib/vendor/redis/test/support/ssl/gen_certs.sh new file mode 100755 index 0000000..074d3e6 --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/gen_certs.sh @@ -0,0 +1,31 @@ +#!/bin/sh + +get_subject() { + if [ "$1" = "trusted" ] + then + echo "/C=IT/ST=Sicily/L=Catania/O=Redis/OU=Security/CN=127.0.0.1" + else + echo "/C=XX/ST=Untrusted/L=Evilville/O=Evil Hacker/OU=Attack Department/CN=127.0.0.1" + fi +} + +# Generate two CAs: one to be considered trusted, and one that's untrusted +for type in trusted untrusted; do + rm -rf ./demoCA + mkdir -p ./demoCA + mkdir -p ./demoCA/certs + mkdir -p ./demoCA/crl + mkdir -p ./demoCA/newcerts + mkdir -p ./demoCA/private + touch ./demoCA/index.txt + + openssl genrsa -out ${type}-ca.key 2048 + openssl req -new -x509 -days 12500 -key ${type}-ca.key -out ${type}-ca.crt -subj "$(get_subject $type)" + openssl x509 -in ${type}-ca.crt -noout -next_serial -out ./demoCA/serial + + openssl req -newkey rsa:2048 -keyout ${type}-cert.key -nodes -out ${type}-cert.req -subj "$(get_subject $type)" + openssl ca -days 12500 -cert ${type}-ca.crt -keyfile ${type}-ca.key -out ${type}-cert.crt -infiles ${type}-cert.req + rm ${type}-cert.req +done + +rm -rf ./demoCA diff --git a/lib/vendor/redis/test/support/ssl/trusted-ca.crt b/lib/vendor/redis/test/support/ssl/trusted-ca.crt new file mode 100644 index 0000000..f1e1b97 --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/trusted-ca.crt @@ -0,0 +1,25 @@ +-----BEGIN CERTIFICATE----- +MIIEIDCCAwigAwIBAgIJAM7kyjC89Qj/MA0GCSqGSIb3DQEBCwUAMGcxCzAJBgNV +BAYTAklUMQ8wDQYDVQQIEwZTaWNpbHkxEDAOBgNVBAcTB0NhdGFuaWExDjAMBgNV +BAoTBVJlZGlzMREwDwYDVQQLEwhTZWN1cml0eTESMBAGA1UEAxMJMTI3LjAuMC4x +MCAXDTE2MDQwMjAzMzQ0MVoYDzIwNTAwNjIzMDMzNDQxWjBnMQswCQYDVQQGEwJJ +VDEPMA0GA1UECBMGU2ljaWx5MRAwDgYDVQQHEwdDYXRhbmlhMQ4wDAYDVQQKEwVS +ZWRpczERMA8GA1UECxMIU2VjdXJpdHkxEjAQBgNVBAMTCTEyNy4wLjAuMTCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMeibFqEG38mtN9DSXy6NZdd7AjH +4/D+VdDzlbJlI5IBACCV9p6P2j5PFlFvkHFE6vr6biMaLXNAmUHYfDzeT95LODHH +t+8HlR51cNYrnt9B3eiVwEnJ7+axuDHg6nUgLXeKeog+vEqreZwLnFibxt2qpFze +xzyKJ37Pm+iAey5glCc/v7ECYQ4sWVVV+ciC+sAwmZDfZXCBQtRRokJ6ikqQDwWV +DugGcV46feTpu79OmkLLM8PI3E7ow2F/3iv67gmdlO5m9wX1ahWzJKUapBTxgf4X +QG0s60WbC9iJIvgXRGW7wWSsqSVJkfLYllDTPgfpLyl1+FR3A4awrsPiMVUCAwEA +AaOBzDCByTAdBgNVHQ4EFgQU+YG9kJR3Vy31d7QVyxRAYyKTK18wgZkGA1UdIwSB +kTCBjoAU+YG9kJR3Vy31d7QVyxRAYyKTK1+ha6RpMGcxCzAJBgNVBAYTAklUMQ8w +DQYDVQQIEwZTaWNpbHkxEDAOBgNVBAcTB0NhdGFuaWExDjAMBgNVBAoTBVJlZGlz +MREwDwYDVQQLEwhTZWN1cml0eTESMBAGA1UEAxMJMTI3LjAuMC4xggkAzuTKMLz1 +CP8wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAeFKB7DUixmxbdvNw +n/mNoHK+OOZXmfxZDCo0v2gcQ4WXUiCqL6MagrImCvkEz5RL6Fk2ZflEV2iGQ5Ds +CmF2n47ISpqG29bfI5R1rcbfqK/5tazUIhQu12ThNmkEh7hCuW/0LqJrnmxpuRLy +le9e3svCC96lwjFczzU/utWurKt7S7Di3C4P+AXAJJuszDMLMCBLaB/3j24cNpOx +zzeZo02x4rpsD2+MMfRDWMWezVEyk63KnI0kt3JGnepsKCFc48ZOk09LwFk3Rfaq +zuKSgEJJw1mfsdBfysM0HQw20yyjSdoTEfQq3bXctTNi+pEOgW6x7TMsnngYYLXV +9XTrpg== +-----END CERTIFICATE----- diff --git a/lib/vendor/redis/test/support/ssl/trusted-ca.key b/lib/vendor/redis/test/support/ssl/trusted-ca.key new file mode 100644 index 0000000..2c30610 --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/trusted-ca.key @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEpQIBAAKCAQEAx6JsWoQbfya030NJfLo1l13sCMfj8P5V0POVsmUjkgEAIJX2 +no/aPk8WUW+QcUTq+vpuIxotc0CZQdh8PN5P3ks4Mce37weVHnVw1iue30Hd6JXA +Scnv5rG4MeDqdSAtd4p6iD68Sqt5nAucWJvG3aqkXN7HPIonfs+b6IB7LmCUJz+/ +sQJhDixZVVX5yIL6wDCZkN9lcIFC1FGiQnqKSpAPBZUO6AZxXjp95Om7v06aQssz +w8jcTujDYX/eK/ruCZ2U7mb3BfVqFbMkpRqkFPGB/hdAbSzrRZsL2Iki+BdEZbvB +ZKypJUmR8tiWUNM+B+kvKXX4VHcDhrCuw+IxVQIDAQABAoIBAQCzbGHiQJXOA+XQ +O9OSjHGaJ8n6Yl2VvaE3eZXzjj8X/Fo271GGVVgbZE10x8aUZxKim+3dEqwCx+52 +ZbHTqyMxcX2CEDRaWwBFLdxKQU467iIZ5m26ZAp/1v7rpXBT8KWsqQNT7L6ihdd4 +zl6orOlhVPsAlSGQYcL5kHJZ1w/fL0phEbwdISd3PYhGHXMNmqfXorzJYHDQA4R+ +yR7WpP1dmnUeEKrHc9FFcBZ75BGlWjdCPZMFKc7IndZumarhBpWH9yZMUxrUIo4V +SCweRUFdD5H1lMZ0YiIAE25wKNEQ2iGd3Jfr8Vj1KFSHC9I2FJA3aFRRUgTwxx/W +h0mJy1ZJAoGBAPYsSSlwQdxZjnyZiVkNSD4MoLdof//nRxeKGejq6AiXDvcsLyJy +0MKk4YBFw2249TWm/KBbMAFiBE7d8uPtP5pPfjNVPX6VltH3AhSZ7Ugbpo6C3NFA +GpzFVtNaWgCVDloDVdmsY7ssDFuAIih0paklPAqnLY+Ua9m1BiEPrB+bAoGBAM+a +i+0NMR4AyKpuo1exdd+7BIHw5HNPwGmR1ggdGWduH0zsOhEawQKKFv1X9xKAcXxW +PyeD56/Tmn7fkWvuE8dOu9E6em0vgmxhYyn4nyLAFYF5uKXYo78MpIEThdpl1ldT +iHwG/25vunaBUHhwbHPUD+F989tmRuCjoFkuA5nPAoGAaqPIlcDhZvkMtoE0dHVC +hE6oGIuWV17y9wmGK9YG6iG2A/EKAhxGvur6HL0b6Z4j6zgJW9Xkt9SkFR4kqAQQ +d2JUQxx75SgcC5y7M/1yQrhnsHiT+7mPTbZW5HvRXUs0yl2DhSYeleiA+epJ4ciW +Mu3EUsEVBYvAJLE8lHnbkF0CgYEAhyxpz3+3a4G3JsHDOWYjCfoLhVAEb9CNyC9c +3QuVbvMVDlEBvgFdivm+3lZYWYOoYP0HQgNw59svzUxks5Hg7vUk9abN8CnvEgKX +PszTUR0g450NzW6xr8PbmO/NR9bnKRUK2Tb1OkMldePdMY6CDykU7g3EqiZ+H+Zq +kaaUUaECgYEAmk5W+S94q5jLemnfAChC5lva/0/aHdhtaoH4Lo+j0haMsdiy8/ZE +sh+3gQ8pqwaCAwnKxAcppt/FNZ7tHRsH3oyY6biypn3WppQj+BA41nuzbspOKJhR +ZDXKFCItbzUjyi23Dx4P4DgMivkpV+e88RMIuBnv4yjl5iOLq+vf4Rg= +-----END RSA PRIVATE KEY----- diff --git a/lib/vendor/redis/test/support/ssl/trusted-cert.crt b/lib/vendor/redis/test/support/ssl/trusted-cert.crt new file mode 100644 index 0000000..8a26c1a --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/trusted-cert.crt @@ -0,0 +1,81 @@ +Certificate: + Data: + Version: 3 (0x2) + Serial Number: 14908262977180600576 (0xcee4ca30bcf50900) + Signature Algorithm: sha1WithRSAEncryption + Issuer: C=IT, ST=Sicily, L=Catania, O=Redis, OU=Security, CN=127.0.0.1 + Validity + Not Before: Apr 2 03:34:42 2016 GMT + Not After : Jun 23 03:34:42 2050 GMT + Subject: C=IT, ST=Sicily, O=Redis, OU=Security, CN=127.0.0.1 + Subject Public Key Info: + Public Key Algorithm: rsaEncryption + Public-Key: (2048 bit) + Modulus: + 00:ab:bf:ac:ef:dc:99:35:fa:07:3f:d5:33:86:f1: + 7d:9e:57:8b:d5:c1:10:04:0c:35:95:7c:61:ff:05: + a6:f9:ef:71:5c:c5:83:68:a2:ad:5d:0f:a5:2b:b4: + 76:9f:36:8f:df:75:fb:d6:48:00:c0:f0:68:56:f6: + 49:84:4d:4e:e1:ca:dd:24:9f:2f:5e:7c:35:26:57: + d6:d5:95:d1:3f:40:32:22:43:2c:8c:b7:8c:89:56: + 7c:d0:94:e5:f7:cf:4a:51:3f:60:b2:fe:1f:3b:38: + d6:47:5d:2e:4f:38:75:d9:9b:c8:0f:d1:fd:91:5a: + 07:c3:94:95:1f:7b:f1:ae:dc:a1:83:e2:6b:78:05: + 34:b3:8b:87:86:31:9f:cc:8b:15:cd:18:2e:06:36: + ca:f8:29:f8:6e:93:60:78:ec:8a:e8:a6:94:ad:24: + a8:e3:d4:ac:42:da:52:0f:34:e8:d0:10:e5:53:db: + f8:3a:56:48:10:33:df:80:70:1c:72:5e:1f:c3:11: + bb:3b:b9:6b:0a:e0:82:eb:67:d4:8f:5c:30:d3:cf: + 17:6d:86:01:0e:ae:43:c1:d8:c0:5e:99:ef:fa:60: + 0a:f2:62:68:62:8b:05:f3:8b:b1:34:d8:70:78:35: + 74:76:c2:46:13:a3:1f:5d:7b:3b:49:20:1e:98:54: + 63:77 + Exponent: 65537 (0x10001) + X509v3 extensions: + X509v3 Basic Constraints: + CA:FALSE + Netscape Comment: + OpenSSL Generated Certificate + X509v3 Subject Key Identifier: + 81:DE:C0:39:F9:8A:57:50:DB:B1:6A:B3:D0:5F:E9:2C:87:5A:1E:3D + X509v3 Authority Key Identifier: + keyid:F9:81:BD:90:94:77:57:2D:F5:77:B4:15:CB:14:40:63:22:93:2B:5F + + Signature Algorithm: sha1WithRSAEncryption + a3:0a:d7:22:5a:bc:cc:f6:ed:2f:f2:9f:dd:e0:46:02:73:14: + dd:a7:f5:39:b9:16:19:16:36:b6:22:5c:66:14:c0:d3:ac:55: + fc:52:2d:c3:b2:70:5f:cf:3d:23:71:78:e9:31:88:65:2c:2e: + 4a:09:6e:4b:97:bb:4d:38:87:d8:25:ed:bb:ed:62:19:08:50: + f2:40:cc:39:ee:f9:a8:3a:5d:2b:e7:34:eb:8a:74:c7:c9:bc: + 88:9b:9b:ca:5b:11:20:ca:53:b2:0b:20:49:fc:b9:f7:ec:03: + c9:5d:c1:24:75:27:f8:7c:70:dc:6a:2c:98:48:93:5f:7f:7e: + 94:a1:cf:79:b3:24:e3:de:9e:f0:0f:d8:d6:3e:c9:52:30:31: + 87:90:c2:d2:23:be:d8:7a:e9:e6:bb:4b:00:75:30:49:4b:98: + d5:f6:7d:b5:83:b5:57:85:20:98:00:51:55:c3:a2:81:ec:6c: + 11:91:33:60:14:7b:d2:01:ee:5b:bf:5b:68:f5:e0:4e:45:0a: + 68:cd:33:4f:29:72:fa:fe:6a:19:b6:84:70:90:a4:d5:7a:04: + 2e:da:5b:98:4f:e4:aa:a6:c4:68:aa:5c:8c:a5:5e:df:20:94: + 22:f7:37:45:71:a4:bc:72:34:ee:42:cf:9d:0f:fb:4a:39:d1: + 8e:41:f3:3f +-----BEGIN CERTIFICATE----- +MIIDvDCCAqSgAwIBAgIJAM7kyjC89QkAMA0GCSqGSIb3DQEBBQUAMGcxCzAJBgNV +BAYTAklUMQ8wDQYDVQQIEwZTaWNpbHkxEDAOBgNVBAcTB0NhdGFuaWExDjAMBgNV +BAoTBVJlZGlzMREwDwYDVQQLEwhTZWN1cml0eTESMBAGA1UEAxMJMTI3LjAuMC4x +MCAXDTE2MDQwMjAzMzQ0MloYDzIwNTAwNjIzMDMzNDQyWjBVMQswCQYDVQQGEwJJ +VDEPMA0GA1UECBMGU2ljaWx5MQ4wDAYDVQQKEwVSZWRpczERMA8GA1UECxMIU2Vj +dXJpdHkxEjAQBgNVBAMTCTEyNy4wLjAuMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAKu/rO/cmTX6Bz/VM4bxfZ5Xi9XBEAQMNZV8Yf8FpvnvcVzFg2ii +rV0PpSu0dp82j991+9ZIAMDwaFb2SYRNTuHK3SSfL158NSZX1tWV0T9AMiJDLIy3 +jIlWfNCU5ffPSlE/YLL+Hzs41kddLk84ddmbyA/R/ZFaB8OUlR978a7coYPia3gF +NLOLh4Yxn8yLFc0YLgY2yvgp+G6TYHjsiuimlK0kqOPUrELaUg806NAQ5VPb+DpW +SBAz34BwHHJeH8MRuzu5awrggutn1I9cMNPPF22GAQ6uQ8HYwF6Z7/pgCvJiaGKL +BfOLsTTYcHg1dHbCRhOjH117O0kgHphUY3cCAwEAAaN7MHkwCQYDVR0TBAIwADAs +BglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwHQYD +VR0OBBYEFIHewDn5ildQ27Fqs9Bf6SyHWh49MB8GA1UdIwQYMBaAFPmBvZCUd1ct +9Xe0FcsUQGMikytfMA0GCSqGSIb3DQEBBQUAA4IBAQCjCtciWrzM9u0v8p/d4EYC +cxTdp/U5uRYZFja2IlxmFMDTrFX8Ui3DsnBfzz0jcXjpMYhlLC5KCW5Ll7tNOIfY +Je277WIZCFDyQMw57vmoOl0r5zTrinTHybyIm5vKWxEgylOyCyBJ/Ln37APJXcEk +dSf4fHDcaiyYSJNff36Uoc95syTj3p7wD9jWPslSMDGHkMLSI77Yeunmu0sAdTBJ +S5jV9n21g7VXhSCYAFFVw6KB7GwRkTNgFHvSAe5bv1to9eBORQpozTNPKXL6/moZ +toRwkKTVegQu2luYT+SqpsRoqlyMpV7fIJQi9zdFcaS8cjTuQs+dD/tKOdGOQfM/ +-----END CERTIFICATE----- diff --git a/lib/vendor/redis/test/support/ssl/trusted-cert.key b/lib/vendor/redis/test/support/ssl/trusted-cert.key new file mode 100644 index 0000000..7dee292 --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/trusted-cert.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCrv6zv3Jk1+gc/ +1TOG8X2eV4vVwRAEDDWVfGH/Bab573FcxYNooq1dD6UrtHafNo/fdfvWSADA8GhW +9kmETU7hyt0kny9efDUmV9bVldE/QDIiQyyMt4yJVnzQlOX3z0pRP2Cy/h87ONZH +XS5POHXZm8gP0f2RWgfDlJUfe/Gu3KGD4mt4BTSzi4eGMZ/MixXNGC4GNsr4Kfhu +k2B47IroppStJKjj1KxC2lIPNOjQEOVT2/g6VkgQM9+AcBxyXh/DEbs7uWsK4ILr +Z9SPXDDTzxdthgEOrkPB2MBeme/6YAryYmhiiwXzi7E02HB4NXR2wkYTox9deztJ +IB6YVGN3AgMBAAECggEASmOxIgtoiQqMzUcpFE/Q2x6MQL9okng/VUoUoALwudzO +OyKJsm6TrHU0U2PM5VUap+1QcRWqzebTKqduXFGn0wCtHEmemMwvsTXmpYhIo57I +mDKEP0bZJjtBwI5dtSIhzGMpHR4YpOwPU8W2YzXPRbvFwaRwsd5O8pWOqZ5jphrQ +DtkLNz4hIFsMihPeYFpuAjsZ2cMIGPtlY2qbfjyno7hd7LxNzL/2vMlDw5MHHtw4 +snxLN92KomC6rSUUydNDyemyMpg8iRwm7gmYzVoZf6aTbI2RdFcv2KZfpUWYdB+I +yU8ZV1Sch7VQ+xLVy74SuY8AZ2Rq4S3M+EmEa5ghoQKBgQDfgOIyStulfYn6UC1A +OYwcGoSOaVNfPE/m9BZN58xK0+XnEqQECMsyg/GYS65Zri4+KJYPxqv6f9ljLTGE +0PxiA7wq+QWnv4EM+3aGShxwyVlmgJZyyBfJtAMr1iDm4JsidTT5GMdfxRICPGZY +WVggcz/cVu39OxRrumREuTWAzwKBgQDEuGheZv68cYt5EkzOWxeFQyt1bzXn1CJg +IXnIFZIekJhVGpBG+zMAYri9+hSheiDrwfIcSfTq9LxF6JNUvaU4qMrkwvW21jKs +n7ofcA+VYq2mggoIuuvKVqXemLHorC0U/zCMnM6rycaa9sB5tsF+Js93uvf1TEJt +veV0yCeM2QKBgF1M0iAoe7SDyXuCyMEMxN5ee4NvmGwjIz/IGR+Aahm6hziE4Y8F +lL2LsujefvPU8FzmWG5Rgy1Y/YiXLxrAmvrXkE9oEOJL4TVoK7w3Z9P1Waqedy+H +M9bxnHlKNAXtMRWbU/fATko+XBwu1pJ/CXjSY5A5gbO6W/X0ozLFFf6lAoGABRZ7 +5I0nY3pQUCZQBDpI5nJxSk1BCKjs5q2W97zPFalJt1HDj4JptEXZX1h7dh2xgkd2 +2pJzGiyQPgKg5N0uy8NZ1AbS0hLCJsLOzodYb9Wohhjw537mIEqTaalrWIgzdkqP +V+OqWLkUQOfG3J8EbB3W2dLlHNwHD82MhLO0iikCgYEAvdK5LmpUdZXMVtiOMZO5 +t3M0vwi6vPhW7DV1QET51x/U+SyH4rvZGeqRl+gcKrZ8SreOlyICvsPgVmvLCrHE +gJLPWJIzI8Mg6u91/KpiVmRahnJjOn3oHNuLSqFjn9lIhmA5dN7zQDXzPdYrWPNR +u1QX+JLhlP33ejgdkdLsNiM= +-----END PRIVATE KEY----- diff --git a/lib/vendor/redis/test/support/ssl/untrusted-ca.crt b/lib/vendor/redis/test/support/ssl/untrusted-ca.crt new file mode 100644 index 0000000..3495dcb --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/untrusted-ca.crt @@ -0,0 +1,26 @@ +-----BEGIN CERTIFICATE----- +MIIEXDCCA0SgAwIBAgIJAIgFm03l5AJkMA0GCSqGSIb3DQEBCwUAMHsxCzAJBgNV +BAYTAlhYMRIwEAYDVQQIEwlVbnRydXN0ZWQxEjAQBgNVBAcTCUV2aWx2aWxsZTEU +MBIGA1UEChMLRXZpbCBIYWNrZXIxGjAYBgNVBAsTEUF0dGFjayBEZXBhcnRtZW50 +MRIwEAYDVQQDEwkxMjcuMC4wLjEwIBcNMTYwNDAyMDMzNDUxWhgPMjA1MDA2MjMw +MzM0NTFaMHsxCzAJBgNVBAYTAlhYMRIwEAYDVQQIEwlVbnRydXN0ZWQxEjAQBgNV +BAcTCUV2aWx2aWxsZTEUMBIGA1UEChMLRXZpbCBIYWNrZXIxGjAYBgNVBAsTEUF0 +dGFjayBEZXBhcnRtZW50MRIwEAYDVQQDEwkxMjcuMC4wLjEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQCtXxcEGUrGqAqlBK94B8IwSkB8OnLYC/c/6Tde +WG46pzmZWZvffi0akcKKubRNcfoavOuqLuNnpQDkIlnJ37K/LZk8Q5+aMoUGBiQ2 +jSN1707sFqH3eTFvXOUzlDEcsBa7Y7RuaI8SXg1UGsnnCcj6H3BW2xKcXPN6/s30 +vhNw2CPqtXm4NOD3Zb5FkB9epAEejRg0OPn5DJ3mESVp/H2EqkptMZ+6cOk2/CMc +e8AAfcxBGwKuOMXNODszTNxN+OuGCHOxx8+vR/eV35tonISwbkmO9WI6DC+pWT2s +PvDhuQtqsrVofCP/pireb5Ce/7bP/FsZcNSMMfV5dponcYrrAgMBAAGjgeAwgd0w +HQYDVR0OBBYEFLeDNvKpJKmuyPsamax2AZTijdkwMIGtBgNVHSMEgaUwgaKAFLeD +NvKpJKmuyPsamax2AZTijdkwoX+kfTB7MQswCQYDVQQGEwJYWDESMBAGA1UECBMJ +VW50cnVzdGVkMRIwEAYDVQQHEwlFdmlsdmlsbGUxFDASBgNVBAoTC0V2aWwgSGFj +a2VyMRowGAYDVQQLExFBdHRhY2sgRGVwYXJ0bWVudDESMBAGA1UEAxMJMTI3LjAu +MC4xggkAiAWbTeXkAmQwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEA +FWYTrxi/h7PYIpp09QsbDiGdC7gmp04HTx82NvBaUFaLk8ygz4DUz5u7QyTDdAga +yWviHghuyZ6vv5Ubaj7XLOzLM6rYsQjkVq5ltwP+9V/U/b5jOHvZdYqdatVXUXxR +SO+e3QYiMpM4Vs/NNXhpUp6apD7VcoB2LgK3vGDJ526PBJjgw24311t8O7kDTwkt +AwX56/KTolMI+k9rT8Ee6aucT6gBNf0judhNkPVo+6CYgjmEVRrN/xaFCUNSpv5E +O6uIcxSSX6a5iOZ/EH+GyHb6kDmztn/Hes+UN9+gMuAK7+LgsD2mYbxn9Pnaerrs +2nER8XurylLxi0GLvNWNdQ== +-----END CERTIFICATE----- diff --git a/lib/vendor/redis/test/support/ssl/untrusted-ca.key b/lib/vendor/redis/test/support/ssl/untrusted-ca.key new file mode 100644 index 0000000..3e30218 --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/untrusted-ca.key @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEpAIBAAKCAQEArV8XBBlKxqgKpQSveAfCMEpAfDpy2Av3P+k3XlhuOqc5mVmb +334tGpHCirm0TXH6Grzrqi7jZ6UA5CJZyd+yvy2ZPEOfmjKFBgYkNo0jde9O7Bah +93kxb1zlM5QxHLAWu2O0bmiPEl4NVBrJ5wnI+h9wVtsSnFzzev7N9L4TcNgj6rV5 +uDTg92W+RZAfXqQBHo0YNDj5+Qyd5hElafx9hKpKbTGfunDpNvwjHHvAAH3MQRsC +rjjFzTg7M0zcTfjrhghzscfPr0f3ld+baJyEsG5JjvViOgwvqVk9rD7w4bkLarK1 +aHwj/6Yq3m+Qnv+2z/xbGXDUjDH1eXaaJ3GK6wIDAQABAoIBAQCeC0QxAVlwNTnW +6qmGsxPr75RPavzMREQ1p8VIpTZ/E3hneg+lMiGtydhdnCJoQxGrFDOFJU86aWmh +jkrpw5nvu4KoNEEnUQyAzFJwxELiPLBmec9WiM1u5nEujtYif8eJNcACsiBSrxhZ +Zj5N9laW5NgE5ZpWnkl7AxL/G9MfFvifr9KtyDcs+wnYD6ffz/bRwS54veMccj/q +SkVQRL7FM4NJczG0TTp+LT/1R3s8YVv9GHnJ6K7Gol3E0PbFS1HztDuMVonhWiac +9Rjt7w0rNgeH6ZbCMXrUd+8I8amazA78p1ky0Mh8d6UUVFU1jjtyxlgDh06IPsnE ++exeAClxAoGBAOMZ7LEFr3VcFwym7RvgckeQhd6Rmz8Bh7kGfB9pDsHFprGJ0rm4 +XgNETJXOky5wUCPZmMBN1iAU/ehyyXqPykXiKjAQLxQNHR9/Z6P58PsHs2Uw8VZa +XdZwlBME5+/yl5DiirO5rCt804DdCQgSu7denudwWbbtzAsodSKj5zEJAoGBAMNu +21hZnsvhtZlvQVHZ4sQttrv9e5VpWWHkDPRN3sdLZPfK/+3L0BmUrGotgNWpTZwR +8YvKRT2Xn1unzpKlkHtIVuHU7khOj+tYHLIx3rezVanw9QzbIANMel6STlUr3jwX +fjnibgkJixxHTOBs8/zm219Q1sNTos9GUOAZQb1TAoGALwGFsVpo59TI3JCMkXGS +led/HgNra84oRo7mECZRrJ/5kdPiLxjPNMPlSji41CrhG5qFeIBj6r4NlBh2RY0P +pAldDBe9dtwEBCn9zL4GOB9u7WoE+ge4VpN0wr8INu0ynAWYCf1LerDaolid7vLZ +sem+4E6r8yYjTsfv/tyIFOkCgYEAlCZobxxZLbNn5+2X9cWXiyIgYXgyBDy9fmDT +lSum0yuLWfDwfELB+XJkFYVzIgVbCRHtKwxl2uAi9OdLyI1r7pkTC9VP4U50+XJt +JoR5koaHTPGVwm4mYXnLVf/RE+3SZXllvdmxknZCl2hRldviRfh3mlT8yUuQo1Jp +oshitnMCgYAXTQLA7B5YLmhCG8HRM/h/xM55ObdDX1SIWUbk3p1uxak1W0abfvpi +FPBy2riOdSDA6Uv7V8y1j4tENGVMyyMsEpFdLDX4Lkbh9niOoPeHCWdO0boPk0Fw +aPXtT7gdTPWJulKOxtLuGqBjZZ77TO49uqWlEMaerulWyjhRm8zzvA== +-----END RSA PRIVATE KEY----- diff --git a/lib/vendor/redis/test/support/ssl/untrusted-cert.crt b/lib/vendor/redis/test/support/ssl/untrusted-cert.crt new file mode 100644 index 0000000..127f8e4 --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/untrusted-cert.crt @@ -0,0 +1,82 @@ +Certificate: + Data: + Version: 3 (0x2) + Serial Number: 9801410922913464933 (0x88059b4de5e40265) + Signature Algorithm: sha1WithRSAEncryption + Issuer: C=XX, ST=Untrusted, L=Evilville, O=Evil Hacker, OU=Attack Department, CN=127.0.0.1 + Validity + Not Before: Apr 2 03:34:51 2016 GMT + Not After : Jun 23 03:34:51 2050 GMT + Subject: C=XX, ST=Untrusted, O=Evil Hacker, OU=Attack Department, CN=127.0.0.1 + Subject Public Key Info: + Public Key Algorithm: rsaEncryption + Public-Key: (2048 bit) + Modulus: + 00:9a:73:e7:45:fc:d3:b5:4a:bd:bd:ad:30:e5:24: + 74:38:01:89:8f:a9:90:bf:3c:4a:bf:d1:f1:5e:db: + c8:aa:26:59:e6:ec:b3:a0:0f:4d:74:59:dd:c9:27: + 2f:e1:48:7d:30:d9:59:06:2f:29:f0:d1:25:33:79: + 5f:58:9d:d7:54:c8:a7:aa:1a:84:00:a2:85:63:32: + cc:ef:73:7d:b0:26:c6:95:f1:86:16:68:38:63:57: + 09:0d:6f:6a:70:e8:75:3b:72:b4:b1:4d:01:0e:01: + 0e:bf:bf:6a:8c:88:fe:0d:cb:88:43:1b:da:ed:0c: + 88:25:33:f7:b9:b1:fc:32:b8:94:c9:20:7c:ac:49: + e4:c1:58:93:69:0e:41:e3:df:96:e3:47:11:14:8c: + e4:4b:b6:56:df:6f:5e:d2:48:dc:a1:8a:98:cc:4b: + 02:89:95:ea:f6:de:a5:3a:9c:06:7c:f0:7c:09:6f: + 27:11:f2:b1:1b:47:6b:a3:ea:d6:ee:a1:65:91:84: + cf:2e:81:d3:55:4a:e8:01:4e:72:41:ac:92:e0:7d: + 7c:fe:85:f0:2e:f1:ee:4a:80:f9:4e:5a:b4:95:6c: + bb:fe:ff:46:58:4a:7b:fc:a0:63:59:5d:01:5b:63: + 06:5c:94:83:30:27:81:f0:1a:13:89:5a:5a:a2:e2: + 0f:eb + Exponent: 65537 (0x10001) + X509v3 extensions: + X509v3 Basic Constraints: + CA:FALSE + Netscape Comment: + OpenSSL Generated Certificate + X509v3 Subject Key Identifier: + 1B:71:91:99:43:12:0F:D3:59:FC:00:EF:99:F3:42:CF:41:FD:40:1D + X509v3 Authority Key Identifier: + keyid:B7:83:36:F2:A9:24:A9:AE:C8:FB:1A:99:AC:76:01:94:E2:8D:D9:30 + + Signature Algorithm: sha1WithRSAEncryption + a4:cd:88:c3:19:b7:cd:7e:7a:e7:85:1f:fb:3e:31:0b:ff:9d: + 6f:b1:a2:72:56:4a:b1:ec:6c:f3:99:bd:65:08:0a:e9:47:1d: + 79:55:5b:29:b1:d4:85:69:85:65:3f:30:37:a1:0e:76:d2:1f: + b0:76:2a:23:75:c9:05:a4:89:cf:c1:68:42:16:46:d6:c9:a8: + e5:06:5b:52:45:d4:41:5d:f3:c7:00:d1:ca:cc:3e:4c:63:e6: + 7a:fe:ce:20:a4:df:e3:7c:e3:75:6e:f7:18:84:1c:9b:56:ce: + 55:fb:04:b9:de:11:6e:7d:5d:47:de:a9:ed:3e:79:48:a5:4f: + 32:d5:96:8d:ea:e2:a6:8a:c2:e9:f5:b0:8d:da:ef:71:96:60: + b0:7e:c3:3d:e9:37:91:27:bf:ae:5c:e8:c0:9a:6f:c8:38:62: + 90:d0:49:c1:7f:28:13:da:29:bb:5b:d1:72:6f:23:7c:a0:87: + 44:96:47:53:0e:0d:1d:74:d9:26:6b:b3:01:24:9c:5e:c8:f4: + 11:fe:35:14:6c:ec:e7:42:5f:32:56:f0:9d:8d:11:02:21:07: + cc:ce:7b:f0:e9:bc:83:c8:93:b0:8c:a7:e9:b1:c2:12:6b:30: + 2b:75:dc:61:b8:d4:87:6b:07:2d:75:b0:7a:18:6e:19:7f:04: + 78:c6:c7:b7 +-----BEGIN CERTIFICATE----- +MIID4jCCAsqgAwIBAgIJAIgFm03l5AJlMA0GCSqGSIb3DQEBBQUAMHsxCzAJBgNV +BAYTAlhYMRIwEAYDVQQIEwlVbnRydXN0ZWQxEjAQBgNVBAcTCUV2aWx2aWxsZTEU +MBIGA1UEChMLRXZpbCBIYWNrZXIxGjAYBgNVBAsTEUF0dGFjayBEZXBhcnRtZW50 +MRIwEAYDVQQDEwkxMjcuMC4wLjEwIBcNMTYwNDAyMDMzNDUxWhgPMjA1MDA2MjMw +MzM0NTFaMGcxCzAJBgNVBAYTAlhYMRIwEAYDVQQIEwlVbnRydXN0ZWQxFDASBgNV +BAoTC0V2aWwgSGFja2VyMRowGAYDVQQLExFBdHRhY2sgRGVwYXJ0bWVudDESMBAG +A1UEAxMJMTI3LjAuMC4xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA +mnPnRfzTtUq9va0w5SR0OAGJj6mQvzxKv9HxXtvIqiZZ5uyzoA9NdFndyScv4Uh9 +MNlZBi8p8NElM3lfWJ3XVMinqhqEAKKFYzLM73N9sCbGlfGGFmg4Y1cJDW9qcOh1 +O3K0sU0BDgEOv79qjIj+DcuIQxva7QyIJTP3ubH8MriUySB8rEnkwViTaQ5B49+W +40cRFIzkS7ZW329e0kjcoYqYzEsCiZXq9t6lOpwGfPB8CW8nEfKxG0dro+rW7qFl +kYTPLoHTVUroAU5yQayS4H18/oXwLvHuSoD5Tlq0lWy7/v9GWEp7/KBjWV0BW2MG +XJSDMCeB8BoTiVpaouIP6wIDAQABo3sweTAJBgNVHRMEAjAAMCwGCWCGSAGG+EIB +DQQfFh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQUG3GR +mUMSD9NZ/ADvmfNCz0H9QB0wHwYDVR0jBBgwFoAUt4M28qkkqa7I+xqZrHYBlOKN +2TAwDQYJKoZIhvcNAQEFBQADggEBAKTNiMMZt81+eueFH/s+MQv/nW+xonJWSrHs +bPOZvWUICulHHXlVWymx1IVphWU/MDehDnbSH7B2KiN1yQWkic/BaEIWRtbJqOUG +W1JF1EFd88cA0crMPkxj5nr+ziCk3+N843Vu9xiEHJtWzlX7BLneEW59XUfeqe0+ +eUilTzLVlo3q4qaKwun1sI3a73GWYLB+wz3pN5Env65c6MCab8g4YpDQScF/KBPa +Kbtb0XJvI3ygh0SWR1MODR102SZrswEknF7I9BH+NRRs7OdCXzJW8J2NEQIhB8zO +e/DpvIPIk7CMp+mxwhJrMCt13GG41IdrBy11sHoYbhl/BHjGx7c= +-----END CERTIFICATE----- diff --git a/lib/vendor/redis/test/support/ssl/untrusted-cert.key b/lib/vendor/redis/test/support/ssl/untrusted-cert.key new file mode 100644 index 0000000..a52934a --- /dev/null +++ b/lib/vendor/redis/test/support/ssl/untrusted-cert.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCac+dF/NO1Sr29 +rTDlJHQ4AYmPqZC/PEq/0fFe28iqJlnm7LOgD010Wd3JJy/hSH0w2VkGLynw0SUz +eV9YnddUyKeqGoQAooVjMszvc32wJsaV8YYWaDhjVwkNb2pw6HU7crSxTQEOAQ6/ +v2qMiP4Ny4hDG9rtDIglM/e5sfwyuJTJIHysSeTBWJNpDkHj35bjRxEUjORLtlbf +b17SSNyhipjMSwKJler23qU6nAZ88HwJbycR8rEbR2uj6tbuoWWRhM8ugdNVSugB +TnJBrJLgfXz+hfAu8e5KgPlOWrSVbLv+/0ZYSnv8oGNZXQFbYwZclIMwJ4HwGhOJ +Wlqi4g/rAgMBAAECggEAPX3fmfGqqAb1u8p0KQZ2bsXN6rBrvHdYmz4OhuGh5nwW +VuXuLc9p2uTcc/VyDpM5pHUkCF5GqGXcFb5Aw5sz28F3XzXnUAlkabYT+VFVvQfz +EEd0Rv9/U62XIQ42pnUmF2D3p48s2FJ7eMPQu9reqsdZnL4+TxoqKgWinv/JlLdh +zBxjgVgaDMsvVc4cuuT6bcI3DUe2F9ALBKfaCxZoOUSsmgieuXog00Bzv0NmZoUD +WsAX0syzUlwjVmCr8J4I0IByYAbn1S/ozU141Z+H+VUyuEpYw0zDqDNrlmdYclc8 +neoq8Xj9Cx1zHdF5H3aT9SLUGxdHPJpED9wQNx2toQKBgQDJcgJEG39u3h3mW/At +f8jl8evar5nUOOn5AIxVGFAWx4ZvoboxHSRlS6UkF0AImlH4L7xQESb9BMzOrObN +PBNQrccH+fz1o1fHDhob7EvyMMwzmDCPpQnN/6KXRzapu2MDFvlMkEMITTN7J0En +c9BOxo06Q4DKXGVCiWmbIwXihQKBgQDER/KfaWRZWOA2mQ26giJVjUX4+s1GeQM0 +V4AIo1KS6fDzh68RsAQpMTx/N8aHEcxf+2qGIOTCvFY3Nxqe5aw/Xiz47MPlYulM +OecovSO96nidhyv2Zux+HpvI85tcWTyORi+RWho51gTOLth6BJ4uvSsaooWmO0Va +GoIxKcaLrwKBgH/guuWHWy8DG5H3fRE1FFA8cc+iN5HMC2NBYNRIGddME+BblznE +WS1ghtXRWJnddPmLPAzLxqdJ28W7ZsyUPWKy3i0HGfjJF1jKb/KX32JAbfC2xOT7 +DK1TgWBtGZtH1EPK2rkqvxLPB0Y/lhG4aF0Jl++LmH9dhf5mAr8zzXGNAoGBAKEi +l7H66aDX76mi2LxmnR0yz2DpNKBINDNCKh/tRJrLZz3mA/k3URMoEow2E8tK90dM +tVTLqEGeMAFAQaB02IVlIPJyHRgxrWkgl/6/15nP5ZkdISA1uqyHIElGhCK6N5Zt +VBu1ppYYdvV1S85QADRKpBpHlgSz3+lqnbsSmqaNAoGAacA3XSIzTHj6+06VzEHN +aO2LJbBxl6Eduj6eTEgcZBlQOX6cVvaleTAT2g2xM0aGMV4StmdijUdktjBQVLpH +8PBTqlfVuLXEXQd+qWMpUJwEkh/pdmf9EPoLSfp3zQLaNI/kCg3jQtR4n6/68hfi +5Q6L0mN+SoB+jRNPDSV7JWA= +-----END PRIVATE KEY----- diff --git a/lib/vendor/redis/test/support/wire/synchrony.rb b/lib/vendor/redis/test/support/wire/synchrony.rb new file mode 100644 index 0000000..f27d448 --- /dev/null +++ b/lib/vendor/redis/test/support/wire/synchrony.rb @@ -0,0 +1,24 @@ +class Wire < Fiber + # We cannot run this fiber explicitly because EM schedules it. Resuming the + # current fiber on the next tick to let the reactor do work. + def self.pass + f = Fiber.current + EM.next_tick { f.resume } + Fiber.yield + end + + def self.sleep(sec) + EM::Synchrony.sleep(sec) + end + + def initialize(&blk) + super + + # Schedule run in next tick + EM.next_tick { resume } + end + + def join + self.class.pass while alive? + end +end diff --git a/lib/vendor/redis/test/support/wire/thread.rb b/lib/vendor/redis/test/support/wire/thread.rb new file mode 100644 index 0000000..aa5a67c --- /dev/null +++ b/lib/vendor/redis/test/support/wire/thread.rb @@ -0,0 +1,5 @@ +class Wire < Thread + def self.sleep(sec) + Kernel.sleep(sec) + end +end diff --git a/lib/vendor/redis/test/synchrony_driver.rb b/lib/vendor/redis/test/synchrony_driver.rb new file mode 100644 index 0000000..82b13a7 --- /dev/null +++ b/lib/vendor/redis/test/synchrony_driver.rb @@ -0,0 +1,88 @@ +# encoding: UTF-8 + +require 'em-synchrony' +require 'em-synchrony/connection_pool' + +require 'redis' +require 'redis/connection/synchrony' + + +require File.expand_path("./helper", File.dirname(__FILE__)) + +PORT = 6381 +OPTIONS = {:port => PORT, :db => 15} + +# +# if running under Eventmachine + Synchrony (Ruby 1.9+), then +# we can simulate the blocking API while performing the network +# IO via the EM reactor. +# + +EM.synchrony do + r = Redis.new OPTIONS + r.flushdb + + r.rpush "foo", "s1" + r.rpush "foo", "s2" + + assert_equal 2, r.llen("foo") + assert_equal "s2", r.rpop("foo") + + r.set("foo", "bar") + + assert_equal "bar", r.getset("foo", "baz") + assert_equal "baz", r.get("foo") + + r.set("foo", "a") + + assert_equal 1, r.getbit("foo", 1) + assert_equal 1, r.getbit("foo", 2) + assert_equal 0, r.getbit("foo", 3) + assert_equal 0, r.getbit("foo", 4) + assert_equal 0, r.getbit("foo", 5) + assert_equal 0, r.getbit("foo", 6) + assert_equal 1, r.getbit("foo", 7) + + r.flushdb + + # command pipelining + r.pipelined do + r.lpush "foo", "s1" + r.lpush "foo", "s2" + end + + assert_equal 2, r.llen("foo") + assert_equal "s2", r.lpop("foo") + assert_equal "s1", r.lpop("foo") + + assert_equal "OK", r.client.call(:quit) + assert_equal "PONG", r.ping + + + rpool = EM::Synchrony::ConnectionPool.new(size: 5) { Redis.new OPTIONS } + + result = rpool.watch 'foo' do |rd| + assert_kind_of Redis, rd + + rd.set "foo", "s1" + rd.multi do |multi| + multi.set "foo", "s2" + end + end + + assert_equal nil, result + assert_equal "s1", rpool.get("foo") + + result = rpool.watch "foo" do |rd| + assert_kind_of Redis, rd + + rd.multi do |multi| + multi.set "foo", "s3" + end + end + + assert_equal ["OK"], result + assert_equal "s3", rpool.get("foo") + + EM.stop +end diff --git a/lib/vendor/redis/test/test.conf.erb b/lib/vendor/redis/test/test.conf.erb new file mode 100644 index 0000000..051cb80 --- /dev/null +++ b/lib/vendor/redis/test/test.conf.erb @@ -0,0 +1,9 @@ +dir <%= REDIS_DIR %> +pidfile <%= REDIS_PID %> +port 6381 +unixsocket <%= REDIS_SOCKET %> +timeout 300 +loglevel debug +logfile <%= REDIS_LOG %> +databases 16 +daemonize yes diff --git a/lib/vendor/redis/test/thread_safety_test.rb b/lib/vendor/redis/test/thread_safety_test.rb new file mode 100644 index 0000000..f03ad77 --- /dev/null +++ b/lib/vendor/redis/test/thread_safety_test.rb @@ -0,0 +1,62 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestThreadSafety < Test::Unit::TestCase + + include Helper::Client + + driver(:ruby, :hiredis) do + def test_thread_safety + redis = Redis.new(OPTIONS) + redis.set "foo", 1 + redis.set "bar", 2 + + sample = 100 + + t1 = Thread.new do + $foos = Array.new(sample) { redis.get "foo" } + end + + t2 = Thread.new do + $bars = Array.new(sample) { redis.get "bar" } + end + + t1.join + t2.join + + assert_equal ["1"], $foos.uniq + assert_equal ["2"], $bars.uniq + end + + def test_thread_safety_queue_commit + redis = Redis.new(OPTIONS) + redis.set "foo", 1 + redis.set "bar", 2 + + sample = 100 + + t1 = Thread.new do + sample.times do + r.queue("get", "foo") + end + + $foos = r.commit + end + + t2 = Thread.new do + sample.times do + r.queue("get", "bar") + end + + $bars = r.commit + end + + t1.join + t2.join + + assert_equal ["1"], $foos.uniq + assert_equal ["2"], $bars.uniq + end + end +end diff --git a/lib/vendor/redis/test/transactions_test.rb b/lib/vendor/redis/test/transactions_test.rb new file mode 100644 index 0000000..3f588b2 --- /dev/null +++ b/lib/vendor/redis/test/transactions_test.rb @@ -0,0 +1,264 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestTransactions < Test::Unit::TestCase + + include Helper::Client + + def test_multi_discard + r.multi + + assert_equal "QUEUED", r.set("foo", "1") + assert_equal "QUEUED", r.get("foo") + + r.discard + + assert_equal nil, r.get("foo") + end + + def test_multi_exec_with_a_block + r.multi do |multi| + multi.set "foo", "s1" + end + + assert_equal "s1", r.get("foo") + end + + def test_multi_exec_with_a_block_doesn_t_return_replies_for_multi_and_exec + r1, r2, nothing_else = r.multi do |multi| + multi.set "foo", "s1" + multi.get "foo" + end + + assert_equal "OK", r1 + assert_equal "s1", r2 + assert_equal nil, nothing_else + end + + def test_assignment_inside_multi_exec_block + r.multi do |m| + @first = m.sadd("foo", 1) + @second = m.sadd("foo", 1) + end + + assert_equal true, @first.value + assert_equal false, @second.value + end + + # Although we could support accessing the values in these futures, + # it doesn't make a lot of sense. + def test_assignment_inside_multi_exec_block_with_delayed_command_errors + assert_raise(Redis::CommandError) do + r.multi do |m| + @first = m.set("foo", "s1") + @second = m.incr("foo") # not an integer + @third = m.lpush("foo", "value") # wrong kind of value + end + end + + assert_equal "OK", @first.value + assert_raise(Redis::CommandError) { @second.value } + assert_raise(Redis::FutureNotReady) { @third.value } + end + + def test_assignment_inside_multi_exec_block_with_immediate_command_errors + assert_raise(Redis::CommandError) do + r.multi do |m| + m.doesnt_exist + @first = m.sadd("foo", 1) + @second = m.sadd("foo", 1) + end + end + + assert_raise(Redis::FutureNotReady) { @first.value } + assert_raise(Redis::FutureNotReady) { @second.value } + end + + def test_raise_immediate_errors_in_multi_exec + assert_raise(RuntimeError) do + r.multi do |multi| + multi.set "bar", "s2" + raise "Some error" + multi.set "baz", "s3" + end + end + + assert_equal nil, r.get("bar") + assert_equal nil, r.get("baz") + end + + def test_transformed_replies_as_return_values_for_multi_exec_block + info, _ = r.multi do |m| + r.info + end + + assert info.kind_of?(Hash) + end + + def test_transformed_replies_inside_multi_exec_block + r.multi do |m| + @info = r.info + end + + assert @info.value.kind_of?(Hash) + end + + def test_raise_command_errors_in_multi_exec + assert_raise(Redis::CommandError) do + r.multi do |m| + m.set("foo", "s1") + m.incr("foo") # not an integer + m.lpush("foo", "value") # wrong kind of value + end + end + + assert_equal "s1", r.get("foo") + end + + def test_raise_command_errors_when_accessing_futures_after_multi_exec + begin + r.multi do |m| + m.set("foo", "s1") + @counter = m.incr("foo") # not an integer + end + rescue Exception + # Not gonna deal with it + end + + # We should test for Redis::Error here, but hiredis doesn't yet do + # custom error classes. + err = nil + begin + @counter.value + rescue => err + end + + assert err.kind_of?(RuntimeError) + end + + def test_multi_with_a_block_yielding_the_client + r.multi do |multi| + multi.set "foo", "s1" + end + + assert_equal "s1", r.get("foo") + end + + def test_raise_command_error_when_exec_fails + redis_mock(:exec => lambda { |*_| "-ERROR" }) do |redis| + assert_raise(Redis::CommandError) do + redis.multi do |m| + m.set "foo", "s1" + end + end + end + end + + def test_watch + res = r.watch "foo" + + assert_equal "OK", res + end + + def test_watch_with_an_unmodified_key + r.watch "foo" + r.multi do |multi| + multi.set "foo", "s1" + end + + assert_equal "s1", r.get("foo") + end + + def test_watch_with_an_unmodified_key_passed_as_array + r.watch ["foo", "bar"] + r.multi do |multi| + multi.set "foo", "s1" + end + + assert_equal "s1", r.get("foo") + end + + def test_watch_with_a_modified_key + r.watch "foo" + r.set "foo", "s1" + res = r.multi do |multi| + multi.set "foo", "s2" + end + + assert_equal nil, res + assert_equal "s1", r.get("foo") + end + + def test_watch_with_a_modified_key_passed_as_array + r.watch ["foo", "bar"] + r.set "foo", "s1" + res = r.multi do |multi| + multi.set "foo", "s2" + end + + assert_equal nil, res + assert_equal "s1", r.get("foo") + end + + def test_watch_with_a_block_and_an_unmodified_key + result = r.watch "foo" do |rd| + + assert_same r, rd + + rd.multi do |multi| + multi.set "foo", "s1" + end + end + + assert_equal ["OK"], result + assert_equal "s1", r.get("foo") + end + + def test_watch_with_a_block_and_a_modified_key + result = r.watch "foo" do |rd| + + assert_same r, rd + + rd.set "foo", "s1" + rd.multi do |multi| + multi.set "foo", "s2" + end + end + + assert_equal nil, result + assert_equal "s1", r.get("foo") + end + + def test_watch_with_a_block_that_raises_an_exception + r.set("foo", "s1") + + begin + r.watch "foo" do + raise "test" + end + rescue RuntimeError + end + + r.set("foo", "s2") + + # If the watch was still set from within the block above, this multi/exec + # would fail. This proves that raising an exception above unwatches. + r.multi do |multi| + multi.set "foo", "s3" + end + + assert_equal "s3", r.get("foo") + end + + def test_unwatch_with_a_modified_key + r.watch "foo" + r.set "foo", "s1" + r.unwatch + r.multi do |multi| + multi.set "foo", "s2" + end + + assert_equal "s2", r.get("foo") + end +end diff --git a/lib/vendor/redis/test/unknown_commands_test.rb b/lib/vendor/redis/test/unknown_commands_test.rb new file mode 100644 index 0000000..0d1ca58 --- /dev/null +++ b/lib/vendor/redis/test/unknown_commands_test.rb @@ -0,0 +1,14 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestUnknownCommands < Test::Unit::TestCase + + include Helper::Client + + def test_should_try_to_work + assert_raise Redis::CommandError do + r.not_yet_implemented_command + end + end +end diff --git a/lib/vendor/redis/test/url_param_test.rb b/lib/vendor/redis/test/url_param_test.rb new file mode 100644 index 0000000..468bbf1 --- /dev/null +++ b/lib/vendor/redis/test/url_param_test.rb @@ -0,0 +1,138 @@ +# encoding: UTF-8 + +require File.expand_path("helper", File.dirname(__FILE__)) + +class TestUrlParam < Test::Unit::TestCase + + include Helper::Client + + def test_url_defaults_to_______________ + redis = Redis.new + + assert_equal "127.0.0.1", redis.client.host + assert_equal 6379, redis.client.port + assert_equal 0, redis.client.db + assert_equal nil, redis.client.password + end + + def test_allows_to_pass_in_a_url + redis = Redis.new :url => "redis://:secr3t@foo.com:999/2" + + assert_equal "foo.com", redis.client.host + assert_equal 999, redis.client.port + assert_equal 2, redis.client.db + assert_equal "secr3t", redis.client.password + end + + def test_allows_to_pass_in_a_url_with_string_key + redis = Redis.new "url" => "redis://:secr3t@foo.com:999/2" + + assert_equal "foo.com", redis.client.host + assert_equal 999, redis.client.port + assert_equal 2, redis.client.db + assert_equal "secr3t", redis.client.password + end + + def test_unescape_password_from_url + redis = Redis.new :url => "redis://:secr3t%3A@foo.com:999/2" + + assert_equal "secr3t:", redis.client.password + end + + def test_unescape_password_from_url_with_string_key + redis = Redis.new "url" => "redis://:secr3t%3A@foo.com:999/2" + + assert_equal "secr3t:", redis.client.password + end + + def test_does_not_unescape_password_when_explicitly_passed + redis = Redis.new :url => "redis://:secr3t%3A@foo.com:999/2", :password => "secr3t%3A" + + assert_equal "secr3t%3A", redis.client.password + end + + def test_does_not_unescape_password_when_explicitly_passed_with_string_key + redis = Redis.new :url => "redis://:secr3t%3A@foo.com:999/2", "password" => "secr3t%3A" + + assert_equal "secr3t%3A", redis.client.password + end + + def test_override_url_if_path_option_is_passed + redis = Redis.new :url => "redis://:secr3t@foo.com/foo:999/2", :path => "/tmp/redis.sock" + + assert_equal "/tmp/redis.sock", redis.client.path + assert_equal nil, redis.client.host + assert_equal nil, redis.client.port + end + + def test_override_url_if_path_option_is_passed_with_string_key + redis = Redis.new :url => "redis://:secr3t@foo.com/foo:999/2", "path" => "/tmp/redis.sock" + + assert_equal "/tmp/redis.sock", redis.client.path + assert_equal nil, redis.client.host + assert_equal nil, redis.client.port + end + + def test_overrides_url_if_another_connection_option_is_passed + redis = Redis.new :url => "redis://:secr3t@foo.com:999/2", :port => 1000 + + assert_equal "foo.com", redis.client.host + assert_equal 1000, redis.client.port + assert_equal 2, redis.client.db + assert_equal "secr3t", redis.client.password + end + + def test_overrides_url_if_another_connection_option_is_passed_with_string_key + redis = Redis.new :url => "redis://:secr3t@foo.com:999/2", "port" => 1000 + + assert_equal "foo.com", redis.client.host + assert_equal 1000, redis.client.port + assert_equal 2, redis.client.db + assert_equal "secr3t", redis.client.password + end + + def test_does_not_overrides_url_if_a_nil_option_is_passed + redis = Redis.new :url => "redis://:secr3t@foo.com:999/2", :port => nil + + assert_equal "foo.com", redis.client.host + assert_equal 999, redis.client.port + assert_equal 2, redis.client.db + assert_equal "secr3t", redis.client.password + end + + def test_does_not_overrides_url_if_a_nil_option_is_passed_with_string_key + redis = Redis.new :url => "redis://:secr3t@foo.com:999/2", "port" => nil + + assert_equal "foo.com", redis.client.host + assert_equal 999, redis.client.port + assert_equal 2, redis.client.db + assert_equal "secr3t", redis.client.password + end + + def test_does_not_modify_the_passed_options + options = { :url => "redis://:secr3t@foo.com:999/2" } + + Redis.new(options) + + assert({ :url => "redis://:secr3t@foo.com:999/2" } == options) + end + + def test_uses_redis_url_over_default_if_available + ENV["REDIS_URL"] = "redis://:secr3t@foo.com:999/2" + + redis = Redis.new + + assert_equal "foo.com", redis.client.host + assert_equal 999, redis.client.port + assert_equal 2, redis.client.db + assert_equal "secr3t", redis.client.password + + ENV.delete("REDIS_URL") + end + + def test_defaults_to_localhost + redis = Redis.new(:url => "redis:///") + + assert_equal "127.0.0.1", redis.client.host + end +end diff --git a/support/vendor-gem.rb b/support/vendor-gem.rb new file mode 100755 index 0000000..4115a56 --- /dev/null +++ b/support/vendor-gem.rb @@ -0,0 +1,38 @@ +#!/usr/bin/env ruby +require 'fileutils' +require 'open3' + +VENDOR_PREFIX = 'lib/vendor' + +def main(gem, version, vendor_dir) + if !vendor_dir.start_with?(VENDOR_PREFIX) + abort "Invalid vendor_dir: must start with #{VENDOR_PREFIX}: #{vendor_dir.inspect}" + end + + FileUtils.rm_rf(vendor_dir) + + # Use clear-sources to force https://rubygems.org as the source + if !system(*%W[gem fetch #{gem} -v #{version} --clear-sources -s https://rubygems.org]) + abort "Failed to fetch gem" + end + + FileUtils.mkdir_p(vendor_dir) + + # A .gem file is a tar file containing a data.tar.gz file. + statuses = Open3.pipeline( + %W[tar -xOf - data.tar.gz], + %W[tar -zxf -], + in: "#{gem}-#{version}.gem", + chdir: vendor_dir + ) + + if !statuses.all?(&:success?) + abort "Failed to extract gem" + end +end + +if ARGV.count != 3 + abort "Usage: #{$PROGNAME} GEM VERSION VENDOR_DIR" +end + +main(*ARGV) |