redis 4.0.1 → 4.0.3

data/test/commands_on_strings_test.rb

@@ -1,99 +1,7 @@
-require_relative "helper"
-require_relative "lint/strings"
+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

@@ -38,6 +38,42 @@ class TestCommandsOnValueTypes < Test::Unit::TestCase
     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 r.randomkey.to_s.empty?
 

data/test/distributed_blocking_commands_test.rb

@@ -41,4 +41,12 @@ class TestDistributedBlockingCommands < Test::Unit::TestCase
       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,8 +1,21 @@
-require_relative "helper"
-require_relative "lint/hashes"
+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,31 +1,26 @@
-require_relative "helper"
-require_relative "lint/hyper_log_log"
+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
+    target_version '2.8.9' do
       assert_raise Redis::Distributed::CannotDistribute do
-        r.pfadd "foo", "s1"
-        r.pfadd "bar", "s2"
-
-        assert r.pfmerge("res", "foo", "bar")
+        super
       end
     end
   end
 
   def test_pfcount_multiple_keys_diff_nodes
-    target_version "2.8.9" do
+    target_version '2.8.9' do
       assert_raise Redis::Distributed::CannotDistribute do
-        r.pfadd "foo", "s1"
-        r.pfadd "bar", "s2"
+        r.pfadd 'foo', 's1'
+        r.pfadd 'bar', 's2'
 
-        assert r.pfcount("res", "foo", "bar")
+        assert r.pfcount('res', 'foo', 'bar')
       end
     end
   end
-
 end

data/test/distributed_commands_on_lists_test.rb

@@ -1,20 +1,19 @@
-require_relative "helper"
-require_relative "lint/lists"
+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")
+      r.rpoplpush('foo', 'bar')
     end
   end
 
   def test_brpoplpush
     assert_raise Redis::Distributed::CannotDistribute do
-      r.brpoplpush("foo", "bar", :timeout => 1)
+      r.brpoplpush('foo', 'bar', timeout: 1)
     end
   end
 end

data/test/distributed_commands_on_sets_test.rb

@@ -1,106 +1,105 @@
-require_relative "helper"
-require_relative "lint/sets"
+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.sadd 'foo', 's1'
+      r.sadd 'bar', 's2'
 
-      r.smove("foo", "bar", "s1")
+      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.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
 
-      r.sinter("foo", "bar")
+      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.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
 
-      r.sinterstore("baz", "foo", "bar")
+      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.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      r.sunion("foo", "bar")
+      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.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      r.sunionstore("baz", "foo", "bar")
+      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.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      r.sdiff("foo", "bar")
+      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.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      r.sdiffstore("baz", "foo", "bar")
+      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"
+      r.sadd 'foo', 's1'
+      r.sadd 'foo', 's2'
+      r.sadd 'bar', 's2'
+      r.sadd 'bar', 's3'
 
-      cursor, vals = r.sscan "foo", 0
+      cursor, vals = r.sscan 'foo', 0
       assert_equal '0', cursor
-      assert_equal %w(s1 s2), vals.sort
+      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"
+      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
+      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,16 +1,59 @@
-require_relative "helper"
-require_relative "lint/sorted_sets"
+require_relative 'helper'
+require_relative 'lint/sorted_sets'
 
 class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase
-
   include Helper::Distributed
   include Lint::SortedSets
 
-  def test_zcount
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 2, "s2"
-    r.zadd "foo", 3, "s3"
+  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
 
-    assert_equal 2, r.zcount("foo", 2, 3)
+  def test_zunionstore_with_weights
+    assert_raise(Redis::Distributed::CannotDistribute) { super }
   end
 end