redis 4.0.0.rc1 → 4.4.0

data/test/connection_handling_test.rb

@@ -1,275 +0,0 @@
-require_relative "helper"
-
-class TestConnectionHandling < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_auth
-    commands = {
-      :auth => lambda { |password| $auth = password; "+OK" },
-      :get  => lambda { |key| $auth == "secret" ? "$3\r\nbar" : "$-1" },
-    }
-
-    redis_mock(commands, :password => "secret") do |redis|
-      assert_equal "bar", redis.get("foo")
-    end
-  end
-
-  def test_id
-    commands = {
-      :client => lambda { |cmd, name| $name = [cmd, name]; "+OK" },
-      :ping  => lambda { "+PONG" },
-    }
-
-    redis_mock(commands, :id => "client-name") do |redis|
-      assert_equal "PONG", redis.ping
-    end
-
-    assert_equal ["setname","client-name"], $name
-  end
-
-  def test_ping
-    assert_equal "PONG", r.ping
-  end
-
-  def test_select
-    r.set "foo", "bar"
-
-    r.select 14
-    assert_equal nil, r.get("foo")
-
-    r._client.disconnect
-
-    assert_equal nil, r.get("foo")
-  end
-
-  def test_quit
-    r.quit
-
-    assert !r._client.connected?
-  end
-
-  def test_close
-    quit = 0
-
-    commands = {
-      :quit => lambda do
-        quit += 1
-        "+OK"
-      end
-    }
-
-    redis_mock(commands) do |redis|
-      assert_equal 0, quit
-
-      redis.quit
-
-      assert_equal 1, quit
-
-      redis.ping
-
-      redis.close
-
-      assert_equal 1, quit
-
-      assert !redis.connected?
-    end
-  end
-
-  def test_disconnect
-    quit = 0
-
-    commands = {
-      :quit => lambda do
-        quit += 1
-        "+OK"
-      end
-    }
-
-    redis_mock(commands) do |redis|
-      assert_equal 0, quit
-
-      redis.quit
-
-      assert_equal 1, quit
-
-      redis.ping
-
-      redis.disconnect!
-
-      assert_equal 1, quit
-
-      assert !redis.connected?
-    end
-  end
-
-  def test_shutdown
-    commands = {
-      :shutdown => lambda { :exit }
-    }
-
-    redis_mock(commands) do |redis|
-      # SHUTDOWN does not reply: test that it does not raise here.
-      assert_equal nil, redis.shutdown
-    end
-  end
-
-  def test_shutdown_with_error
-    connections = 0
-    commands = {
-      :select => lambda { |*_| connections += 1; "+OK\r\n" },
-      :connections => lambda { ":#{connections}\r\n" },
-      :shutdown => lambda { "-ERR could not shutdown\r\n" }
-    }
-
-    redis_mock(commands) do |redis|
-      connections = redis.connections
-
-      # SHUTDOWN replies with an error: test that it gets raised
-      assert_raise Redis::CommandError do
-        redis.shutdown
-      end
-
-      # The connection should remain in tact
-      assert_equal connections, redis.connections
-    end
-  end
-
-  def test_shutdown_from_pipeline
-    commands = {
-      :shutdown => lambda { :exit }
-    }
-
-    redis_mock(commands) do |redis|
-      result = redis.pipelined do
-        redis.shutdown
-      end
-
-      assert_equal nil, result
-      assert !redis._client.connected?
-    end
-  end
-
-  def test_shutdown_with_error_from_pipeline
-    connections = 0
-    commands = {
-      :select => lambda { |*_| connections += 1; "+OK\r\n" },
-      :connections => lambda { ":#{connections}\r\n" },
-      :shutdown => lambda { "-ERR could not shutdown\r\n" }
-    }
-
-    redis_mock(commands) do |redis|
-      connections = redis.connections
-
-      # SHUTDOWN replies with an error: test that it gets raised
-      assert_raise Redis::CommandError do
-        redis.pipelined do
-          redis.shutdown
-        end
-      end
-
-      # The connection should remain in tact
-      assert_equal connections, redis.connections
-    end
-  end
-
-  def test_shutdown_from_multi_exec
-    commands = {
-      :multi => lambda { "+OK\r\n" },
-      :shutdown => lambda { "+QUEUED\r\n" },
-      :exec => lambda { :exit }
-    }
-
-    redis_mock(commands) do |redis|
-      result = redis.multi do
-        redis.shutdown
-      end
-
-      assert_equal nil, result
-      assert !redis._client.connected?
-    end
-  end
-
-  def test_shutdown_with_error_from_multi_exec
-    connections = 0
-    commands = {
-      :select => lambda { |*_| connections += 1; "+OK\r\n" },
-      :connections => lambda { ":#{connections}\r\n" },
-      :multi => lambda { "+OK\r\n" },
-      :shutdown => lambda { "+QUEUED\r\n" },
-      :exec => lambda { "*1\r\n-ERR could not shutdown\r\n" }
-    }
-
-    redis_mock(commands) do |redis|
-      connections = redis.connections
-
-      # SHUTDOWN replies with an error: test that it gets returned
-      # We should test for Redis::CommandError here, but hiredis doesn't yet do
-      # custom error classes.
-      err = nil
-
-      begin
-        redis.multi { redis.shutdown }
-      rescue => err
-      end
-
-      assert err.kind_of?(StandardError)
-
-      # The connection should remain intact
-      assert_equal connections, redis.connections
-    end
-  end
-
-  def test_slaveof
-    redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do |redis|
-      assert_equal "SLAVEOF somehost 6381", redis.slaveof("somehost", 6381)
-    end
-  end
-
-  def test_bgrewriteaof
-    redis_mock(:bgrewriteaof => lambda { "+BGREWRITEAOF" }) do |redis|
-      assert_equal "BGREWRITEAOF", redis.bgrewriteaof
-    end
-  end
-
-  def test_config_get
-    assert r.config(:get, "*")["timeout"] != nil
-
-    config = r.config(:get, "timeout")
-    assert_equal ["timeout"], config.keys
-    assert config.values.compact.size > 0
-  end
-
-  def test_config_set
-    begin
-      assert_equal "OK", r.config(:set, "timeout", 200)
-      assert_equal "200", r.config(:get, "*")["timeout"]
-
-      assert_equal "OK", r.config(:set, "timeout", 100)
-      assert_equal "100", r.config(:get, "*")["timeout"]
-    ensure
-      r.config :set, "timeout", 300
-    end
-  end
-
-  driver(:ruby, :hiredis) do
-    def test_consistency_on_multithreaded_env
-      t = nil
-
-      commands = {
-        :set => lambda { |key, value| t.kill; "+OK\r\n" },
-        :incr => lambda { |key| ":1\r\n" },
-      }
-
-      redis_mock(commands) do |redis|
-        t = Thread.new do
-          redis.set("foo", "bar")
-        end
-
-        t.join
-
-        assert_equal 1, redis.incr("baz")
-      end
-    end
-  end
-end

