redis 3.2.1 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1245d9a408be7cfa9f796b5b02e6f2dcaff10f2a
-  data.tar.gz: 2dce33db07a7a16dcade71b081996f241d2075ab
+  metadata.gz: 183e90b7d3961182b8b5b20b1295b6dd9d30df12
+  data.tar.gz: 60023071a61af0e34d85b0a999db0bc5877070ad
 SHA512:
-  metadata.gz: ef3734d43bbd4fb5f50fbef3d9b3348d382c9389433a8af91e9d94410b818b3eaa8d306b827e91aafaa26fa28aa461f9c028293280c6df48bf5d28412554140a
-  data.tar.gz: cc7122626f5587a8a750746acfb59d7462fb426cd68234ee141805e77b5bbfb39736543f71fc26575ef5bd1bd6dce3b7eb2b8857408461cf4f9ac2e4f2d05c78
+  metadata.gz: a1d93f8ee26f3dfecb10d223d178e4f78aa399d3bc8a78a4db479f0e6d89bd77c97d9e113b0138d102fbecf3d0a4452ce5f0da9412e069726c3b1fd7bb7bf7a4
+  data.tar.gz: 1a2077544497d0f2a1cd9035677dc1d514a9395b070b10f380e8fcc35cbbbbbae898e1b4ad3e7ff44e2fb96930330cb66b021ccaa726451c2c15276ff26b0011

data/.travis.yml

@@ -3,9 +3,12 @@ language: ruby
 rvm:
   - 1.8.7
   - 1.9.3
+  - 2.0
   - 2.1
+  - 2.2
   - jruby-18mode
   - jruby-19mode
+  - rbx-2
 
 gemfile: ".travis/Gemfile"
 
@@ -45,6 +48,8 @@ matrix:
     - rvm: jruby-19mode
       gemfile: .travis/Gemfile
       env: conn=synchrony REDIS_BRANCH=2.8
+  allow_failures:
+    - rvm: rbx-2
 
 notifications:
   irc:

data/CHANGELOG.md

@@ -12,6 +12,17 @@
   security updates in June of 2013; continuing to support it would prevent
   the use of newer features of Ruby.
 
+# 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.

data/README.md

@@ -23,6 +23,20 @@ most important changes, as well as a full list of changes.
 
 ## 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.
@@ -43,12 +57,14 @@ server or a different port, try:
 redis = Redis.new(:host => "10.0.1.1", :port => 6380, :db => 15)
 ```
 
-You can also specify connection options as an URL:
+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.
@@ -298,7 +314,7 @@ all contributors)
 * Matthew Clark
 * Brian McKinney
 * Luca Guidi
-* Salvatore Sanfillipo
+* Salvatore Sanfilippo
 * Chris Wanstrath
 * Damian Janowski
 * Michel Martens

data/examples/unicorn/unicorn.rb

@@ -16,5 +16,5 @@ worker_processes 3
 # worker processes.
 
 after_fork do |server, worker|
-  Redis.current.quit
+  Redis.current.disconnect!
 end

data/lib/redis.rb

@@ -26,6 +26,26 @@ class Redis
 
   include MonitorMixin
 
+  # Create a new client instance
+  #
+  # @param [Hash] options
+  # @option options [String] :url (value of the environment variable REDIS_URL) a Redis URL, for a TCP connection: `redis://:[password]@[hostname]:[port]/[db]` (password, port and database are optional), for a unix socket connection: `unix://[path to Redis socket]`. This overrides all other options.
+  # @option options [String] :host ("127.0.0.1") server hostname
+  # @option options [Fixnum] :port (6379) server port
+  # @option options [String] :path path to server socket (overrides host and port)
+  # @option options [Float] :timeout (5.0) timeout in seconds
+  # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
+  # @option options [String] :password Password to authenticate against server
+  # @option options [Fixnum] :db (0) Database to select after initial connect
+  # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`, `:synchrony`
+  # @option options [String] :id ID for the client connection, assigns name to current connection by sending `CLIENT SETNAME`
+  # @option options [Hash, Fixnum] :tcp_keepalive Keepalive values, if Fixnum `intvl` and `probe` are calculated based on the value, if Hash `time`, `intvl` and `probes` can be specified as a Fixnum
+  # @option options [Fixnum] :reconnect_attempts Number of attempts trying to connect
+  # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
+  # @option options [Array] :sentinels List of sentinels to contact
+  # @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave`
+  #
+  # @return [Redis] a new client instance
   def initialize(options = {})
     @options = options.dup
     @original_client = @client = Client.new(options)
