redis 3.0.0.rc1 → 3.0.0.rc2

data/test/error_replies_test.rb

@@ -1,53 +1,59 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestErrorReplies < Test::Unit::TestCase
+
+  include Helper::Client
 
-# 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|
+  # 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 with_reconnection_check
     before = r.info["total_connections_received"]
     yield(r)
     after = r.info["total_connections_received"]
-    assert before == after
+  ensure
+    assert_equal 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
+  def test_error_reply_for_single_command
+    with_reconnection_check do
+      begin
+        r.unknown_command
+      rescue => ex
+      ensure
+        assert ex.message =~ /unknown command/i
+      end
+    end
   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
+  def test_raise_first_error_reply_in_pipeline
+    with_reconnection_check do
+      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
-  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
+  def test_recover_from_raise_in__call_loop
+    with_reconnection_check do
+      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
-  rescue => ex
-  ensure
-    assert ex.message =~ /unknown command/i
   end
 end

data/test/helper.rb

@@ -1,6 +1,6 @@
 $:.unshift File.expand_path('../lib', File.dirname(__FILE__))
 
-#require "cutest"
+require "test/unit"
 require "logger"
 require "stringio"
 
@@ -9,23 +9,34 @@ begin
 rescue LoadError
 end
 
-PORT    = 6379
-OPTIONS = {:port => PORT, :db => 15, :timeout => 3}
-NODES   = ["redis://127.0.0.1:6379/15"]
+$VERBOSE = true
+
+ENV["conn"] ||= "ruby"
+
+require "redis"
+require "redis/distributed"
+require "redis/connection/#{ENV["conn"]}"
+
+require "support/redis_mock"
+require "support/connection/#{ENV["conn"]}"
+
+PORT    = 6381
+OPTIONS = {:port => PORT, :db => 15, :timeout => 0.1}
+NODES   = ["redis://127.0.0.1:#{PORT}/15"]
 
 def init(redis)
   begin
-    redis.flushdb
     redis.select 14
     redis.flushdb
     redis.select 15
+    redis.flushdb
     redis
   rescue Redis::CannotConnectError
     puts <<-EOS
 
       Cannot connect to Redis.
 
-      Make sure Redis is running on localhost, port 6379.
+      Make sure Redis is running on localhost, port #{PORT}.
       This testing suite connects to the database 15.
 
       To install redis:
@@ -42,114 +53,136 @@ def init(redis)
   end
 end
 
-$VERBOSE = true
+def driver(*drivers, &blk)
+  if drivers.map(&:to_s).include?(ENV["conn"])
+    class_eval(&blk)
+  end
+end
 
-require "redis/connection/%s" % (ENV["REDIS_CONNECTION_DRIVER"] || "ruby")
-require "redis"
+module Helper
 
-def driver
-  Redis::Connection.drivers.last.to_s.split("::").last.downcase.to_sym
-end
+  def run(runner)
+    if respond_to?(:around)
+      around { super(runner) }
+    else
+      super
+    end
+  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
+  def silent
+    verbose, $VERBOSE = $VERBOSE, false
 
-    blk = Proc.new do
-      prepare.each { |blk| blk.call }
-      block.call(setup && setup.call)
+    begin
+      yield
+    ensure
+      $VERBOSE = verbose
     end
+  end
 
-    t = Thread.current[:cutest]
-    if defined? EventMachine
-      EM.synchrony do
-        Thread.current[:cutest] = t
-        blk.call
-        EM.stop
-      end
-    else
-      blk.call
+  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
 
-  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
+  class Version
+
+    include Comparable
+
+    attr :parts
+
+    def initialize(v)
+      case v
+      when Version
+        @parts = v.parts
+      else
+        @parts = v.to_s.split(".")
+      end
     end
 
-    def self.sleep(sec)
-      EM::Synchrony.sleep(sec)
+    def <=>(other)
+      other = Version.new(other)
+      length = [self.parts.length, other.parts.length].max
+      length.times do |i|
+        a, b = self.parts[i], other.parts[i]
+
+        return -1 if a.nil?
+        return +1 if b.nil?
+        return a <=> b if a != b
+      end
+
+      0
     end
