redis 2.0.0 → 2.2.1

data/test/distributed_test.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "handle multiple servers" do
+  @r = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
+
+  100.times do |idx|
+    @r.set(idx.to_s, "foo#{idx}")
+  end
+
+  100.times do |idx|
+    assert "foo#{idx}" == @r.get(idx.to_s)
+  end
+
+  assert "0" == @r.keys("*").sort.first
+  assert "string" == @r.type("1")
+end
+
+test "add nodes" do
+  logger = Logger.new("/dev/null")
+
+  @r = Redis::Distributed.new NODES, :logger => logger, :timeout => 10
+
+  assert "127.0.0.1" == @r.nodes[0].client.host
+  assert 6379 == @r.nodes[0].client.port
+  assert 15 == @r.nodes[0].client.db
+  assert 10 == @r.nodes[0].client.timeout
+  assert logger == @r.nodes[0].client.logger
+
+  @r.add_node("redis://localhost:6380/14")
+
+  assert "localhost" == @r.nodes[1].client.host
+  assert 6380 == @r.nodes[1].client.port
+  assert 14 == @r.nodes[1].client.db
+  assert 10 == @r.nodes[1].client.timeout
+  assert logger == @r.nodes[1].client.logger
+end
+
+test "Pipelining commands cannot be distributed" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.pipelined do
+      r.lpush "foo", "s1"
+      r.lpush "foo", "s2"
+    end
+  end
+end
+
+test "Unknown commands does not work by default" do |r|
+  assert_raise NoMethodError do
+    r.not_yet_implemented_command
+  end
+end

data/test/distributed_transactions_test.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require "redis/distributed"
+
+setup do
+  log = StringIO.new
+  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
+end
+
+test "MULTI/DISCARD" do |r|
+  @foo = nil
+
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.multi { @foo = 1 }
+  end
+
+  assert nil == @foo
+
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.discard
+  end
+end
+
+test "WATCH/UNWATCH" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.watch("foo")
+  end
+
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.unwatch
+  end
+end
+

data/test/encoding_test.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "returns properly encoded strings" do |r|
+  with_external_encoding("UTF-8") do
+    r.set "foo", "שלום"
+
+    assert "Shalom שלום" == "Shalom " + r.get("foo")
+  end
+end if defined?(Encoding)
+

data/test/error_replies_test.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+# 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 test_with_reconnection_check(title)
+  test(title) do |r|
+    before = r.info["total_connections_received"]
+    yield(r)
+    after = r.info["total_connections_received"]
+    assert before == after
+  end
+end
+
+test_with_reconnection_check "Error reply for single command" do |r|
+  begin
+    r.unknown_command
+  rescue => ex
+  ensure
+    assert ex.message =~ /unknown command/i
+  end
+end
+
+test_with_reconnection_check "Raise first error reply in pipeline" do |r|
+  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
+
+test_with_reconnection_check "Recover from raise in #call_loop" do |r|
+  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

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,160 @@
+# 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).
+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,114 @@
+test "HSET and HGET" do |r|
+  r.hset("foo", "f1", "s1")
+
+  assert "s1" == 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
+

data/test/lint/lists.rb

@@ -0,0 +1,93 @@
+test "RPUSH" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.rpop("foo")
+end
+
+test "LPUSH" do |r|
+  r.lpush "foo", "s1"
+  r.lpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.lpop("foo")
+end
+
+test "LLEN" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+end
+
+test "LRANGE" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+  r.rpush "foo", "s3"
+
+  assert ["s2", "s3"] == r.lrange("foo", 1, -1)
+  assert ["s1", "s2"] == r.lrange("foo", 0, 1)
+
+  assert [] == r.lrange("bar", 0, -1)
+end
+
+test "LTRIM" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+  r.rpush "foo", "s3"
+
+  r.ltrim "foo", 0, 1
+
+  assert 2 == r.llen("foo")
+  assert ["s1", "s2"] == r.lrange("foo", 0, -1)
+end
+
+test "LINDEX" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert "s1" == r.lindex("foo", 0)
+  assert "s2" == r.lindex("foo", 1)
+end
+
+test "LSET" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert "s2" == r.lindex("foo", 1)
+  assert r.lset("foo", 1, "s3")
+  assert "s3" == r.lindex("foo", 1)
+
+  assert_raise RuntimeError do
+    r.lset("foo", 4, "s3")
+  end
+end
+
+test "LREM" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 1 == r.lrem("foo", 1, "s1")
+  assert ["s2"] == r.lrange("foo", 0, -1)
+end
+
+test "LPOP" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s1" == r.lpop("foo")
+  assert 1 == r.llen("foo")
+end
+
+test "RPOP" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.rpop("foo")
+  assert 1 == r.llen("foo")
+end
+
+