redis 3.0.0.rc2 → 3.0.0

data/lib/redis/pipeline.rb

@@ -9,13 +9,17 @@ class Redis
     attr :futures
 
     def initialize
-      @without_reconnect = false
+      @with_reconnect = true
       @shutdown = false
       @futures = []
     end
 
+    def with_reconnect?
+      @with_reconnect
+    end
+
     def without_reconnect?
-      @without_reconnect
+      !@with_reconnect
     end
 
     def shutdown?
@@ -41,11 +45,15 @@ class Redis
       @futures.map { |f| f._command }
     end
 
-    def without_reconnect(&block)
-      @without_reconnect = true
+    def with_reconnect(val=true)
+      @with_reconnect = false unless val
       yield
     end
 
+    def without_reconnect(&blk)
+      with_reconnect(false, &blk)
+    end
+
     def finish(replies, &blk)
       if blk
         futures.each_with_index.map do |future, i|

data/lib/redis/version.rb

@@ -1,3 +1,3 @@
 class Redis
-  VERSION = "3.0.0.rc2"
+  VERSION = "3.0.0"
 end

data/redis.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
 
   s.homepage = "https://github.com/redis/redis-rb"
 
-  s.summary = "A Ruby client library for the Redis key-value store."
+  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

data/test/commands_on_lists_test.rb

@@ -8,36 +8,6 @@ class TestCommandsOnLists < Test::Unit::TestCase
   include Helper::Client
   include Lint::Lists
 
-  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_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_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
-
   def test_rpoplpush
     r.rpush "foo", "s1"
     r.rpush "foo", "s2"

data/test/commands_on_strings_test.rb

@@ -80,10 +80,4 @@ class TestCommandsOnStrings < Test::Unit::TestCase
     assert_equal "s2", r.get("foo")
     assert_equal "s3", r.get("bar")
   end
-
-  def test_strlen
-    r.set "foo", "lorem"
-
-    assert_equal 5, r.strlen("foo")
-  end
 end

data/test/distributed_scripting_test.rb

@@ -0,0 +1,102 @@
+# encoding: UTF-8
+
+require "helper"
+
+class TestDistributedScripting < Test::Unit::TestCase
+
+  include Helper::Distributed
+
+  def to_sha(script)
+    r.script(:load, script).first
+  end
+
+  def test_script_exists
+    return if version < "2.5.9" # 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
+
+  def test_script_flush
+    return if version < "2.5.9" # 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
+
+  def test_script_kill
+    return if version < "2.5.9" # 2.6-rc1
+
+    redis_mock(:script => lambda { |arg| "+#{arg.upcase}" }) do |redis|
+      assert_equal ["KILL"], redis.script(:kill)
+    end
+  end
+
+  def test_eval
+    return if version < "2.5.9" # 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
+
+  def test_eval_with_options_hash
+    return if version < "2.5.9" # 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
+
+  def test_evalsha
+    return if version < "2.5.9" # 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
+
+  def test_evalsha_with_options_hash
+    return if version < "2.5.9" # 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

data/test/internals_test.rb

@@ -117,54 +117,59 @@ class TestInternals < Test::Unit::TestCase
     end
   end
 
-  def test_retry_when_first_read_raises_econnreset
+  def close_on_ping(seq)
     $request = 0
 
     command = lambda do
-      case ($request += 1)
-      when 1; nil # Close on first command
-      else "+%d" % $request
-      end
+      idx = $request
+      $request += 1
+
+      rv = "+%d" % idx
+      rv = nil if seq.include?(idx)
+      rv
     end
 
     redis_mock(:ping => command, :timeout => 0.1) do |redis|
-      assert_equal "2", redis.ping
+      yield(redis)
     end
   end
 
-  def test_don_t_retry_when_wrapped_inside__without_reconnect
-    $request = 0
+  def test_retry_by_default
+    close_on_ping([0]) do |redis|
+      assert_equal "1", redis.ping
+    end
+  end
 
-    command = lambda do
-      case ($request += 1)
-      when 1; nil # Close on first command
-      else "+%d" % $request
+  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
 
-    redis_mock(:ping => command, :timeout => 0.1) do |redis|
+  def test_dont_retry_when_wrapped_in_with_reconnect_false
+    close_on_ping([0]) do |redis|
       assert_raise Redis::ConnectionError do
-        redis.without_reconnect do
+        redis.with_reconnect(false) do
           redis.ping
         end
       end