+  end
 
-    def initialize(&blk)
-      super
+  module Generic
+
+    include Helper
 
-      # Schedule run in next tick
-      EM.next_tick { resume }
+    attr_reader :log
+    attr_reader :redis
+
+    alias :r :redis
+
+    def setup
+      @log = StringIO.new
+      @redis = init _new_client
     end
 
-    def join
-      self.class.pass while alive?
+    def teardown
+      @redis.quit if @redis
     end
-  end
-else
-  class Wire < Thread
-    def self.sleep(sec)
-      Kernel.sleep(sec)
+
+    def redis_mock(commands, options = {}, &blk)
+      RedisMock.start(commands) do |port|
+        yield _new_client(options.merge(:port => port))
+      end
     end
   end
-end
 
-def capture_stderr
-  stderr = $stderr
-  $stderr = StringIO.new
+  module Client
 
-  yield
+    include Generic
 
-  $stderr = stderr
-end
+    def version
+      Version.new(redis.info["redis_version"])
+    end
 
-def silent
-  verbose, $VERBOSE = $VERBOSE, false
+    private
 
-  begin
-    yield
-  ensure
-    $VERBOSE = verbose
+    def _format_options(options)
+      OPTIONS.merge(:logger => ::Logger.new(@log)).merge(options)
+    end
+
+    def _new_client(options = {})
+      Redis.new(_format_options(options))
+    end
   end
-end
 
-def version(r)
-  info = r.info
-  info = info.first unless info.is_a?(Hash)
-  version_str_to_i info["redis_version"]
-end
+  module Distributed
 
-def version_str_to_i(version_str)
-  version_str.split(".").map{ |v| v.ljust(2, '0') }.join.to_i
-end
+    include Generic
 
-def with_external_encoding(encoding)
-  original_encoding = Encoding.default_external
+    def version
+      Version.new(redis.info.first["redis_version"])
+    end
 
-  begin
-    silent { Encoding.default_external = Encoding.find(encoding) }
-    yield
-  ensure
-    silent { Encoding.default_external = original_encoding }
-  end
-end
+    private
 
-def assert_nothing_raised(*exceptions)
-  begin
-    yield
-  rescue *exceptions
-    flunk(caller[1])
+    def _format_options(options)
+      {
+        :timeout => OPTIONS[:timeout],
+        :logger => ::Logger.new(@log),
+      }.merge(options)
+    end
+
+    def _new_client(options = {})
+      Redis::Distributed.new(NODES, _format_options(options))
+    end
   end
 end

data/test/helper_test.rb

@@ -1,8 +1,22 @@
-require File.expand_path("./helper", File.dirname(__FILE__))
+# encoding: UTF-8
 
-test "version_str_to_i" do
-  assert_equal 200000, version_str_to_i('2.0.0')
-  assert_equal 202020, version_str_to_i('2.2.2')
-  assert_equal 202022, version_str_to_i('2.2.22')
-  assert_equal 222222, version_str_to_i('22.22.22')
+require "helper"
+
+class TestHelper < Test::Unit::TestCase
+
+  include Helper
+
+  def test_version_comparison
+    v = Version.new("2.0.0")
+
+    assert v < "3"
+    assert v > "1"
+    assert v > "2"
+
+    assert v < "2.1"
+    assert v < "2.0.1"
+    assert v < "2.0.0.1"
+
+    assert v == "2.0.0"
+  end
 end

data/test/internals_test.rb

@@ -1,152 +1,216 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require File.expand_path("./redis_mock", File.dirname(__FILE__))
+require "helper"
 
-include RedisMock::Helper
+class TestInternals < Test::Unit::TestCase
 
-setup do
-  log = StringIO.new
+  include Helper::Client
 
-  [Redis.new(OPTIONS.merge(:logger => ::Logger.new(log))), log]
-end
+  def test_logger
+    r.ping
 
-$TEST_PIPELINING = true
+    assert log.string =~ /Redis >> PING/
+      assert log.string =~ /Redis >> \d+\.\d+ms/
+  end
 