@@ -329,8 +349,15 @@ class Redis
   # Get the time to live (in seconds) for a key.
   #
   # @param [String] key
-  # @return [Fixnum] remaining time to live in seconds, or -1 if the
-  #   key does not exist or does not have a timeout
+  # @return [Fixnum] remaining time to live in seconds.
+  #
+  # In Redis 2.6 or older the command returns -1 if the key does not exist or if
+  # the key exist but has no associated expire.
+  #
+  # Starting with Redis 2.8 the return value in case of error changed:
+  #
+  #     - The command returns -2 if the key does not exist.
+  #     - The command returns -1 if the key exists but has no associated expire.
   def ttl(key)
     synchronize do |client|
       client.call([:ttl, key])
@@ -362,8 +389,14 @@ class Redis
   # Get the time to live (in milliseconds) for a key.
   #
   # @param [String] key
-  # @return [Fixnum] remaining time to live in milliseconds, or -1 if the
-  #   key does not exist or does not have a timeout
+  # @return [Fixnum] remaining time to live in milliseconds
+  # In Redis 2.6 or older the command returns -1 if the key does not exist or if
+  # the key exist but has no associated expire.
+  #
+  # Starting with Redis 2.8 the return value in case of error changed:
+  #
+  #     - The command returns -2 if the key does not exist.
+  #     - The command returns -1 if the key exists but has no associated expire.
   def pttl(key)
     synchronize do |client|
       client.call([:pttl, key])
@@ -385,7 +418,7 @@ class Redis
   # @param [String] key
   # @param [String] ttl
   # @param [String] serialized_value
-  # @return `"OK"`
+  # @return [String] `"OK"`
   def restore(key, ttl, serialized_value)
     synchronize do |client|
       client.call([:restore, key, ttl, serialized_value])
@@ -690,7 +723,7 @@ class Redis
   # @param [String] key
   # @param [Fixnum] ttl
   # @param [String] value
-  # @return `"OK"`
+  # @return [String] `"OK"`
   def setex(key, ttl, value)
     synchronize do |client|
       client.call([:setex, key, ttl, value.to_s])
@@ -702,7 +735,7 @@ class Redis
   # @param [String] key
   # @param [Fixnum] ttl
   # @param [String] value
-  # @return `"OK"`
+  # @return [String] `"OK"`
   def psetex(key, ttl, value)
     synchronize do |client|
       client.call([:psetex, key, ttl, value.to_s])
@@ -727,7 +760,7 @@ class Redis
   #     # => "OK"
   #
   # @param [Array<String>] args array of keys and values
-  # @return `"OK"`
+  # @return [String] `"OK"`
   #
   # @see #mapped_mset
   def mset(*args)
@@ -743,7 +776,7 @@ class Redis
   #     # => "OK"
   #
   # @param [Hash] hash keys mapping to values
-  # @return `"OK"`
+  # @return [String] `"OK"`
   #
   # @see #mset
   def mapped_mset(hash)
@@ -968,7 +1001,7 @@ class Redis
   # Prepend one or more values to a list, creating the list if it doesn't exist
   #
   # @param [String] key
-  # @param [String, Array] string value, or array of string values to push
+  # @param [String, Array] value string value, or array of string values to push
   # @return [Fixnum] the length of the list after the push operation
   def lpush(key, value)
     synchronize do |client|
@@ -1410,20 +1443,50 @@ class Redis
   # @param [[Float, String], Array<[Float, String]>] args
   #   - a single `[score, member]` pair
   #   - an array of `[score, member]` pairs
