redis 3.0.0 → 4.5.0

data/test/helper_test.rb

@@ -1,22 +0,0 @@
-# encoding: UTF-8
-
-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,214 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestInternals < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_logger
-    r.ping
-
-    assert log.string =~ /Redis >> PING/
-      assert log.string =~ /Redis >> \d+\.\d+ms/
-  end
-
-  def test_logger_with_pipelining
-    r.pipelined do
-      r.set "foo", "bar"
-      r.get "foo"
-    end
-
-    assert log.string["SET foo bar"]
-    assert log.string["GET foo"]
-  end
-
-  def test_recovers_from_failed_commands
-    # See https://github.com/redis/redis-rb/issues#issue/28
-
-    assert_raise(Redis::CommandError) do
-      r.command_that_doesnt_exist
-    end
-
-    assert_nothing_raised do
-      r.info
-    end
-  end
-
-  def test_raises_on_protocol_errors
-    redis_mock(:ping => lambda { |*_| "foo" }) do |redis|
-      assert_raise(Redis::ProtocolError) do
-        redis.ping
-      end
-    end
-  end
-
-  def test_provides_a_meaningful_inspect
-    assert_equal "#<Redis client v#{Redis::VERSION} for redis://127.0.0.1:#{PORT}/15>", r.inspect
-  end
-
-  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_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
-
-  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
-
-  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
-
-  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
-
-  def test_override_id
-    redis = Redis.new(OPTIONS.merge(:id => "test"))
-    assert_equal redis.client.id, "test"
-  end
-
-  def test_timeout
-    assert_nothing_raised do
-      Redis.new(OPTIONS.merge(:timeout => 0))
-    end
-  end
-
-  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 close_on_ping(seq)
-    $request = 0
-
-    command = lambda do
-      idx = $request
-      $request += 1
-
-      rv = "+%d" % idx
-      rv = nil if seq.include?(idx)
-      rv
-    end
-
-    redis_mock(:ping => command, :timeout => 0.1) do |redis|
-      yield(redis)
-    end
-  end
-
-  def test_retry_by_default
-    close_on_ping([0]) do |redis|
-      assert_equal "1", redis.ping
-    end
-  end
-
-  def test_retry_when_wrapped_in_with_reconnect_true
-    close_on_ping([0]) do |redis|
-      redis.with_reconnect(true) do
-        assert_equal "1", redis.ping
-      end
-    end
-  end
-
-  def test_dont_retry_when_wrapped_in_with_reconnect_false
-    close_on_ping([0]) do |redis|
-      assert_raise Redis::ConnectionError do
-        redis.with_reconnect(false) do
-          redis.ping
-        end
-      end
-    end
-  end
-
-  def test_dont_retry_when_wrapped_in_without_reconnect
-    close_on_ping([0]) do |redis|
-      assert_raise Redis::ConnectionError do
-        redis.without_reconnect do
-          redis.ping
-        end
-      end
-    end
-  end
-
-  def test_retry_only_once_when_read_raises_econnreset
-    close_on_ping([0, 1]) do |redis|
-      assert_raise Redis::ConnectionError do
-        redis.ping
-      end
-
-      assert !redis.client.connected?
-    end
-  end
-
-  def test_don_t_retry_when_second_read_in_pipeline_raises_econnreset
-    close_on_ping([1]) do |redis|
-      assert_raise Redis::ConnectionError do
-        redis.pipelined do
-          redis.ping
-          redis.ping # Second #read times out
-        end
-      end
-
-      assert !redis.client.connected?
-    end
-  end
-
-  def test_connecting_to_unix_domain_socket
-    assert_nothing_raised do
-      Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock")).ping
-    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

data/test/lint/blocking_commands.rb