-load File.expand_path("./lint/internals.rb", File.dirname(__FILE__))
+  def test_logger_with_pipelining
+    r.pipelined do
+      r.set "foo", "bar"
+      r.get "foo"
+    end
 
-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
+    assert log.string["SET foo bar"]
+    assert log.string["GET foo"]
+  end
 
-test "Redis.current" do
-  Redis.current.set("foo", "bar")
+  def test_recovers_from_failed_commands
+    # See https://github.com/redis/redis-rb/issues#issue/28
 
-  assert "bar" == Redis.current.get("foo")
+    assert_raise(Redis::CommandError) do
+      r.command_that_doesnt_exist
+    end
 
-  Redis.current = Redis.new(OPTIONS.merge(:db => 14))
+    assert_nothing_raised do
+      r.info
+    end
+  end
 
-  assert Redis.current.get("foo").nil?
-end
+  def test_raises_on_protocol_errors
+    redis_mock(:ping => lambda { |*_| "foo" }) do |redis|
+      assert_raise(Redis::ProtocolError) do
+        redis.ping
+      end
+    end
+  end
 
-test "Timeout" do
-  assert_nothing_raised do
-    Redis.new(OPTIONS.merge(:timeout => 0))
+  def test_provides_a_meaningful_inspect
+    assert_equal "#<Redis client v#{Redis::VERSION} for redis://127.0.0.1:#{PORT}/15>", r.inspect
   end
-end
 
-test "Connection timeout" do
-  next if driver == :synchrony
+  def test_redis_current
+    assert_equal "127.0.0.1", Redis.current.client.host
+    assert_equal 6379, Redis.current.client.port
+    assert_equal 0, Redis.current.client.db
+
+    Redis.current = Redis.new(OPTIONS.merge(:port => 6380, :db => 1))
+
+    t = Thread.new do
+      assert_equal "127.0.0.1", Redis.current.client.host
+      assert_equal 6380, Redis.current.client.port
+      assert_equal 1, Redis.current.client.db
+    end
+
+    t.join
 
-  assert_raise Redis::CannotConnectError do
-    Redis.new(OPTIONS.merge(:host => "10.255.255.254", :timeout => 0.1)).ping
+    assert_equal "127.0.0.1", Redis.current.client.host
+    assert_equal 6380, Redis.current.client.port
+    assert_equal 1, Redis.current.client.db
+  end
+
+  def test_default_id_with_host_and_port
+    redis = Redis.new(OPTIONS.merge(:host => "host", :port => "1234", :db => 0))
+    assert_equal "redis://host:1234/0", redis.client.id
   end
-end
 
-test "Retry when first read raises ECONNRESET" do
-  $request = 0
+  def test_default_id_with_host_and_port_and_explicit_scheme
+    redis = Redis.new(OPTIONS.merge(:host => "host", :port => "1234", :db => 0, :scheme => "foo"))
+    assert_equal "redis://host:1234/0", redis.client.id
+  end
 
-  command = lambda do
-    case ($request += 1)
-    when 1; nil # Close on first command
-    else "+%d" % $request
-    end
+  def test_default_id_with_path
+    redis = Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock", :db => 0))
+    assert_equal "redis:///tmp/redis.sock/0", redis.client.id
   end
 
-  redis_mock(:ping => command) do
-    redis = Redis.connect(:port => 6380, :timeout => 0.1)
-    assert "2" == redis.ping
+  def test_default_id_with_path_and_explicit_scheme
+    redis = Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock", :db => 0, :scheme => "foo"))
+    assert_equal "redis:///tmp/redis.sock/0", redis.client.id
   end
-end
 
-test "Don't retry when wrapped inside #without_reconnect" do
-  $request = 0
+  def test_override_id
+    redis = Redis.new(OPTIONS.merge(:id => "test"))
+    assert_equal redis.client.id, "test"
+  end
 
-  command = lambda do
-    case ($request += 1)
-    when 1; nil # Close on first command
-    else "+%d" % $request
+  def test_timeout
+    assert_nothing_raised do
+      Redis.new(OPTIONS.merge(:timeout => 0))
     end
   end
 
