yam-redis-with-retries 2.2.2.1

data/test/remote_server_control_commands_test.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require File.expand_path("./redis_mock", File.dirname(__FILE__))
+
+include RedisMock::Helper
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "INFO" do |r|
+  %w(last_save_time redis_version total_connections_received connected_clients total_commands_processed connected_slaves uptime_in_seconds used_memory uptime_in_days changes_since_last_save).each do |x|
+    assert r.info.keys.include?(x)
+  end
+end
+
+test "INFO COMMANDSTATS" do |r|
+  # Only available on Redis >= 2.3.0
+  next if r.info["redis_version"] < "2.3.0"
+
+  r.config(:resetstat)
+  r.ping
+
+  result = r.info(:commandstats)
+  assert "1" == result["ping"]["calls"]
+end
+
+test "MONITOR" do |r|
+  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
+
+test "MONITOR returns value for break" do |r|
+  result = r.monitor do |line|
+    break line
+  end
+
+  assert result == "OK"
+end
+
+test "ECHO" do |r|
+  assert "foo bar baz\n" == r.echo("foo bar baz\n")
+end
+
+test "DEBUG" do |r|
+  r.set "foo", "s1"
+
+  assert r.debug(:object, "foo").kind_of?(String)
+end
+
+test "OBJECT" do |r|
+  r.lpush "list", "value"
+
+  assert r.object(:refcount, "list") == 1
+  assert r.object(:encoding, "list") == "ziplist"
+  assert r.object(:idletime, "list").kind_of?(Fixnum)
+end
+
+test "SYNC" do |r|
+  replies = {:sync => lambda { "+OK" }}
+
+  redis_mock(replies) do
+    redis = Redis.new(OPTIONS.merge(:port => 6380))
+
+    assert "OK" == redis.sync
+  end
+end

data/test/retry_test.rb