@@ -1,124 +0,0 @@
-module Lint
-
-  module BlockingCommands
-
-    def setup
-      super
-
-      r.rpush("{zap}foo", "s1")
-      r.rpush("{zap}foo", "s2")
-      r.rpush("{zap}bar", "s1")
-      r.rpush("{zap}bar", "s2")
-    end
-
-    def to_protocol(obj)
-      case obj
-      when String
-        "$#{obj.length}\r\n#{obj}\r\n"
-      when Array
-        "*#{obj.length}\r\n" + obj.map { |e| to_protocol(e) }.join
-      else
-        fail
-      end
-    end
-
-    def mock(options = {}, &blk)
-      commands = {
-        :blpop => lambda do |*args|
-          sleep options[:delay] if options.has_key?(:delay)
-          to_protocol([args.first, args.last])
-        end,
-        :brpop => lambda do |*args|
-          sleep options[:delay] if options.has_key?(:delay)
-          to_protocol([args.first, args.last])
-        end,
-        :brpoplpush => lambda do |*args|
-          sleep options[:delay] if options.has_key?(:delay)
-          to_protocol(args.last)
-        end,
-      }
-
-      redis_mock(commands, &blk)
-    end
-
-    def test_blpop
-      assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo")
-      assert_equal ["{zap}foo", "s2"], r.blpop(["{zap}foo"])
-      assert_equal ["{zap}bar", "s1"], r.blpop(["{zap}bar", "{zap}foo"])
-      assert_equal ["{zap}bar", "s2"], r.blpop(["{zap}foo", "{zap}bar"])
-    end
-
-    def test_blpop_timeout
-      mock do |r|
-        assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo")
-        assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", :timeout => 1)
-      end
-    end
-
-    def test_blpop_with_old_prototype
-      assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo", 0)
-      assert_equal ["{zap}foo", "s2"], r.blpop("{zap}foo", 0)
-      assert_equal ["{zap}bar", "s1"], r.blpop("{zap}bar", "{zap}foo", 0)
-      assert_equal ["{zap}bar", "s2"], r.blpop("{zap}foo", "{zap}bar", 0)
-    end
-
-    def test_blpop_timeout_with_old_prototype
-      mock do |r|
-        assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo", 0)
-        assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", 1)
-      end
-    end
-
-    def test_brpop
-      assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo")
-      assert_equal ["{zap}foo", "s1"], r.brpop(["{zap}foo"])
-      assert_equal ["{zap}bar", "s2"], r.brpop(["{zap}bar", "{zap}foo"])
-      assert_equal ["{zap}bar", "s1"], r.brpop(["{zap}foo", "{zap}bar"])
-    end
-
-    def test_brpop_timeout
-      mock do |r|
-        assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo")
-        assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", :timeout => 1)
-      end
-    end
-
-    def test_brpop_with_old_prototype
-      assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo", 0)
-      assert_equal ["{zap}foo", "s1"], r.brpop("{zap}foo", 0)
-      assert_equal ["{zap}bar", "s2"], r.brpop("{zap}bar", "{zap}foo", 0)
-      assert_equal ["{zap}bar", "s1"], r.brpop("{zap}foo", "{zap}bar", 0)
-    end
-
-    def test_brpop_timeout_with_old_prototype
-      mock do |r|
-        assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo", 0)
-        assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", 1)
-      end
-    end
-
-    def test_brpoplpush
-      assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux")
-      assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
-    end
-
-    def test_brpoplpush_timeout
-      mock do |r|
-        assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar")
-        assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
-      end
-    end
-
-    def test_brpoplpush_with_old_prototype
-      assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux", 0)
-      assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
-    end
-
-    def test_brpoplpush_timeout_with_old_prototype
-      mock do |r|
-        assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar", 0)
-        assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", 1)
-      end
-    end
-  end
-end

data/test/lint/hashes.rb

