redis 4.0.0 → 5.0.0

data/test/blocking_commands_test.rb

@@ -1,40 +0,0 @@
-require_relative "helper"
-require_relative "lint/blocking_commands"
-
-class TestBlockingCommands < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::BlockingCommands
-
-  def assert_takes_longer_than_client_timeout
-    timeout = OPTIONS[:timeout]
-    delay = timeout * 2
-
-    mock(:delay => delay) do |r|
-      t1 = Time.now
-      yield(r)
-      t2 = Time.now
-
-      assert timeout == r._client.timeout
-      assert delay <= (t2 - t1)
-    end
-  end
-
-  def test_blpop_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal ["foo", "0"], r.blpop("foo")
-    end
-  end
-
-  def test_brpop_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal ["foo", "0"], r.brpop("foo")
-    end
-  end
-
-  def test_brpoplpush_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal "0", r.brpoplpush("foo", "bar")
-    end
-  end
-end

data/test/client_test.rb

@@ -1,59 +0,0 @@
-require_relative "helper"
-
-class TestClient < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_call
-    result = r.call("PING")
-    assert_equal result, "PONG"
-  end
-
-  def test_call_with_arguments
-    result = r.call("SET", "foo", "bar")
-    assert_equal result, "OK"
-  end
-
-  def test_call_integers
-    result = r.call("INCR", "foo")
-    assert_equal result, 1
-  end
-
-  def test_call_raise
-    assert_raises(Redis::CommandError) do
-      r.call("INCR")
-    end
-  end
-
-  def test_queue_commit
-    r.queue("SET", "foo", "bar")
-    r.queue("GET", "foo")
-    result = r.commit
-
-    assert_equal result, ["OK", "bar"]
-  end
-
-  def test_commit_raise
-    r.queue("SET", "foo", "bar")
-    r.queue("INCR")
-
-    assert_raise(Redis::CommandError) do
-      r.commit
-    end
-  end
-
-  def test_queue_after_error
-    r.queue("SET", "foo", "bar")
-    r.queue("INCR")
-
-    assert_raise(Redis::CommandError) do
-      r.commit
-    end
-
-    r.queue("SET",  "foo", "bar")
-    r.queue("INCR", "baz")
-    result = r.commit
-
-    assert_equal result, ["OK", 1]
-  end
-end

data/test/command_map_test.rb

@@ -1,28 +0,0 @@
-require_relative "helper"
-
-class TestCommandMap < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_override_existing_commands
-    r.set("counter", 1)
-
-    assert_equal 2, r.incr("counter")
-
-    r._client.command_map[:incr] = :decr
-
-    assert_equal 1, r.incr("counter")
-  end
-
-  def test_override_non_existing_commands
-    r.set("key", "value")
-
-    assert_raise Redis::CommandError do
-      r.idontexist("key")
-    end
-
-    r._client.command_map[:idontexist] = :get
-
-    assert_equal "value", r.idontexist("key")
-  end
-end

data/test/commands_on_hashes_test.rb

@@ -1,19 +0,0 @@
-require_relative "helper"
-require_relative "lint/hashes"
-
-class TestCommandsOnHashes < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::Hashes
-
-  def test_mapped_hmget_in_a_pipeline_returns_hash
-    r.hset("foo", "f1", "s1")
-    r.hset("foo", "f2", "s2")
-
-    result = r.pipelined do
-      r.mapped_hmget("foo", "f1", "f2")
-    end
-
-    assert_equal result[0], { "f1" => "s1", "f2" => "s2" }
-  end
-end

data/test/commands_on_hyper_log_log_test.rb

@@ -1,19 +0,0 @@
-require_relative "helper"
-require_relative "lint/hyper_log_log"
-
-class TestCommandsOnHyperLogLog < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::HyperLogLog
-
-  def test_pfmerge
-    target_version "2.8.9" do
-      r.pfadd "foo", "s1"
-      r.pfadd "bar", "s2"
-
-      assert_equal true, r.pfmerge("res", "foo", "bar")
-      assert_equal 2, r.pfcount("res")
-    end
-  end
-
-end

data/test/commands_on_lists_test.rb

@@ -1,18 +0,0 @@
-require_relative "helper"
-require_relative "lint/lists"
-
-class TestCommandsOnLists < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::Lists
-
-  def test_rpoplpush
-    r.rpush "foo", "s1"
-    r.rpush "foo", "s2"
-
-    assert_equal "s2", r.rpoplpush("foo", "bar")
-    assert_equal ["s2"], r.lrange("bar", 0, -1)
-    assert_equal "s1", r.rpoplpush("foo", "bar")
-    assert_equal ["s1", "s2"], r.lrange("bar", 0, -1)
-  end
-end

data/test/commands_on_sets_test.rb

