gorsuch-redis 3.0.0.rc1

data/test/distributed_remote_server_control_commands_test.rb

@@ -0,0 +1,42 @@
+# 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 "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|
+    r.info.each do |info|
+      assert info.keys.include?(x)
+    end
+  end
+end
+
+test "INFO COMMANDSTATS" do |r|
+  # Only available on Redis >= 2.9.0
+  next if version(r) < 209000
+
+  r.nodes.each { |n| n.config(:resetstat) }
+  r.ping # Executed on every node
+
+  r.info(:commandstats).each do |info|
+    assert "1" == info["ping"]["calls"]
+  end
+end
+
+test "MONITOR" do |r|
+  begin
+    r.monitor
+  rescue Exception => ex
+  ensure
+    assert ex.kind_of?(NotImplementedError)
+  end
+end
+
+test "ECHO" do |r|
+  assert ["foo bar baz\n"] == r.echo("foo bar baz\n")
+end

data/test/distributed_sorting_test.rb

@@ -0,0 +1,21 @@
+# 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 "SORT" do |r|
+  assert_raise Redis::Distributed::CannotDistribute do
+    r.set("foo:1", "s1")
+    r.set("foo:2", "s2")
+
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
+
+    r.sort("bar", :get => "foo:*", :limit => [0, 1])
+  end
+end

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,33 @@
+# 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,15 @@
+# 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,155 @@
+$:.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 Redis::CannotConnectError
+    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://redis.io/download/>.
+
+      To start the server:
+        rake start
+
+      To stop the server:
+        rake stop
+
+    EOS
+    exit 1
+  end
+end
+
+$VERBOSE = true
+
+require "redis/connection/%s" % (ENV["REDIS_CONNECTION_DRIVER"] || "ruby")
+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 version(r)
+  info = r.info
+  info = info.first unless info.is_a?(Hash)
+  version_str_to_i info["redis_version"]
+end
+
+def version_str_to_i(version_str)
+  version_str.split(".").map{ |v| v.ljust(2, '0') }.join.to_i
+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/helper_test.rb

@@ -0,0 +1,8 @@
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+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')
+end

data/test/internals_test.rb

@@ -0,0 +1,152 @@
+# 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
+
+test "Connection timeout" do
+  next if driver == :synchrony
+
+  assert_raise Redis::CannotConnectError do
+    Redis.new(OPTIONS.merge(:host => "10.255.255.254", :timeout => 0.1)).ping
+  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 Redis::ConnectionError 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 Redis::ConnectionError 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 Redis::ConnectionError 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
+
+# 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