-
-      assert !redis.client.connected?
     end
   end
 
-  def test_retry_only_once_when_read_raises_econnreset
-    $request = 0
-
-    command = lambda do
-      case ($request += 1)
-      when 1; nil # Close on first command
-      when 2; nil # Close on second command
-      else "+%d" % $request
+  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
 
-    redis_mock(:ping => command, :timeout => 0.1) do |redis|
+  def test_retry_only_once_when_read_raises_econnreset
+    close_on_ping([0, 1]) do |redis|
       assert_raise Redis::ConnectionError do
         redis.ping
       end
@@ -174,22 +179,15 @@ class TestInternals < Test::Unit::TestCase
   end
 
   def test_don_t_retry_when_second_read_in_pipeline_raises_econnreset
-    $request = 0
-
-    command = lambda do
-      case ($request += 1)
-      when 2; nil # Close on second command
-      else "+%d" % $request
-      end
-    end
-
-    redis_mock(:ping => command, :timeout => 0.1) do |redis|
+    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
 

data/test/lint/lists.rb

@@ -2,6 +2,31 @@ 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
+      return if version < "2.3.9" # 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
+
+    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"
@@ -18,20 +43,13 @@ module Lint
       assert_equal "s3", r.rpop("foo")
     end
 
-    def test_lpush
-      r.lpush "foo", "s1"
-      r.lpush "foo", "s2"
+    def test_rpushx
+      r.rpushx "foo", "s1"
+      r.rpush "foo", "s2"
+      r.rpushx "foo", "s3"
 
       assert_equal 2, r.llen("foo")
-      assert_equal "s2", r.lpop("foo")
-    end
-
-    def test_variadic_lpush
-      return if version < "2.3.9" # 2.4-rc6
-
-      assert_equal 3, r.lpush("foo", ["s1", "s2", "s3"])
-      assert_equal 3, r.llen("foo")
-      assert_equal "s3", r.lpop("foo")
+      assert_equal ["s2", "s3"], r.lrange("foo", 0, -1)
     end
 
     def test_llen
@@ -109,5 +127,17 @@ module Lint
       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

data/test/lint/strings.rb

@@ -147,5 +147,11 @@ module Lint
 
       assert_equal "abare", r.get("foo")
     end
+
+    def test_strlen
+      r.set "foo", "lorem"
+
+      assert_equal 5, r.strlen("foo")
+    end
   end
 end

data/test/lint/value_types.rb

@@ -2,6 +2,10 @@ module Lint
 
   module ValueTypes
 
+    def assert_in_range(range, value)
+      assert range.include?(value), "expected #{value} to be in #{range.inspect}"
+    end
+
     def test_exists
       assert_equal false, r.exists("foo")
 
@@ -29,7 +33,7 @@ module Lint
     def test_expire
       r.set("foo", "s1")
       assert r.expire("foo", 1)
-      assert [0, 1].include? r.ttl("foo")
+      assert_in_range 0..1, r.ttl("foo")
     end
 
     def test_pexpire
@@ -37,13 +41,13 @@ module Lint
 
       r.set("foo", "s1")
       assert r.pexpire("foo", 1000)
-      assert [0, 1].include? r.ttl("foo")
+      assert_in_range 0..1, r.ttl("foo")
     end
 
     def test_expireat
       r.set("foo", "s1")
       assert r.expireat("foo", (Time.now + 1).to_i)
-      assert [0, 1].include? r.ttl("foo")
+      assert_in_range 0..1, r.ttl("foo")
     end
 
     def test_pexpireat
@@ -51,7 +55,7 @@ module Lint
 
       r.set("foo", "s1")
       assert r.pexpireat("foo", (Time.now + 1).to_i * 1_000)
-      assert [0, 1].include? r.ttl("foo")
+      assert_in_range 0..1, r.ttl("foo")
     end
 
     def test_persist
@@ -65,7 +69,7 @@ module Lint
     def test_ttl
       r.set("foo", "s1")
       r.expire("foo", 1)
-      assert [0, 1].include? r.ttl("foo")
+      assert_in_range 0..1, r.ttl("foo")
     end
 
     def test_pttl
@@ -73,7 +77,7 @@ module Lint
 
       r.set("foo", "s1")
       r.expire("foo", 1)
-      assert 1000 >= r.pttl("foo")
+      assert_in_range 1..1000, r.pttl("foo")
     end
 
     def test_move