-  redis_mock(:ping => command) do
-    redis = Redis.connect(:port => 6380, :timeout => 0.1)
-    assert_raise Redis::ConnectionError do
-      redis.without_reconnect do
-        redis.ping
+  def test_time
+    return if version < "2.5.4"
+
+    # Test that the difference between the time that Ruby reports and the time
+    # that Redis reports is minimal (prevents the test from being racy).
+    rv = r.time
+
+    redis_usec = rv[0] * 1_000_000 + rv[1]
+    ruby_usec = Integer(Time.now.to_f * 1_000_000)
+
+    assert 500_000 > (ruby_usec - redis_usec).abs
+  end
+
+  def test_connection_timeout
+    assert_raise Redis::CannotConnectError do
+      Redis.new(OPTIONS.merge(:host => "10.255.255.254", :timeout => 0.1)).ping
+    end
+  end
+
+  def test_retry_when_first_read_raises_econnreset
+    $request = 0
+
+    command = lambda do
+      case ($request += 1)
+      when 1; nil # Close on first command
+      else "+%d" % $request
       end
     end
 
-    assert !redis.client.connected?
+    redis_mock(:ping => command, :timeout => 0.1) do |redis|
+      assert_equal "2", redis.ping
+    end
   end
-end
 
-test "Retry only once when read raises ECONNRESET" do
-  $request = 0
+  def test_don_t_retry_when_wrapped_inside__without_reconnect
+    $request = 0
+
+    command = lambda do
+      case ($request += 1)
+      when 1; nil # Close on first command
+      else "+%d" % $request
+      end
+    end
+
+    redis_mock(:ping => command, :timeout => 0.1) do |redis|
+      assert_raise Redis::ConnectionError do
+        redis.without_reconnect do
+          redis.ping
+        end
+      end
 
-  command = lambda do
-    case ($request += 1)
-    when 1; nil # Close on first command
-    when 2; nil # Close on second command
-    else "+%d" % $request
+      assert !redis.client.connected?
     end
   end
 
-  redis_mock(:ping => command) do
-    redis = Redis.connect(:port => 6380, :timeout => 0.1)
-    assert_raise Redis::ConnectionError do
-      redis.ping
+  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
+      end
     end
 
-    assert !redis.client.connected?
+    redis_mock(:ping => command, :timeout => 0.1) do |redis|
+      assert_raise Redis::ConnectionError do
+        redis.ping
+      end
+
+      assert !redis.client.connected?
+    end
   end
-end
 
-test "Don't retry when second read in pipeline raises ECONNRESET" do
-  $request = 0
+  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
+    command = lambda do
+      case ($request += 1)
+      when 2; nil # Close on second command
+      else "+%d" % $request
+      end
     end
-  end
 
-  redis_mock(:ping => command) do
-    redis = Redis.connect(:port => 6380, :timeout => 0.1)
-    assert_raise Redis::ConnectionError do
-      redis.pipelined do
-        redis.ping
-        redis.ping # Second #read times out
+    redis_mock(:ping => command, :timeout => 0.1) do |redis|
+      assert_raise Redis::ConnectionError do
+        redis.pipelined do
+          redis.ping
+          redis.ping # Second #read times out
+        end
       end
     end
   end
-end
 
-test "Connecting to UNIX domain socket" do
-  assert_nothing_raised do
-    Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock")).ping
+  def test_connecting_to_unix_domain_socket
+    assert_nothing_raised do
+      Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock")).ping
+    end
   end
-end
 
-# if driver == :ruby || driver == :hiredis
-#   # 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
-# end
+  driver(:ruby, :hiredis) do
+    def test_bubble_timeout_without_retrying
+      serv = TCPServer.new(6380)
+
+      redis = Redis.new(:port => 6380, :timeout => 0.1)
+
+      assert_raise(Redis::TimeoutError) do
+        redis.ping
+      end
+
+    ensure
+      serv.close if serv
+    end
+  end
+end