yam-redis-with-retries 2.2.2.1

data/test/helper.rb

@@ -0,0 +1,145 @@
+$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require "cutest"
+require "logger"
+require "stringio"
+
+begin
+  require "ruby-debug"
+rescue LoadError
+end
+
+PORT    = 6379
+OPTIONS = {:port => PORT, :db => 15, :timeout => 3}
+NODES   = ["redis://127.0.0.1:6379/15"]
+
+def init(redis)
+  begin
+    redis.flushdb
+    redis.select 14
+    redis.flushdb
+    redis.select 15
+    redis
+  rescue Errno::ECONNREFUSED
+    puts <<-EOS
+
+      Cannot connect to Redis.
+
+      Make sure Redis is running on localhost, port 6379.
+      This testing suite connects to the database 15.
+
+      To install redis:
+        visit <http://code.google.com/p/redis/>.
+
+      To start the server:
+        rake start
+
+      To stop the server:
+        rake stop
+
+    EOS
+    exit 1
+  end
+end
+
+$VERBOSE = true
+
+require "redis"
+
+def driver
+  Redis::Connection.drivers.last.to_s.split("::").last.downcase.to_sym
+end
+
+if driver == :synchrony
+  # Make cutest fiber + eventmachine aware if the synchrony driver is used.
+  undef test if defined? test
+  def test(name = nil, &block)
+    cutest[:test] = name
+
+    blk = Proc.new do
+      prepare.each { |blk| blk.call }
+      block.call(setup && setup.call)
+    end
+
+    t = Thread.current[:cutest]
+    if defined? EventMachine
+      EM.synchrony do
+        Thread.current[:cutest] = t
+        blk.call
+        EM.stop
+      end
+    else
+      blk.call
+    end
+  end
+
+  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
+else
+  class Wire < Thread
+    def self.sleep(sec)
+      Kernel.sleep(sec)
+    end
+  end
+end
+
+def capture_stderr
+  stderr = $stderr
+  $stderr = StringIO.new
+
+  yield
+
+  $stderr = stderr
+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 assert_nothing_raised(*exceptions)
+  begin
+    yield
+  rescue *exceptions
+    flunk(caller[1])
+  end
+end
+

data/test/internals_test.rb

@@ -0,0 +1,163 @@
+# 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
+  log = StringIO.new
+
+  [Redis.new(OPTIONS.merge(:logger => ::Logger.new(log))), log]
+end
+
+$TEST_PIPELINING = true
+
+load File.expand_path("./lint/internals.rb", File.dirname(__FILE__))
+
+test "provides a meaningful inspect" do |r, _|
+  assert "#<Redis client v#{Redis::VERSION} connected to redis://127.0.0.1:6379/15 (Redis v#{r.info["redis_version"]})>" == r.inspect
+end
+
+test "Redis.current" do
+  Redis.current.set("foo", "bar")
+
+  assert "bar" == Redis.current.get("foo")
+
+  Redis.current = Redis.new(OPTIONS.merge(:db => 14))
+
+  assert Redis.current.get("foo").nil?
+end
+
+test "Timeout" do
+  assert_nothing_raised do
+    Redis.new(OPTIONS.merge(:timeout => 0))
+  end
+end
+
+# Don't use assert_raise because Timeour::Error in 1.8 inherits
+# Exception instead of StandardError (on 1.9).
+test "Connection timeout" do
+  # EM immediately raises CONNREFUSED
+  next if driver == :synchrony
+
+  result = false
+
+  begin
+    Redis.new(OPTIONS.merge(:host => "10.255.255.254", :timeout => 0.1)).ping
+  rescue Timeout::Error
+    result = true
+  ensure
+    assert result
+  end
+end
+
+test "Retry when first read raises ECONNRESET" do
+  $request = 0
+
+  command = lambda do
+    case ($request += 1)
+    when 1; nil # Close on first command
+    else "+%d" % $request
+    end
+  end
+
+  redis_mock(:ping => command) do
+    redis = Redis.connect(:port => 6380, :timeout => 0.1)
+    assert "2" == redis.ping
+  end
+end
+
+test "Don't retry when wrapped inside #without_reconnect" do
+  $request = 0
+
+  command = lambda do
+    case ($request += 1)
+    when 1; nil # Close on first command
+    else "+%d" % $request
+    end
+  end
+
+  redis_mock(:ping => command) do
+    redis = Redis.connect(:port => 6380, :timeout => 0.1)
+    assert_raise Errno::ECONNRESET do
+      redis.without_reconnect do
+        redis.ping
+      end
+    end
+
+    assert !redis.client.connected?
+  end
+end
+
+test "Retry only once when read raises ECONNRESET" do
+  $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
+    end
+  end
+
+  redis_mock(:ping => command) do
+    redis = Redis.connect(:port => 6380, :timeout => 0.1)
+    assert_raise Errno::ECONNRESET do
+      redis.ping
+    end
+
+    assert !redis.client.connected?
+  end
+end
+
+test "Don't retry when second read in pipeline raises ECONNRESET" do
+  $request = 0
+
+  command = lambda do
+    case ($request += 1)
+    when 2; nil # Close on second command
+    else "+%d" % $request
+    end
+  end
+
+  redis_mock(:ping => command) do
+    redis = Redis.connect(:port => 6380, :timeout => 0.1)
+    assert_raise Errno::ECONNRESET do
+      redis.pipelined do
+        redis.ping
+        redis.ping # Second #read times out
+      end
+    end
+  end
+end
+
+test "Connecting to UNIX domain socket" do
+  assert_nothing_raised do
+    Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock")).ping
+  end
+end
+
+# Using a mock server in a thread doesn't work here (possibly because blocking
+# socket ops, raw socket timeouts and Ruby's thread scheduling don't mix).
+#
+# I think this is failing because of a race condition?
+#
+# test "Bubble EAGAIN without retrying" do
+#   cmd = %{(sleep 0.3; echo "+PONG\r\n") | nc -l 6380}
+#   IO.popen(cmd) do |_|
+#     sleep 0.1 # Give nc a little time to start listening
+#     redis = Redis.connect(:port => 6380, :timeout => 0.1)
+
+#     begin
+#       assert_raise(Errno::EAGAIN) { redis.ping }
+#     ensure
+#       # Explicitly close connection so nc can quit
+#       redis.client.disconnect
+
+#       # Make the reactor loop do a tick to really close
+#       EM::Synchrony.sleep(0) if driver == :synchrony
+#     end
+#   end
+# end
+