-  #
-  # @return [Boolean, Fixnum]
+  # @param [Hash] options
+  #   - `:xx => true`: Only update elements that already exist (never
+  #   add elements)
+  #   - `:nx => true`: Don't update already existing elements (always
+  #   add new elements)
+  #   - `:ch => true`: Modify the return value from the number of new
+  #   elements added, to the total number of elements changed (CH is an
+  #   abbreviation of changed); changed elements are new elements added
+  #   and elements already existing for which the score was updated
+  #   - `:incr => true`: When this option is specified ZADD acts like
+  #   ZINCRBY; only one score-element pair can be specified in this mode
+  #
+  # @return [Boolean, Fixnum, Float]
   #   - `Boolean` when a single pair is specified, holding whether or not it was
-  #   **added** to the sorted set
+  #   **added** to the sorted set.
   #   - `Fixnum` when an array of pairs is specified, holding the number of
-  #   pairs that were **added** to the sorted set
-  def zadd(key, *args)
+  #   pairs that were **added** to the sorted set.
+  #   - `Float` when option :incr is specified, holding the score of the member
+  #   after incrementing it.
+  def zadd(key, *args) #, options
+    zadd_options = []
+    if args.last.is_a?(Hash)
+      options = args.pop
+
+      nx = options[:nx]
+      zadd_options << "NX" if nx
+
+      xx = options[:xx]
+      zadd_options << "XX" if xx
+
+      ch = options[:ch]
+      zadd_options << "CH" if ch
+
+      incr = options[:incr]
+      zadd_options << "INCR" if incr
+    end
+
     synchronize do |client|
       if args.size == 1 && args[0].is_a?(Array)
-        # Variadic: return integer
-        client.call([:zadd, key] + args[0])
+        # Variadic: return float if INCR, integer if !INCR
+        client.call([:zadd, key] + zadd_options + args[0], &(incr ? _floatify : _identity))
       elsif args.size == 2
-        # Single pair: return boolean
-        client.call([:zadd, key, args[0], args[1]], &_boolify)
+        # Single pair: return float if INCR, boolean if !INCR
+        client.call([:zadd, key] + zadd_options + args, &(incr ? _floatify : _boolify))
       else
         raise ArgumentError, "wrong number of arguments"
       end
@@ -1867,7 +1930,7 @@ class Redis
   #
   # @param [String] key
   # @param [Array<String>] attrs array of fields and values
-  # @return `"OK"`
+  # @return [String] `"OK"`
   #
   # @see #mapped_hmset
   def hmset(key, *attrs)
@@ -1883,8 +1946,8 @@ class Redis
   #     # => "OK"
   #
   # @param [String] key
-  # @param [Hash] a non-empty hash with fields mapping to values
-  # @return `"OK"`
+  # @param [Hash] hash a non-empty hash with fields mapping to values
+  # @return [String] `"OK"`
   #
   # @see #hmset
   def mapped_hmset(key, hash)
@@ -2207,7 +2270,7 @@ class Redis
   #
   # Only call this method when `#multi` was called **without** a block.
   #
-  # @return `"OK"`
+  # @return [String] `"OK"`
   #
   # @see #multi
   # @see #exec
@@ -2355,7 +2418,7 @@ class Redis
   #   redis.scan(4, :match => "key:1?")
   #     # => ["92", ["key:13", "key:18"]]
   #
-  # @param [String, Integer] cursor: the cursor of the iteration
+  # @param [String, Integer] cursor the cursor of the iteration
   # @param [Hash] options
   #   - `:match => String`: only return keys matching the pattern
   #   - `:count => Integer`: return count keys at most per iteration
@@ -2395,7 +2458,7 @@ class Redis
   # @example Retrieve the first batch of key/value pairs in a hash
   #   redis.hscan("hash", 0)
   #
-  # @param [String, Integer] cursor: the cursor of the iteration
+  # @param [String, Integer] cursor the cursor of the iteration
   # @param [Hash] options
   #   - `:match => String`: only return keys matching the pattern
   #   - `:count => Integer`: return count keys at most per iteration
@@ -2433,7 +2496,7 @@ class Redis
   # @example Retrieve the first batch of key/value pairs in a hash
   #   redis.zscan("zset", 0)
   #