@@ -1,75 +0,0 @@
-require_relative "helper"
-require_relative "lint/sets"
-
-class TestCommandsOnSets < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::Sets
-
-  def test_smove
-    r.sadd "foo", "s1"
-    r.sadd "bar", "s2"
-
-    assert r.smove("foo", "bar", "s1")
-    assert r.sismember("bar", "s1")
-  end
-
-  def test_sinter
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-
-    assert_equal ["s2"], r.sinter("foo", "bar")
-  end
-
-  def test_sinterstore
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-
-    r.sinterstore("baz", "foo", "bar")
-
-    assert_equal ["s2"], r.smembers("baz")
-  end
-
-  def test_sunion
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-    r.sadd "bar", "s3"
-
-    assert_equal ["s1", "s2", "s3"], r.sunion("foo", "bar").sort
-  end
-
-  def test_sunionstore
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-    r.sadd "bar", "s3"
-
-    r.sunionstore("baz", "foo", "bar")
-
-    assert_equal ["s1", "s2", "s3"], r.smembers("baz").sort
-  end
-
-  def test_sdiff
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-    r.sadd "bar", "s3"
-
-    assert_equal ["s1"], r.sdiff("foo", "bar")
-    assert_equal ["s3"], r.sdiff("bar", "foo")
-  end
-
-  def test_sdiffstore
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-    r.sadd "bar", "s3"
-
-    r.sdiffstore("baz", "foo", "bar")
-
-    assert_equal ["s1"], r.smembers("baz")
-  end
-end

data/test/commands_on_sorted_sets_test.rb

@@ -1,150 +0,0 @@
-require_relative "helper"
-require_relative "lint/sorted_sets"
-
-class TestCommandsOnSortedSets < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::SortedSets
-
-  def test_zlexcount
-    target_version "2.8.9" do
-      r.zadd "foo", 0, "aaren"
-      r.zadd "foo", 0, "abagael"
-      r.zadd "foo", 0, "abby"
-      r.zadd "foo", 0, "abbygail"
-
-      assert_equal 4, r.zlexcount("foo", "[a", "[a\xff")
-      assert_equal 4, r.zlexcount("foo", "[aa", "[ab\xff")
-      assert_equal 3, r.zlexcount("foo", "(aaren", "[ab\xff")
-      assert_equal 2, r.zlexcount("foo", "[aba", "(abbygail")
-      assert_equal 1, r.zlexcount("foo", "(aaren", "(abby")
-    end
-  end
-
-  def test_zrangebylex
-    target_version "2.8.9" do
-      r.zadd "foo", 0, "aaren"
-      r.zadd "foo", 0, "abagael"
-      r.zadd "foo", 0, "abby"
-      r.zadd "foo", 0, "abbygail"
-
-      assert_equal ["aaren", "abagael", "abby", "abbygail"], r.zrangebylex("foo", "[a", "[a\xff")
-      assert_equal ["aaren", "abagael"], r.zrangebylex("foo", "[a", "[a\xff", :limit => [0, 2])
-      assert_equal ["abby", "abbygail"], r.zrangebylex("foo", "(abb", "(abb\xff")
-      assert_equal ["abbygail"], r.zrangebylex("foo", "(abby", "(abby\xff")
-    end
-  end
-
-  def test_zrevrangebylex
-    target_version "2.9.9" do
-      r.zadd "foo", 0, "aaren"
-      r.zadd "foo", 0, "abagael"
-      r.zadd "foo", 0, "abby"
-      r.zadd "foo", 0, "abbygail"
-
-      assert_equal ["abbygail", "abby", "abagael", "aaren"], r.zrevrangebylex("foo", "[a\xff", "[a")
-      assert_equal ["abbygail", "abby"], r.zrevrangebylex("foo", "[a\xff", "[a", :limit => [0, 2])
-      assert_equal ["abbygail", "abby"], r.zrevrangebylex("foo", "(abb\xff", "(abb")
-      assert_equal ["abbygail"], r.zrevrangebylex("foo", "(abby\xff", "(abby")
-    end
-  end
-
-  def test_zcount
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 2, "s2"
-    r.zadd "foo", 3, "s3"
-
-    assert_equal 2, r.zcount("foo", 2, 3)
-  end
-
-  def test_zunionstore
-    r.zadd "foo", 1, "s1"
-    r.zadd "bar", 2, "s2"
-    r.zadd "foo", 3, "s3"
-    r.zadd "bar", 4, "s4"
-
-    assert_equal 4, r.zunionstore("foobar", ["foo", "bar"])
-    assert_equal ["s1", "s2", "s3", "s4"], r.zrange("foobar", 0, -1)
-  end
-
-  def test_zunionstore_with_weights
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 3, "s3"
-    r.zadd "bar", 20, "s2"
-    r.zadd "bar", 40, "s4"
-
-    assert_equal 4, r.zunionstore("foobar", ["foo", "bar"])
-    assert_equal ["s1", "s3", "s2", "s4"], r.zrange("foobar", 0, -1)
-
-    assert_equal 4, r.zunionstore("foobar", ["foo", "bar"], :weights => [10, 1])
-    assert_equal ["s1", "s2", "s3", "s4"], r.zrange("foobar", 0, -1)
-  end
-
-  def test_zunionstore_with_aggregate
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 2, "s2"
-    r.zadd "bar", 4, "s2"
-    r.zadd "bar", 3, "s3"
-
-    assert_equal 3, r.zunionstore("foobar", ["foo", "bar"])
-    assert_equal ["s1", "s3", "s2"], r.zrange("foobar", 0, -1)
-
-    assert_equal 3, r.zunionstore("foobar", ["foo", "bar"], :aggregate => :min)
-    assert_equal ["s1", "s2", "s3"], r.zrange("foobar", 0, -1)
-
-    assert_equal 3, r.zunionstore("foobar", ["foo", "bar"], :aggregate => :max)
-    assert_equal ["s1", "s3", "s2"], r.zrange("foobar", 0, -1)
-  end
-
-  def test_zinterstore
-    r.zadd "foo", 1, "s1"
-    r.zadd "bar", 2, "s1"
-    r.zadd "foo", 3, "s3"
-    r.zadd "bar", 4, "s4"
-
-    assert_equal 1, r.zinterstore("foobar", ["foo", "bar"])
-    assert_equal ["s1"], r.zrange("foobar", 0, -1)
-  end
-
-  def test_zinterstore_with_weights
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 2, "s2"
-    r.zadd "foo", 3, "s3"
-    r.zadd "bar", 20, "s2"
-    r.zadd "bar", 30, "s3"
-    r.zadd "bar", 40, "s4"
-
-    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"])
-    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
-
-    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :weights => [10, 1])
-    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
-
-    assert_equal 40.0, r.zscore("foobar", "s2")
-    assert_equal 60.0, r.zscore("foobar", "s3")
-  end
-
-  def test_zinterstore_with_aggregate
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 2, "s2"
-    r.zadd "foo", 3, "s3"
-    r.zadd "bar", 20, "s2"
-    r.zadd "bar", 30, "s3"
-    r.zadd "bar", 40, "s4"
-
-    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"])
-    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
-    assert_equal 22.0, r.zscore("foobar", "s2")
-    assert_equal 33.0, r.zscore("foobar", "s3")
-
-    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :aggregate => :min)
-    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
-    assert_equal 2.0, r.zscore("foobar", "s2")
-    assert_equal 3.0, r.zscore("foobar", "s3")
-
-    assert_equal 2, r.zinterstore("foobar", ["foo", "bar"], :aggregate => :max)
-    assert_equal ["s2", "s3"], r.zrange("foobar", 0, -1)
-    assert_equal 20.0, r.zscore("foobar", "s2")
-    assert_equal 30.0, r.zscore("foobar", "s3")
-  end
-end