data/test/lint/hashes.rb

@@ -0,0 +1,126 @@
+test "HSET and HGET" do |r|
+  r.hset("foo", "f1", "s1")
+
+  assert "s1" == r.hget("foo", "f1")
+end
+
+test "HSETNX" do |r|
+  r.hset("foo", "f1", "s1")
+  r.hsetnx("foo", "f1", "s2")
+
+  assert "s1" == r.hget("foo", "f1")
+
+  r.del("foo")
+  r.hsetnx("foo", "f1", "s2")
+
+  assert "s2" == r.hget("foo", "f1")
+end
+
+test "HDEL" do |r|
+  r.hset("foo", "f1", "s1")
+
+  assert "s1" == r.hget("foo", "f1")
+
+  r.hdel("foo", "f1")
+
+  assert nil == r.hget("foo", "f1")
+end
+
+test "HEXISTS" do |r|
+  assert false == r.hexists("foo", "f1")
+
+  r.hset("foo", "f1", "s1")
+
+  assert r.hexists("foo", "f1")
+end
+
+test "HLEN" do |r|
+  assert 0 == r.hlen("foo")
+
+  r.hset("foo", "f1", "s1")
+
+  assert 1 == r.hlen("foo")
+
+  r.hset("foo", "f2", "s2")
+
+  assert 2 == r.hlen("foo")
+end
+
+test "HKEYS" do |r|
+  assert [] == r.hkeys("foo")
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert ["f1", "f2"] == r.hkeys("foo")
+end
+
+test "HVALS" do |r|
+  assert [] == r.hvals("foo")
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert ["s1", "s2"] == r.hvals("foo")
+end
+
+test "HGETALL" do |r|
+  assert({} == r.hgetall("foo"))
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo"))
+end
+
+test "HMSET" do |r|
+  r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
+
+  assert "bar1" == r.hget("hash", "foo1")
+  assert "bar2" == r.hget("hash", "foo2")
+end
+
+test "HMSET with invalid arguments" do |r|
+  assert_raise(RuntimeError) do
+    r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
+  end
+end
+
+test "Mapped HMSET" do |r|
+  r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2")
+
+  assert "s1" == r.hget("foo", "f1")
+  assert "s2" == r.hget("foo", "f2")
+end
+
+test "HMGET" do |r|
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+  r.hset("foo", "f3", "s3")
+
+  assert ["s2", "s3"] == r.hmget("foo", "f2", "f3")
+end
+
+test "HMGET mapped" do |r|
+  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
+
+test "HINCRBY" do |r|
+  r.hincrby("foo", "f1", 1)
+
+  assert "1" == r.hget("foo", "f1")
+
+  r.hincrby("foo", "f1", 2)
+
+  assert "3" == r.hget("foo", "f1")
+
+  r.hincrby("foo", "f1", -1)
+
+  assert "2" == r.hget("foo", "f1")
+end
+

data/test/lint/internals.rb

@@ -0,0 +1,37 @@
+test "Logger" do |r, log|
+  r.ping
+
+  assert log.string =~ /Redis >> PING/
+  assert log.string =~ /Redis >> \d+\.\d+ms/
+end
+
+test "Logger with pipelining" do |r, log|
+  r.pipelined do
+    r.set "foo", "bar"
+    r.get "foo"
+  end
+
+  assert log.string["SET foo bar"]
+  assert log.string["GET foo"]
+end if $TEST_PIPELINING
+
+test "Recovers from failed commands" do |r, _|
+  # See http://github.com/ezmobius/redis-rb/issues#issue/28
+
+  assert_raise(ArgumentError) do
+    r.srem "foo"
+  end
+
+  assert_nothing_raised do
+    r.info
+  end
+end
+
+test "raises on protocol errors" do
+  redis_mock(:ping => lambda { |*_| "foo" }) do
+    assert_raise(Redis::ProtocolError) do
+      Redis.connect(:port => 6380).ping
+    end
+  end
+end
+