@@ -1,162 +0,0 @@
-module Lint
-
-  module Hashes
-
-    def test_hset_and_hget
-      r.hset("foo", "f1", "s1")
-
-      assert_equal "s1", r.hget("foo", "f1")
-    end
-
-    def test_hsetnx
-      r.hset("foo", "f1", "s1")
-      r.hsetnx("foo", "f1", "s2")
-
-      assert_equal "s1", r.hget("foo", "f1")
-
-      r.del("foo")
-      r.hsetnx("foo", "f1", "s2")
-
-      assert_equal "s2", r.hget("foo", "f1")
-    end
-
-    def test_hdel
-      r.hset("foo", "f1", "s1")
-
-      assert_equal "s1", r.hget("foo", "f1")
-
-      assert_equal 1, r.hdel("foo", "f1")
-
-      assert_equal nil, r.hget("foo", "f1")
-    end
-
-    def test_variadic_hdel
-      return if version < "2.3.9"
-
-      r.hset("foo", "f1", "s1")
-      r.hset("foo", "f2", "s2")
-
-      assert_equal "s1", r.hget("foo", "f1")
-      assert_equal "s2", r.hget("foo", "f2")
-
-      assert_equal 2, r.hdel("foo", ["f1", "f2"])
-
-      assert_equal nil, r.hget("foo", "f1")
-      assert_equal nil, r.hget("foo", "f2")
-    end
-
-    def test_hexists
-      assert_equal false, r.hexists("foo", "f1")
-
-      r.hset("foo", "f1", "s1")
-
-      assert r.hexists("foo", "f1")
-    end
-
-    def test_hlen
-      assert_equal 0, r.hlen("foo")
-
-      r.hset("foo", "f1", "s1")
-
-      assert_equal 1, r.hlen("foo")
-
-      r.hset("foo", "f2", "s2")
-
-      assert_equal 2, r.hlen("foo")
-    end
-
-    def test_hkeys
-      assert_equal [], r.hkeys("foo")
-
-      r.hset("foo", "f1", "s1")
-      r.hset("foo", "f2", "s2")
-
-      assert_equal ["f1", "f2"], r.hkeys("foo")
-    end
-
-    def test_hvals
-      assert_equal [], r.hvals("foo")
-
-      r.hset("foo", "f1", "s1")
-      r.hset("foo", "f2", "s2")
-
-      assert_equal ["s1", "s2"], r.hvals("foo")
-    end
-
-    def test_hgetall
-      assert({} == r.hgetall("foo"))
-
-      r.hset("foo", "f1", "s1")
-      r.hset("foo", "f2", "s2")
-
-      assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo"))
-    end
-
-    def test_hmset
-      r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
-
-      assert_equal "bar1", r.hget("hash", "foo1")
-      assert_equal "bar2", r.hget("hash", "foo2")
-    end
-
-    def test_hmset_with_invalid_arguments
-      assert_raise(Redis::CommandError) do
-        r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
-      end
-    end
-
-    def test_mapped_hmset
-      r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2")
-
-      assert_equal "s1", r.hget("foo", "f1")
-      assert_equal "s2", r.hget("foo", "f2")
-    end
-
-    def test_hmget
-      r.hset("foo", "f1", "s1")
-      r.hset("foo", "f2", "s2")
-      r.hset("foo", "f3", "s3")
-
-      assert_equal ["s2", "s3"], r.hmget("foo", "f2", "f3")
-    end
-
-    def test_hmget_mapped
-      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
-
-    def test_hincrby
-      r.hincrby("foo", "f1", 1)
-
-      assert_equal "1", r.hget("foo", "f1")
-
-      r.hincrby("foo", "f1", 2)
-
-      assert_equal "3", r.hget("foo", "f1")
-
-      r.hincrby("foo", "f1", -1)
-
-      assert_equal "2", r.hget("foo", "f1")
-    end
-
-    def test_hincrbyfloat
-      return if version < "2.5.4"
-
-      r.hincrbyfloat("foo", "f1", 1.23)
-
-      assert_equal "1.23", r.hget("foo", "f1")
-
-      r.hincrbyfloat("foo", "f1", 0.77)
-
-      assert_equal "2", r.hget("foo", "f1")
-
-      r.hincrbyfloat("foo", "f1", -0.1)
-
-      assert_equal "1.9", r.hget("foo", "f1")
-    end
-  end
-end

