redis 4.0.3 → 4.5.0

data/test/distributed_blocking_commands_test.rb

@@ -1,52 +0,0 @@
-require_relative "helper"
-require_relative "lint/blocking_commands"
-
-class TestDistributedBlockingCommands < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::BlockingCommands
-
-  def test_blpop_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.blpop(["foo", "bar"])
-    end
-  end
-
-  def test_blpop_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.blpop("foo", "bar", 0)
-    end
-  end
-
-  def test_brpop_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpop(["foo", "bar"])
-    end
-  end
-
-  def test_brpop_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpop("foo", "bar", 0)
-    end
-  end
-
-  def test_brpoplpush_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpoplpush("foo", "bar")
-    end
-  end
-
-  def test_brpoplpush_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpoplpush("foo", "bar", 0)
-    end
-  end
-
-  def test_bzpopmin
-    # Not implemented yet
-  end
-
-  def test_bzpopmax
-    # Not implemented yet
-  end
-end

data/test/distributed_commands_on_hashes_test.rb

@@ -1,21 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/hashes'
-
-class TestDistributedCommandsOnHashes < Test::Unit::TestCase
-  include Helper::Distributed
-  include Lint::Hashes
-
-  def test_hscan
-    # Not implemented yet
-  end
-
-  def test_hstrlen
-    # Not implemented yet
-  end
-
-  def test_mapped_hmget_in_a_pipeline_returns_hash
-    assert_raise(Redis::Distributed::CannotDistribute) do
-      super
-    end
-  end
-end

data/test/distributed_commands_on_hyper_log_log_test.rb

@@ -1,26 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/hyper_log_log'
-
-class TestDistributedCommandsOnHyperLogLog < Test::Unit::TestCase
-  include Helper::Distributed
-  include Lint::HyperLogLog
-
-  def test_pfmerge
-    target_version '2.8.9' do
-      assert_raise Redis::Distributed::CannotDistribute do
-        super
-      end
-    end
-  end
-
-  def test_pfcount_multiple_keys_diff_nodes
-    target_version '2.8.9' do
-      assert_raise Redis::Distributed::CannotDistribute do
-        r.pfadd 'foo', 's1'
-        r.pfadd 'bar', 's2'
-
-        assert r.pfcount('res', 'foo', 'bar')
-      end
-    end
-  end
-end

data/test/distributed_commands_on_lists_test.rb

@@ -1,19 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/lists'
-
-class TestDistributedCommandsOnLists < Test::Unit::TestCase
-  include Helper::Distributed
-  include Lint::Lists
-
-  def test_rpoplpush
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.rpoplpush('foo', 'bar')
-    end
-  end
-
-  def test_brpoplpush
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.brpoplpush('foo', 'bar', timeout: 1)
-    end
-  end
-end

data/test/distributed_commands_on_sets_test.rb

@@ -1,105 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/sets'
-
-class TestDistributedCommandsOnSets < Test::Unit::TestCase
-  include Helper::Distributed
-  include Lint::Sets
-
-  def test_smove
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd 'foo', 's1'
-      r.sadd 'bar', 's2'
-
-      r.smove('foo', 'bar', 's1')
-    end
-  end
-
-  def test_sinter
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd 'foo', 's1'
-      r.sadd 'foo', 's2'
-      r.sadd 'bar', 's2'
-
-      r.sinter('foo', 'bar')
-    end
-  end
-
-  def test_sinterstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd 'foo', 's1'
-      r.sadd 'foo', 's2'
-      r.sadd 'bar', 's2'
-
-      r.sinterstore('baz', 'foo', 'bar')
-    end
-  end
-
-  def test_sunion
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd 'foo', 's1'
-      r.sadd 'foo', 's2'
-      r.sadd 'bar', 's2'
-      r.sadd 'bar', 's3'
-
-      r.sunion('foo', 'bar')
-    end
-  end
-
-  def test_sunionstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd 'foo', 's1'
-      r.sadd 'foo', 's2'
-      r.sadd 'bar', 's2'
-      r.sadd 'bar', 's3'
-
-      r.sunionstore('baz', 'foo', 'bar')
-    end
-  end
-
-  def test_sdiff
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd 'foo', 's1'
-      r.sadd 'foo', 's2'
-      r.sadd 'bar', 's2'
-      r.sadd 'bar', 's3'
-
-      r.sdiff('foo', 'bar')
-    end
-  end
-
-  def test_sdiffstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd 'foo', 's1'
-      r.sadd 'foo', 's2'
-      r.sadd 'bar', 's2'
-      r.sadd 'bar', 's3'
-
-      r.sdiffstore('baz', 'foo', 'bar')
-    end
-  end
-
-  def test_sscan
-    assert_nothing_raised do
-      r.sadd 'foo', 's1'
-      r.sadd 'foo', 's2'
-      r.sadd 'bar', 's2'
-      r.sadd 'bar', 's3'
-
-      cursor, vals = r.sscan 'foo', 0
-      assert_equal '0', cursor
-      assert_equal %w[s1 s2], vals.sort
-    end
-  end
-
-  def test_sscan_each
-    assert_nothing_raised do
-      r.sadd 'foo', 's1'
-      r.sadd 'foo', 's2'
-      r.sadd 'bar', 's2'
-      r.sadd 'bar', 's3'
-
-      vals = r.sscan_each('foo').to_a
-      assert_equal %w[s1 s2], vals.sort
-    end
-  end
-end