-  # @param [String, Integer] cursor: the cursor of the iteration
+  # @param [String, Integer] cursor the cursor of the iteration
   # @param [Hash] options
   #   - `:match => String`: only return keys matching the pattern
   #   - `:count => Integer`: return count keys at most per iteration
@@ -2472,7 +2535,7 @@ class Redis
   # @example Retrieve the first batch of keys in a set
   #   redis.sscan("set", 0)
   #
-  # @param [String, Integer] cursor: the cursor of the iteration
+  # @param [String, Integer] cursor the cursor of the iteration
   # @param [Hash] options
   #   - `:match => String`: only return keys matching the pattern
   #   - `:count => Integer`: return count keys at most per iteration
@@ -2539,6 +2602,33 @@ class Redis
     end
   end
 
+  # Interact with the sentinel command (masters, master, slaves, failover)
+  #
+  # @param [String] subcommand e.g. `masters`, `master`, `slaves`
+  # @param [Array<String>] args depends on subcommand
+  # @return [Array<String>, Hash<String, String>, String] depends on subcommand
+  def sentinel(subcommand, *args)
+    subcommand = subcommand.to_s.downcase
+    synchronize do |client|
+      client.call([:sentinel, subcommand] + args) do |reply|
+        case subcommand
+        when "get-master-addr-by-name"
+          reply
+        else
+          if reply.kind_of?(Array)
+            if reply[0].kind_of?(Array)
+              reply.map(&_hashify)
+            else
+              _hashify.call(reply)
+            end
+          else
+            reply
+          end
+        end
+      end
+    end
+  end
+
   def id
     @original_client.id
   end
@@ -2614,6 +2704,12 @@ private
     array.each_slice(2).to_a
   end
 
+  def _identity
+    lambda { |value|
+      value
+    }
+  end
+
   def _subscription(method, channels, block)
     return @client.call([method] + channels) if subscribed?
 

data/lib/redis/client.rb

@@ -94,6 +94,7 @@ class Redis
         establish_connection
         call [:auth, password] if password
         call [:select, db] if db != 0
+        call [:client, :setname, @options[:id]] if @options[:id]
         @connector.check(self)
       end
 
@@ -392,11 +393,8 @@ class Redis
         if uri.scheme == "unix"
           defaults[:path]   = uri.path
         elsif uri.scheme == "redis"
-          # Require the URL to have at least a host
-          raise ArgumentError, "invalid url: #{uri}" unless uri.host
-
           defaults[:scheme]   = uri.scheme
-          defaults[:host]     = uri.host
+          defaults[:host]     = uri.host if uri.host
           defaults[:port]     = uri.port if uri.port
           defaults[:password] = CGI.unescape(uri.password) if uri.password
           defaults[:db]       = uri.path[1..-1].to_i if uri.path

data/lib/redis/hash_ring.rb

@@ -25,6 +25,7 @@ class Redis
       @nodes << node
       @replicas.times do |i|
         key = Zlib.crc32("#{node.id}:#{i}")
+        raise "Node ID collision" if @ring.has_key?(key)
         @ring[key] = node
         @sorted_keys << key
       end

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.2.1"
+  VERSION = "3.2.2"
 end

data/redis.gemspec

@@ -40,4 +40,5 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 
   s.add_development_dependency("rake")
+  s.add_development_dependency("test-unit")
 end

data/test/connection_handling_test.rb

@@ -17,6 +17,19 @@ class TestConnectionHandling < Test::Unit::TestCase
     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

data/test/distributed_internals_test.rb

@@ -7,16 +7,16 @@ class TestDistributedInternals < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_provides_a_meaningful_inspect
-    nodes = ["redis://127.0.0.1:#{PORT}/15", *NODES]
+    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://127.0.0.1:#{PORT}/15", *NODES]
+    nodes = ["redis://localhost:#{PORT}/15", *NODES]
     redis = Redis::Distributed.new nodes
-    assert_equal ["redis://127.0.0.1:#{PORT}/15", *NODES], redis.nodes.map { |node| node.client.id}
+    assert_equal ["redis://localhost:#{PORT}/15", *NODES], redis.nodes.map { |node| node.client.id}
   end
 
   def test_default_as_config_hashes