data/test/lint/lists.rb

@@ -1,143 +0,0 @@
-module Lint
-
-  module Lists
-
-    def test_lpush
-      r.lpush "foo", "s1"
-      r.lpush "foo", "s2"
-
-      assert_equal 2, r.llen("foo")
-      assert_equal "s2", r.lpop("foo")
-    end
-
-    def test_variadic_lpush
-      return if version < "2.3.9" # 2.4-rc6
-
-      assert_equal 3, r.lpush("foo", ["s1", "s2", "s3"])
-      assert_equal 3, r.llen("foo")
-      assert_equal "s3", r.lpop("foo")
-    end
-
-    def test_lpushx
-      r.lpushx "foo", "s1"
-      r.lpush "foo", "s2"
-      r.lpushx "foo", "s3"
-
-      assert_equal 2, r.llen("foo")
-      assert_equal ["s3", "s2"], r.lrange("foo", 0, -1)
-    end
-
-    def test_rpush
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-
-      assert_equal 2, r.llen("foo")
-      assert_equal "s2", r.rpop("foo")
-    end
-
-    def test_variadic_rpush
-      return if version < "2.3.9" # 2.4-rc6
-
-      assert_equal 3, r.rpush("foo", ["s1", "s2", "s3"])
-      assert_equal 3, r.llen("foo")
-      assert_equal "s3", r.rpop("foo")
-    end
-
-    def test_rpushx
-      r.rpushx "foo", "s1"
-      r.rpush "foo", "s2"
-      r.rpushx "foo", "s3"
-
-      assert_equal 2, r.llen("foo")
-      assert_equal ["s2", "s3"], r.lrange("foo", 0, -1)
-    end
-
-    def test_llen
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-
-      assert_equal 2, r.llen("foo")
-    end
-
-    def test_lrange
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-      r.rpush "foo", "s3"
-
-      assert_equal ["s2", "s3"], r.lrange("foo", 1, -1)
-      assert_equal ["s1", "s2"], r.lrange("foo", 0, 1)
-
-      assert_equal [], r.lrange("bar", 0, -1)
-    end
-
-    def test_ltrim
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-      r.rpush "foo", "s3"
-
-      r.ltrim "foo", 0, 1
-
-      assert_equal 2, r.llen("foo")
-      assert_equal ["s1", "s2"], r.lrange("foo", 0, -1)
-    end
-
-    def test_lindex
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-
-      assert_equal "s1", r.lindex("foo", 0)
-      assert_equal "s2", r.lindex("foo", 1)
-    end
-
-    def test_lset
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-
-      assert_equal "s2", r.lindex("foo", 1)
-      assert r.lset("foo", 1, "s3")
-      assert_equal "s3", r.lindex("foo", 1)
-
-      assert_raise Redis::CommandError do
-        r.lset("foo", 4, "s3")
-      end
-    end
-
-    def test_lrem
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-
-      assert_equal 1, r.lrem("foo", 1, "s1")
-      assert_equal ["s2"], r.lrange("foo", 0, -1)
-    end
-
-    def test_lpop
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-
-      assert_equal 2, r.llen("foo")
-      assert_equal "s1", r.lpop("foo")
-      assert_equal 1, r.llen("foo")
-    end
-
-    def test_rpop
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s2"
-
-      assert_equal 2, r.llen("foo")
-      assert_equal "s2", r.rpop("foo")
-      assert_equal 1, r.llen("foo")
-    end
-
-    def test_linsert
-      r.rpush "foo", "s1"
-      r.rpush "foo", "s3"
-      r.linsert "foo", :before, "s3", "s2"
-
-      assert_equal ["s1", "s2", "s3"], r.lrange("foo", 0, -1)
-
-      assert_raise(Redis::CommandError) do
-        r.linsert "foo", :anywhere, "s3", "s2"
-      end
-    end
-  end
-end