data/test/distributed_commands_on_sorted_sets_test.rb

@@ -1,59 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/sorted_sets'
-
-class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase
-  include Helper::Distributed
-  include Lint::SortedSets
-
-  def test_zinterstore
-    assert_raise(Redis::Distributed::CannotDistribute) { super }
-  end
-
-  def test_zinterstore_with_aggregate
-    assert_raise(Redis::Distributed::CannotDistribute) { super }
-  end
-
-  def test_zinterstore_with_weights
-    assert_raise(Redis::Distributed::CannotDistribute) { super }
-  end
-
-  def test_zlexcount
-    # Not implemented yet
-  end
-
-  def test_zpopmax
-    # Not implemented yet
-  end
-
-  def test_zpopmin
-    # Not implemented yet
-  end
-
-  def test_zrangebylex
-    # Not implemented yet
-  end
-
-  def test_zremrangebylex
-    # Not implemented yet
-  end
-
-  def test_zrevrangebylex
-    # Not implemented yet
-  end
-
-  def test_zscan
-    # Not implemented yet
-  end
-
-  def test_zunionstore
-    assert_raise(Redis::Distributed::CannotDistribute) { super }
-  end
-
-  def test_zunionstore_with_aggregate
-    assert_raise(Redis::Distributed::CannotDistribute) { super }
-  end
-
-  def test_zunionstore_with_weights
-    assert_raise(Redis::Distributed::CannotDistribute) { super }
-  end
-end

data/test/distributed_commands_on_strings_test.rb

@@ -1,79 +0,0 @@
-require_relative "helper"
-require_relative "lint/strings"
-
-class TestDistributedCommandsOnStrings < Test::Unit::TestCase
-
-  include Helper::Distributed
-  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_mset
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mset(:foo, "s1", :bar, "s2")
-    end
-  end
-
-  def test_mset_mapped
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mapped_mset(:foo => "s1", :bar => "s2")
-    end
-  end
-
-  def test_msetnx
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.msetnx(:foo, "s2", :bar, "s3")
-    end
-  end
-
-  def test_msetnx_mapped
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.mapped_msetnx(:foo => "s2", :bar => "s3")
-    end
-  end
-
-  def test_bitop
-    target_version "2.5.10" do
-      assert_raise Redis::Distributed::CannotDistribute do
-        r.set("foo", "a")
-        r.set("bar", "b")
-
-        r.bitop(:and, "foo&bar", "foo", "bar")
-      end
-    end
-  end
-
-  def test_mapped_mget_in_a_pipeline_returns_hash
-    assert_raise Redis::Distributed::CannotDistribute do
-      super
-    end
-  end
-
-  def test_bitfield
-    # Not implemented yet
-  end
-end

data/test/distributed_commands_on_value_types_test.rb