@@ -67,4 +67,13 @@ class TestDistributedInternals < Test::Unit::TestCase
 
     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 = Redis::Distributed.new nodes
+    end
+  end
+
 end

data/test/distributed_key_tags_test.rb

@@ -8,9 +8,9 @@ class TestDistributedKeyTags < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_hashes_consistently
-    r1 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
-    r2 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
-    r3 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
+    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

data/test/distributed_test.rb

@@ -7,7 +7,7 @@ class TestDistributed < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_handle_multiple_servers
-    @r = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
+    @r = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
 
     100.times do |idx|
       @r.set(idx.to_s, "foo#{idx}")

data/test/lint/sorted_sets.rb

@@ -9,6 +9,43 @@ module Lint
       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
@@ -31,6 +68,47 @@ module Lint
         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

data/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

data/test/sentinel_test.rb

@@ -24,8 +24,10 @@ class SentinalTest < Test::Unit::TestCase
       }
     end
 
-    RedisMock.start(handler.call(:s1), {}, 26381) do
-      RedisMock.start(handler.call(:s2), {}, 26382) do
+    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
@@ -59,8 +61,10 @@ class SentinalTest < Test::Unit::TestCase
       end
     }
 
-    RedisMock.start(s1, {}, 26381) do
-      RedisMock.start(s2, {}, 26382) do
+    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
@@ -94,8 +98,10 @@ class SentinalTest < Test::Unit::TestCase
       end
     }
 
-    RedisMock.start(s1, {}, 26381) do
-      RedisMock.start(s2, {}, 26382) do
+    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
@@ -118,20 +124,22 @@ class SentinalTest < Test::Unit::TestCase
       :m1 => []
     }
 
-    sentinel = {
-      :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", "6382"]
-      end
-    }
+    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|
@@ -144,8 +152,9 @@ class SentinalTest < Test::Unit::TestCase
       end
     }
 
-    RedisMock.start(master, {}, 6382) do
-      RedisMock.start(sentinel, {}, 26381) 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://:foo@master1/15", :sentinels => sentinels, :role => :master)
 
         assert redis.ping
@@ -159,11 +168,13 @@ class SentinalTest < Test::Unit::TestCase
   def test_sentinel_role_mismatch
     sentinels = [{:host => "127.0.0.1", :port => 26381}]
 
-    sentinel = {
-      :sentinel => lambda do |command, *args|
-        ["127.0.0.1", "6382"]
-      end
-    }
+    sentinel = lambda do |port|
+      {
+        :sentinel => lambda do |command, *args|
+          ["127.0.0.1", port.to_s]
+        end
+      }
+    end
 
     master = {
       :role => lambda do
@@ -172,8 +183,9 @@ class SentinalTest < Test::Unit::TestCase
     }
 
     ex = assert_raise(Redis::ConnectionError) do
-      RedisMock.start(master, {}, 6382) do
-        RedisMock.start(sentinel, {}, 26381) 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
@@ -190,7 +202,7 @@ class SentinalTest < Test::Unit::TestCase
 
     connections = []
 
-    handler = lambda do |id|
+    handler = lambda do |id, port|
       {
         :sentinel => lambda do |command, *args|
           connections << id
@@ -198,7 +210,7 @@ class SentinalTest < Test::Unit::TestCase
           if connections.count(id) < 2
             :close
           else
-            ["127.0.0.1", "6382"]
+            ["127.0.0.1", port.to_s]
           end
         end
       }
@@ -210,9 +222,11 @@ class SentinalTest < Test::Unit::TestCase
       end
     }
 
-    RedisMock.start(master, {}, 6382) do
-      RedisMock.start(handler.call(:s1), {}, 26381) do
-        RedisMock.start(handler.call(:s2), {}, 26382) 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|
+          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
@@ -225,9 +239,9 @@ class SentinalTest < Test::Unit::TestCase
     connections.clear
 
     ex = assert_raise(Redis::CannotConnectError) do
-      RedisMock.start(master, {}, 6382) do
-        RedisMock.start(handler.call(:s1), {}, 26381) do
-          RedisMock.start(handler.call(:s2), {}, 26382) 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