data/test/encoding_test.rb

@@ -1,14 +0,0 @@
-require_relative "helper"
-
-class TestEncoding < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_returns_properly_encoded_strings
-    with_external_encoding("UTF-8") do
-      r.set "foo", "שלום"
-
-      assert_equal "Shalom שלום", "Shalom " + r.get("foo")
-    end
-  end
-end

data/test/error_replies_test.rb

@@ -1,57 +0,0 @@
-require_relative "helper"
-
-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 with_reconnection_check
-    before = r.info["total_connections_received"]
-    yield(r)
-    after = r.info["total_connections_received"]
-  ensure
-    assert_equal before, after
-  end
-
-  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
-
-  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
-  end
-
-  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
-  end
-end

data/test/fork_safety_test.rb

@@ -1,60 +0,0 @@
-require_relative "helper"
-
-class TestForkSafety < Test::Unit::TestCase
-
-  include Helper::Client
-
-  driver(:ruby, :hiredis) do
-    def test_fork_safety
-      redis = Redis.new(OPTIONS)
-      redis.set "foo", 1
-
-      child_pid = fork do
-        begin
-          # InheritedError triggers a reconnect,
-          # so we need to disable reconnects to force
-          # the exception bubble up
-          redis.without_reconnect do
-            redis.set "foo", 2
-          end
-        rescue Redis::InheritedError
-          exit 127
-        end
-      end
-
-      _, status = Process.wait2(child_pid)
-
-      assert_equal 127, status.exitstatus
-      assert_equal "1", redis.get("foo")
-
-    rescue NotImplementedError => error
-      raise unless error.message =~ /fork is not available/
-    end
-
-    def test_fork_safety_with_enabled_inherited_socket
-      redis = Redis.new(OPTIONS.merge(:inherit_socket => true))
-      redis.set "foo", 1
-
-      child_pid = fork do
-        begin
-          # InheritedError triggers a reconnect,
-          # so we need to disable reconnects to force
-          # the exception bubble up
-          redis.without_reconnect do
-            redis.set "foo", 2
-          end
-        rescue Redis::InheritedError
-          exit 127
-        end
-      end
-
-      _, status = Process.wait2(child_pid)
-
-      assert_equal 0, status.exitstatus
-      assert_equal "2", redis.get("foo")
-
-    rescue NotImplementedError => error
-      raise unless error.message =~ /fork is not available/
-    end
-  end
-end