@@ -1,129 +0,0 @@
-require_relative "helper"
-require_relative "lint/value_types"
-
-class TestDistributedCommandsOnValueTypes < Test::Unit::TestCase
-
-  include Helper::Distributed
-  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_unlink
-    target_version "4.0.0" do
-      r.set "foo", "s1"
-      r.set "bar", "s2"
-      r.set "baz", "s3"
-
-      assert_equal ["bar", "baz", "foo"], r.keys("*").sort
-
-      assert_equal 1, r.unlink("foo")
-
-      assert_equal ["bar", "baz"], r.keys("*").sort
-
-      assert_equal 2, r.unlink("bar", "baz")
-
-      assert_equal [], r.keys("*").sort
-    end
-  end
-
-  def test_unlink_with_array_argument
-    target_version "4.0.0" do
-      r.set "foo", "s1"
-      r.set "bar", "s2"
-      r.set "baz", "s3"
-
-      assert_equal ["bar", "baz", "foo"], r.keys("*").sort
-
-      assert_equal 1, r.unlink(["foo"])
-
-      assert_equal ["bar", "baz"], r.keys("*").sort
-
-      assert_equal 2, r.unlink(["bar", "baz"])
-
-      assert_equal [], r.keys("*").sort
-    end
-  end
-
-  def test_randomkey
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.randomkey
-    end
-  end
-
-  def test_rename
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.rename "foo", "bar"
-    end
-
-    assert_equal "s1", r.get("foo")
-    assert_equal nil, r.get("bar")
-  end
-
-  def test_renamenx
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.rename "foo", "bar"
-    end
-
-    assert_equal "s1", r.get("foo")
-    assert_equal nil , 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_migrate
-    r.set("foo", "s1")
-
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.migrate("foo", {})
-    end
-  end
-end

data/test/distributed_commands_requiring_clustering_test.rb