data/test/support/redis_mock.rb

@@ -2,25 +2,21 @@ require "socket"
 
 module RedisMock
   class Server
-    VERBOSE = false
+    def initialize(options = {}, &block)
+      @server = TCPServer.new(options[:host] || "127.0.0.1", 0)
+      @server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+    end
 
-    def initialize(port, options = {}, &block)
-      @server = TCPServer.new(options[:host] || "127.0.0.1", port)
-      @server.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+    def port
+      @server.addr[1]
     end
 
     def start(&block)
       @thread = Thread.new { run(&block) }
     end
 
-    # Bail out of @server.accept before closing the socket. This is required
-    # to avoid EADDRINUSE after a couple of iterations.
     def shutdown
-      @thread.terminate if @thread
-      @server.close if @server
-    rescue => ex
-      $stderr.puts "Error closing mock server: #{ex.message}" if VERBOSE
-      $stderr.puts ex.backtrace if VERBOSE
+      @thread.kill
     end
 
     def run
@@ -35,20 +31,15 @@ module RedisMock
           end
         end
       rescue => ex
-        $stderr.puts "Error running mock server: #{ex.message}" if VERBOSE
-        $stderr.puts ex.backtrace if VERBOSE
+        $stderr.puts "Error running mock server: #{ex.message}"
+        $stderr.puts ex.backtrace
         retry
       ensure
-        begin
-          @server.close
-        rescue IOError
-        end
+        @server.close
       end
     end
   end
 
-  MOCK_PORT = 6382
-
   # Starts a mock Redis server in a thread.
   #
   # The server will use the lambda handler passed as argument to handle
@@ -59,14 +50,13 @@ module RedisMock
   #     # Every connection will be closed immediately
   #   end
   #
-  def self.start_with_handler(blk, options = {}, port = MOCK_PORT)
-    server = Server.new(port, options)
+  def self.start_with_handler(blk, options = {})
+    server = Server.new(options)
+    port = server.port
 
     begin
       server.start(&blk)
-
       yield(port)
-
     ensure
       server.shutdown
     end
@@ -77,11 +67,11 @@ module RedisMock
   # 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
-  #     assert_equal "PONG", Redis.new(:port => MOCK_PORT).ping
+  #   RedisMock.start(:ping => lambda { "+PONG" }) do |port|
+  #     assert_equal "PONG", Redis.new(:port => port).ping
   #   end
   #
-  def self.start(commands, options = {}, port = MOCK_PORT, &blk)
+  def self.start(commands, options = {}, &blk)
     handler = lambda do |session|
       while line = session.gets
         argv = Array.new(line[1..-3].to_i) do
@@ -106,8 +96,16 @@ module RedisMock
           break :close
         elsif response.is_a?(Array)
           session.write("*%d\r\n" % response.size)
-          response.each do |e|
-            session.write("$%d\r\n%s\r\n" % [e.length, e])
+
+          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)
@@ -116,6 +114,6 @@ module RedisMock
       end
     end
 
-    start_with_handler(handler, options, port, &blk)
+    start_with_handler(handler, options, &blk)
   end
 end

data/test/url_param_test.rb

@@ -129,4 +129,10 @@ class TestUrlParam < Test::Unit::TestCase
 
     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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.2
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,7 +16,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -32,6 +32,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       A Ruby client that tries to match Redis' API one-to-one, while still
       providing an idiomatic interface. It features thread-safety,
@@ -134,6 +148,7 @@ files:
 - test/remote_server_control_commands_test.rb
 - test/scanning_test.rb
 - test/scripting_test.rb
+- test/sentinel_command_test.rb
 - test/sentinel_test.rb
 - test/sorting_test.rb
 - test/support/connection/hiredis.rb
@@ -168,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: A Ruby client library for Redis
@@ -224,6 +239,7 @@ test_files:
 - test/remote_server_control_commands_test.rb
 - test/scanning_test.rb
 - test/scripting_test.rb
+- test/sentinel_command_test.rb
 - test/sentinel_test.rb
 - test/sorting_test.rb
 - test/support/connection/hiredis.rb