data/test/helper.rb

@@ -1,179 +0,0 @@
-require "test/unit"
-require "logger"
-require "stringio"
-
-$VERBOSE = true
-
-ENV["DRIVER"] ||= "ruby"
-
-require_relative "../lib/redis"
-require_relative "../lib/redis/connection/#{ENV["DRIVER"]}"
-
-require_relative "support/redis_mock"
-require_relative "support/connection/#{ENV["DRIVER"]}"
-
-PORT    = 6381
-OPTIONS = {:port => PORT, :db => 15, :timeout => Float(ENV["TIMEOUT"] || 0.1)}
-NODES   = ["redis://127.0.0.1:#{PORT}/15"]
-
-def init(redis)
-  begin
-    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 #{PORT}.
-      This testing suite connects to the database 15.
-
-      Try this once:
-
-        $ make clean
-
-      Then run the build again:
-
-        $ make
-
-    EOS
-    exit 1
-  end
-end
-
-def driver(*drivers, &blk)
-  if drivers.map(&:to_s).include?(ENV["DRIVER"])
-    class_eval(&blk)
-  end
-end
-
-module Helper
-
-  def run(runner)
-    if respond_to?(:around)
-      around { super(runner) }
-    else
-      super
-    end
-  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
-
-  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 <=>(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.to_i <=> b.to_i if a != b
-      end
-
-      0
-    end
-  end
-
-  module Generic
-
-    include Helper
-
-    attr_reader :log
-    attr_reader :redis
-
-    alias :r :redis
-
-    def setup
-      @log = StringIO.new
-      @redis = init _new_client
-
-      # Run GC to make sure orphaned connections are closed.
-      GC.start
-    end
-
-    def teardown
-      @redis.quit if @redis
-    end
-
-    def redis_mock(commands, options = {}, &blk)
-      RedisMock.start(commands, options) do |port|
-        yield _new_client(options.merge(:port => port))
-      end
-    end
-
-    def redis_mock_with_handler(handler, options = {}, &blk)
-      RedisMock.start_with_handler(handler, options) do |port|
-        yield _new_client(options.merge(:port => port))
-      end
-    end
-
-    def assert_in_range(range, value)
-      assert range.include?(value), "expected #{value} to be in #{range.inspect}"
-    end
-
-    def target_version(target)
-      if version < target
-        skip("Requires Redis > #{target}") if respond_to?(:skip)
-      else
-        yield
-      end
-    end
-  end
-
-  module Client
-
-    include Generic
-
-    def version
-      Version.new(redis.info["redis_version"])
-    end
-
-    private
-
-    def _format_options(options)
-      OPTIONS.merge(:logger => ::Logger.new(@log)).merge(options)
-    end
-
-    def _new_client(options = {})
-      Redis.new(_format_options(options).merge(:driver => ENV["DRIVER"]))
-    end
-  end
-
-end

data/test/helper_test.rb

@@ -1,22 +0,0 @@
-require_relative "helper"
-
-class TestHelper < Test::Unit::TestCase
-
-  include Helper
-
-  def test_version_comparison
-    v = Version.new("2.0.1")
-
-    assert v > "1"
-    assert v > "2"
-    assert v < "3"
-    assert v < "10"
-
-    assert v < "2.1"
-    assert v < "2.0.2"
-    assert v < "2.0.1.1"
-    assert v < "2.0.10"
-
-    assert v == "2.0.1"
-  end
-end