data/test/commands_on_strings_test.rb

@@ -1,99 +0,0 @@
-require_relative "helper"
-require_relative "lint/strings"
-
-class TestCommandsOnStrings < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::Strings
-
-  def test_mget
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    assert_equal ["s1", "s2"]     , r.mget("foo", "bar")
-    assert_equal ["s1", "s2", nil], r.mget("foo", "bar", "baz")
-  end
-
-  def test_mget_mapped
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    response = r.mapped_mget("foo", "bar")
-
-    assert_equal "s1", response["foo"]
-    assert_equal "s2", response["bar"]
-
-    response = r.mapped_mget("foo", "bar", "baz")
-
-    assert_equal "s1", response["foo"]
-    assert_equal "s2", response["bar"]
-    assert_equal nil , response["baz"]
-  end
-
-  def test_mapped_mget_in_a_pipeline_returns_hash
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    result = r.pipelined do
-      r.mapped_mget("foo", "bar")
-    end
-
-    assert_equal result[0], { "foo" => "s1", "bar" => "s2" }
-  end
-
-  def test_mset
-    r.mset(:foo, "s1", :bar, "s2")
-
-    assert_equal "s1", r.get("foo")
-    assert_equal "s2", r.get("bar")
-  end
-
-  def test_mset_mapped
-    r.mapped_mset(:foo => "s1", :bar => "s2")
-
-    assert_equal "s1", r.get("foo")
-    assert_equal "s2", r.get("bar")
-  end
-
-  def test_msetnx
-    r.set("foo", "s1")
-    assert_equal false, r.msetnx(:foo, "s2", :bar, "s3")
-    assert_equal "s1", r.get("foo")
-    assert_equal nil, r.get("bar")
-
-    r.del("foo")
-    assert_equal true, r.msetnx(:foo, "s2", :bar, "s3")
-    assert_equal "s2", r.get("foo")
-    assert_equal "s3", r.get("bar")
-  end
-
-  def test_msetnx_mapped
-    r.set("foo", "s1")
-    assert_equal false, r.mapped_msetnx(:foo => "s2", :bar => "s3")
-    assert_equal "s1", r.get("foo")
-    assert_equal nil, r.get("bar")
-
-    r.del("foo")
-    assert_equal true, r.mapped_msetnx(:foo => "s2", :bar => "s3")
-    assert_equal "s2", r.get("foo")
-    assert_equal "s3", r.get("bar")
-  end
-
-  def test_bitop
-    with_external_encoding("UTF-8") do
-      target_version "2.5.10" do
-        r.set("foo", "a")
-        r.set("bar", "b")
-
-        r.bitop(:and, "foo&bar", "foo", "bar")
-        assert_equal "\x60", r.get("foo&bar")
-        r.bitop(:or, "foo|bar", "foo", "bar")
-        assert_equal "\x63", r.get("foo|bar")
-        r.bitop(:xor, "foo^bar", "foo", "bar")
-        assert_equal "\x03", r.get("foo^bar")
-        r.bitop(:not, "~foo", "foo")
-        assert_equal "\x9E", r.get("~foo")
-      end
-    end
-  end
-end