@@ -1,162 +0,0 @@
-require_relative "helper"
-
-class TestDistributedCommandsRequiringClustering < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_rename
-    r.set("{qux}foo", "s1")
-    r.rename "{qux}foo", "{qux}bar"
-
-    assert_equal "s1", r.get("{qux}bar")
-    assert_equal nil, r.get("{qux}foo")
-  end
-
-  def test_renamenx
-    r.set("{qux}foo", "s1")
-    r.set("{qux}bar", "s2")
-
-    assert_equal false, r.renamenx("{qux}foo", "{qux}bar")
-
-    assert_equal "s1", r.get("{qux}foo")
-    assert_equal "s2", r.get("{qux}bar")
-  end
-
-  def test_brpoplpush
-    r.rpush "{qux}foo", "s1"
-    r.rpush "{qux}foo", "s2"
-
-    assert_equal "s2", r.brpoplpush("{qux}foo", "{qux}bar", :timeout => 1)
-    assert_equal ["s2"], r.lrange("{qux}bar", 0, -1)
-  end
-
-  def test_rpoplpush
-    r.rpush "{qux}foo", "s1"
-    r.rpush "{qux}foo", "s2"
-
-    assert_equal "s2", r.rpoplpush("{qux}foo", "{qux}bar")
-    assert_equal ["s2"], r.lrange("{qux}bar", 0, -1)
-    assert_equal "s1", r.rpoplpush("{qux}foo", "{qux}bar")
-    assert_equal ["s1", "s2"], r.lrange("{qux}bar", 0, -1)
-  end
-
-  def test_smove
-    r.sadd "{qux}foo", "s1"
-    r.sadd "{qux}bar", "s2"
-
-    assert r.smove("{qux}foo", "{qux}bar", "s1")
-    assert r.sismember("{qux}bar", "s1")
-  end
-
-  def test_sinter
-    r.sadd "{qux}foo", "s1"
-    r.sadd "{qux}foo", "s2"
-    r.sadd "{qux}bar", "s2"
-
-    assert_equal ["s2"], r.sinter("{qux}foo", "{qux}bar")
-  end
-
-  def test_sinterstore
-    r.sadd "{qux}foo", "s1"
-    r.sadd "{qux}foo", "s2"
-    r.sadd "{qux}bar", "s2"
-
-    r.sinterstore("{qux}baz", "{qux}foo", "{qux}bar")
-
-    assert_equal ["s2"], r.smembers("{qux}baz")
-  end
-
-  def test_sunion
-    r.sadd "{qux}foo", "s1"
-    r.sadd "{qux}foo", "s2"
-    r.sadd "{qux}bar", "s2"
-    r.sadd "{qux}bar", "s3"
-
-    assert_equal ["s1", "s2", "s3"], r.sunion("{qux}foo", "{qux}bar").sort
-  end
-
-  def test_sunionstore
-    r.sadd "{qux}foo", "s1"
-    r.sadd "{qux}foo", "s2"
-    r.sadd "{qux}bar", "s2"
-    r.sadd "{qux}bar", "s3"
-
-    r.sunionstore("{qux}baz", "{qux}foo", "{qux}bar")
-
-    assert_equal ["s1", "s2", "s3"], r.smembers("{qux}baz").sort
-  end
-
-  def test_sdiff
-    r.sadd "{qux}foo", "s1"
-    r.sadd "{qux}foo", "s2"
-    r.sadd "{qux}bar", "s2"
-    r.sadd "{qux}bar", "s3"
-
-    assert_equal ["s1"], r.sdiff("{qux}foo", "{qux}bar")
-    assert_equal ["s3"], r.sdiff("{qux}bar", "{qux}foo")
-  end
-
-  def test_sdiffstore
-    r.sadd "{qux}foo", "s1"
-    r.sadd "{qux}foo", "s2"
-    r.sadd "{qux}bar", "s2"
-    r.sadd "{qux}bar", "s3"
-
-    r.sdiffstore("{qux}baz", "{qux}foo", "{qux}bar")
-
-    assert_equal ["s1"], r.smembers("{qux}baz")
-  end
-
-  def test_sort
-    r.set("{qux}foo:1", "s1")
-    r.set("{qux}foo:2", "s2")
-
-    r.rpush("{qux}bar", "1")
-    r.rpush("{qux}bar", "2")
-
-    assert_equal ["s1"], r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1])
-    assert_equal ["s2"], r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1], :order => "desc alpha")
-  end
-
-  def test_sort_with_an_array_of_gets
-    r.set("{qux}foo:1:a", "s1a")
-    r.set("{qux}foo:1:b", "s1b")
-
-    r.set("{qux}foo:2:a", "s2a")
-    r.set("{qux}foo:2:b", "s2b")
-
-    r.rpush("{qux}bar", "1")
-    r.rpush("{qux}bar", "2")
-
-    assert_equal [["s1a", "s1b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1])
-    assert_equal [["s2a", "s2b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1], :order => "desc alpha")
-    assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"])
-  end
-
-  def test_sort_with_store
-    r.set("{qux}foo:1", "s1")
-    r.set("{qux}foo:2", "s2")
-
-    r.rpush("{qux}bar", "1")
-    r.rpush("{qux}bar", "2")
-
-    r.sort("{qux}bar", :get => "{qux}foo:*", :store => "{qux}baz")
-    assert_equal ["s1", "s2"], r.lrange("{qux}baz", 0, -1)
-  end
-
-  def test_bitop
-    target_version "2.5.10" do
-      r.set("{qux}foo", "a")
-      r.set("{qux}bar", "b")
-
-      r.bitop(:and, "{qux}foo&bar", "{qux}foo", "{qux}bar")
-      assert_equal "\x60", r.get("{qux}foo&bar")
-      r.bitop(:or, "{qux}foo|bar", "{qux}foo", "{qux}bar")
-      assert_equal "\x63", r.get("{qux}foo|bar")
-      r.bitop(:xor, "{qux}foo^bar", "{qux}foo", "{qux}bar")
-      assert_equal "\x03", r.get("{qux}foo^bar")
-      r.bitop(:not, "{qux}~foo", "{qux}foo")
-      assert_equal "\x9E", r.get("{qux}~foo")
-    end
-  end
-end

data/test/distributed_connection_handling_test.rb

@@ -1,21 +0,0 @@
-require_relative "helper"
-
-class TestDistributedConnectionHandling < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  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.select 15
-
-    assert_equal "bar", r.get("foo")
-  end
-end