@@ -0,0 +1,225 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "mocha"
+
+include Mocha::API
+
+setup do
+end
+
+test "Happy path with retry enabled" do
+  client = Object.new
+  client.stubs(:call).with([:info]).returns("foo:bar")
+  Redis::Client.stubs(:new).returns(client)
+
+  redis = Redis.new(OPTIONS.merge({ :max_retries => 3 }))
+
+  assert_equal({ "foo" => "bar" }, redis.info)
+end
+
+test "Method retried 1 number of times" do
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+
+  redis = Redis.new(OPTIONS.merge({
+    :max_retries => 1,
+    :mark_dead   => false
+  }))
+
+  begin
+    redis.info
+    raise "Should have reached max retries"
+  rescue Redis::Retry::MaxRetriesReachedError => e
+    assert_equal 1, e.retries
+  end
+end
+
+test "Method retried 5 number of times" do
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+
+  redis = Redis.new(OPTIONS.merge({ 
+    :max_retries => 5,
+    :mark_dead   => false
+   }))
+
+  begin
+    redis.info
+    raise "Should have reached max retries"
+  rescue Redis::Retry::MaxRetriesReachedError => e
+    assert_equal 5, e.retries
+  end
+end
+
+test "No retries if an unsupported exception is thrown" do
+  error = RuntimeError.new("foo")
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(error)
+  Redis::Client.stubs(:new).returns(client)
+
+  redis = Redis.new(OPTIONS.merge({ :max_retries => 1 }))
+
+  begin
+    redis.info
+    raise "Should have errored out"
+  rescue => e
+    assert_equal e, error
+  end
+end
+
+test "Test marked dead after retries exhausted" do
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+
+  redis = Redis.new(OPTIONS.merge({ 
+    :max_retries       => 3, 
+    :mark_dead_seconds => 5
+  }))
+
+  begin
+    redis.info
+    raise "Should have been marked as dead"
+  rescue Redis::Retry::MarkedDeadError => e
+    # should still be dead.
+    client.stubs(:call).returns(:foo => :bar)
+    begin
+      redis.info
+      raise "Should still have been dead"
+    rescue Redis::Retry::MarkedDeadError => e
+    end
+  end
+end
+
+test "Test resuscitation after being marked as dead" do
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+
+  redis = Redis.new(OPTIONS.merge({ 
+    :max_retries       => 1, 
+    :mark_dead_seconds => 1
+  }))
+
+  begin
+    redis.info
+    raise "Should have been marked as dead"
+  rescue Redis::Retry::MarkedDeadError => e
+
+    # should only be dead for 1 seconds
+    client.stubs(:call).returns(:foo => :bar)
+    sleep 1
+
+    assert_equal redis.info, {:foo => :bar}
+  end
+end
+
+test "Test partial resuscitation" do
+  retries = 3
+  client  = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+  redis = Redis.new(OPTIONS.merge({
+    :max_retries       => retries,
+    :mark_dead_seconds => 1
+  }))
+  
+  begin
+    redis.info
+    raise "Should have been marked as dead"
+  rescue Redis::Retry::MarkedDeadError
+    sleep 1
+  end
+
+  ## eh, gross, but handly for this test
+  class Redis;        attr_accessor :retry;              end
+  class Redis::Retry; attr_accessor :consecutive_errors; end
+  redis.retry.mark_alive!
+
+  assert_equal redis.retry.consecutive_errors, (retries - 1)
+end
+
+
+test "Should not retry if max_retries paramater is not specified" do
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+
+  redis = Redis.new(OPTIONS)
+
+  begin
+    redis.info
+    raise "Should have failed"
+  rescue Errno::ECONNABORTED => e
+    # success
+  end
+end
+
+test "Should call on_retry callback" do
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+
+  @ex = nil 
+  redis = Redis.new(OPTIONS.merge({
+    :with_retry     => true,
+    :on_retry       => Proc.new{|e| assert e.kind_of?(Errno::ECONNABORTED); }
+  }))
+
+  begin 
+    redis.info
+  rescue Redis::Retry::MarkedDeadError
+    ## success
+  end
+end
+
+test "SHould call on_max_retries callback with mark_dead" do
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+
+  @ex = nil 
+  redis = Redis.new(OPTIONS.merge({
+    :with_retry     => true,
+    :mark_dead      => true, 
+    :on_max_retries => Proc.new{|e| assert e.kind_of?(Redis::Retry::MarkedDeadError); }
+  }))
+
+  begin 
+    redis.info
+  rescue Redis::Retry::MarkedDeadError
+    ## success
+  end
+end
+
+test "Should call on_max_retries callback without mark_dead" do
+  client = mock()
+  client.stubs(:disconnect => nil)
+  client.stubs(:call).raises(Errno::ECONNABORTED)
+  Redis::Client.stubs(:new).returns(client)
+
+  @ex = nil 
+  redis = Redis.new(OPTIONS.merge({
+    :with_retry     => true,
+    :mark_dead      => false,
+    :on_max_retries => Proc.new{|e| assert e.kind_of?(Redis::Retry::MaxRetriesReachedError); }
+  }))
+
+  begin 
+    redis.info
+  rescue Redis::Retry::MaxRetriesReachedError
+    ## success
+  end
+end

data/test/sorting_test.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "SORT" do |r|
+  r.set("foo:1", "s1")
+  r.set("foo:2", "s2")
+
+  r.rpush("bar", "1")
+  r.rpush("bar", "2")
+
+  assert ["s1"] == r.sort("bar", :get => "foo:*", :limit => [0, 1])
+  assert ["s2"] == r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
+end
+
+test "SORT with an array of GETs" do |r|
+  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 ["s1a", "s1b"] == r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
+  assert ["s2a", "s2b"] == r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+end
+
+test "SORT with STORE" do |r|
+  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 ["s1", "s2"] == r.lrange("baz", 0, -1)
+end
+

data/test/synchrony_driver.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+require 'em-synchrony'
+
+require 'redis'
+require 'redis/connection/synchrony'
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+#
+# 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
+  r.flushdb
+
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.rpop("foo")
+
+  r.set("foo", "bar")
+
+  assert "bar" == r.getset("foo", "baz")
+  assert "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 2 == r.llen("foo")
+  assert "s2" == r.lpop("foo")
+  assert "s1" == r.lpop("foo")
+
+  assert "OK" == r.client.call(:quit)
+  assert "PONG" == r.ping
+
+  EM.stop
+end

data/test/test.conf

@@ -0,0 +1,8 @@
+dir ./test/db
+pidfile ./redis.pid
+port 6379
+timeout 300
+loglevel debug
+logfile stdout
+databases 16
+daemonize yes

data/test/thread_safety_test.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "thread safety" do
+  redis = Redis.connect(OPTIONS.merge(:thread_safe => true))
+
+  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