data/test/commands_on_value_types_test.rb

@@ -1,131 +0,0 @@
-require_relative "helper"
-require_relative "lint/value_types"
-
-class TestCommandsOnValueTypes < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::ValueTypes
-
-  def test_del
-    r.set "foo", "s1"
-    r.set "bar", "s2"
-    r.set "baz", "s3"
-
-    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
-
-    assert_equal 1, r.del("foo")
-
-    assert_equal ["bar", "baz"], r.keys("*").sort
-
-    assert_equal 2, r.del("bar", "baz")
-
-    assert_equal [], r.keys("*").sort
-  end
-
-  def test_del_with_array_argument
-    r.set "foo", "s1"
-    r.set "bar", "s2"
-    r.set "baz", "s3"
-
-    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
-
-    assert_equal 1, r.del(["foo"])
-
-    assert_equal ["bar", "baz"], r.keys("*").sort
-
-    assert_equal 2, r.del(["bar", "baz"])
-
-    assert_equal [], r.keys("*").sort
-  end
-
-  def test_randomkey
-    assert r.randomkey.to_s.empty?
-
-    r.set("foo", "s1")
-
-    assert_equal "foo", r.randomkey
-
-    r.set("bar", "s2")
-
-    4.times do
-      assert ["foo", "bar"].include?(r.randomkey)
-    end
-  end
-
-  def test_rename
-    r.set("foo", "s1")
-    r.rename "foo", "bar"
-
-    assert_equal "s1", r.get("bar")
-    assert_equal nil, r.get("foo")
-  end
-
-  def test_renamenx
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    assert_equal false, r.renamenx("foo", "bar")
-
-    assert_equal "s1", r.get("foo")
-    assert_equal "s2", r.get("bar")
-  end
-
-  def test_dbsize
-    assert_equal 0, r.dbsize
-
-    r.set("foo", "s1")
-
-    assert_equal 1, r.dbsize
-  end
-
-  def test_flushdb
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    assert_equal 2, r.dbsize
-
-    r.flushdb
-
-    assert_equal 0, r.dbsize
-  end
-
-  def test_flushall
-    redis_mock(:flushall => lambda { "+FLUSHALL" }) do |redis|
-      assert_equal "FLUSHALL", redis.flushall
-    end
-  end
-
-  def test_migrate
-    redis_mock(:migrate => lambda { |*args| args }) do |redis|
-      options = { :host => "127.0.0.1", :port => 1234 }
-
-      ex = assert_raise(RuntimeError) do
-        redis.migrate("foo", options.reject { |key, _| key == :host })
-      end
-      assert ex.message =~ /host not specified/
-
-      ex = assert_raise(RuntimeError) do
-        redis.migrate("foo", options.reject { |key, _| key == :port })
-      end
-      assert ex.message =~ /port not specified/
-
-      default_db = redis._client.db.to_i
-      default_timeout = redis._client.timeout.to_i
-
-      # Test defaults
-      actual = redis.migrate("foo", options)
-      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, default_timeout.to_s]
-      assert_equal expected, actual
-
-      # Test db override
-      actual = redis.migrate("foo", options.merge(:db => default_db + 1))
-      expected = ["127.0.0.1", "1234", "foo", (default_db + 1).to_s, default_timeout.to_s]
-      assert_equal expected, actual
-
-      # Test timeout override
-      actual = redis.migrate("foo", options.merge(:timeout => default_timeout + 1))
-      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, (default_timeout + 1).to_s]
-      assert_equal expected, actual
-    end
-  end
-end