redis 3.0.5 → 3.0.6

data/test/lint/value_types.rb

@@ -33,11 +33,11 @@ module Lint
     end
 
     def test_pexpire
-      return if version < "2.5.4"
-
-      r.set("foo", "s1")
-      assert r.pexpire("foo", 2000)
-      assert_in_range 0..2, r.ttl("foo")
+      target_version "2.5.4" do
+        r.set("foo", "s1")
+        assert r.pexpire("foo", 2000)
+        assert_in_range 0..2, r.ttl("foo")
+      end
     end
 
     def test_expireat
@@ -47,11 +47,11 @@ module Lint
     end
 
     def test_pexpireat
-      return if version < "2.5.4"
-
-      r.set("foo", "s1")
-      assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000)
-      assert_in_range 0..2, r.ttl("foo")
+      target_version "2.5.4" do
+        r.set("foo", "s1")
+        assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000)
+        assert_in_range 0..2, r.ttl("foo")
+      end
     end
 
     def test_persist
@@ -69,31 +69,31 @@ module Lint
     end
 
     def test_pttl
-      return if version < "2.5.4"
-
-      r.set("foo", "s1")
-      r.expire("foo", 2)
-      assert_in_range 1..2000, r.pttl("foo")
+      target_version "2.5.4" do
+        r.set("foo", "s1")
+        r.expire("foo", 2)
+        assert_in_range 1..2000, r.pttl("foo")
+      end
     end
 
     def test_dump_and_restore
-      return if version < "2.5.7"
-
-      r.set("foo", "a")
-      v = r.dump("foo")
-      r.del("foo")
-
-      assert r.restore("foo", 1000, v)
-      assert_equal "a", r.get("foo")
-      assert [0, 1].include? r.ttl("foo")
-
-      r.rpush("bar", ["b", "c", "d"])
-      w = r.dump("bar")
-      r.del("bar")
-
-      assert r.restore("bar", 1000, w)
-      assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
-      assert [0, 1].include? r.ttl("bar")
+      target_version "2.5.7" do
+        r.set("foo", "a")
+        v = r.dump("foo")
+        r.del("foo")
+
+        assert r.restore("foo", 1000, v)
+        assert_equal "a", r.get("foo")
+        assert [0, 1].include? r.ttl("foo")
+
+        r.rpush("bar", ["b", "c", "d"])
+        w = r.dump("bar")
+        r.del("bar")
+
+        assert r.restore("bar", 1000, w)
+        assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
+        assert [0, 1].include? r.ttl("bar")
+      end
     end
 
     def test_move

data/test/persistence_control_commands_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require "helper"
+require File.expand_path("helper", File.dirname(__FILE__))
 
 class TestPersistenceControlCommands < Test::Unit::TestCase
 

data/test/pipelining_commands_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require "helper"
+require File.expand_path("helper", File.dirname(__FILE__))
 
 class TestPipeliningCommands < Test::Unit::TestCase
 

data/test/publish_subscribe_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require "helper"
+require File.expand_path("helper", File.dirname(__FILE__))
 
 class TestPublishSubscribe < Test::Unit::TestCase
 

data/test/remote_server_control_commands_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require "helper"
+require File.expand_path("helper", File.dirname(__FILE__))
 
 class TestRemoteServerControlCommands < Test::Unit::TestCase
 
@@ -26,13 +26,13 @@ class TestRemoteServerControlCommands < Test::Unit::TestCase
   end
 
   def test_info_commandstats
-    return if version < "2.5.7"
+    target_version "2.5.7" do
+      r.config(:resetstat)
+      r.ping
 
-    r.config(:resetstat)
-    r.ping
-
-    result = r.info(:commandstats)
-    assert_equal "1", result["ping"]["calls"]
+      result = r.info(:commandstats)
+      assert_equal "1", result["ping"]["calls"]
+    end
   end
 
   def test_monitor_redis_lt_2_5_0

data/test/scanning_test.rb

@@ -0,0 +1,413 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+unless defined?(Enumerator)
+  Enumerator = Enumerable::Enumerator
+end
+
+class TestScanning < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_scan_basic
+    target_version "2.7.105" do
+      r.debug :populate, 1000
+
+      cursor = 0
+      all_keys   = []
+      loop {
+        cursor, keys = r.scan cursor
+        all_keys += keys
+        break if cursor == "0"
+      }
+
+      assert_equal 1000, all_keys.uniq.size
+    end
+  end
+
+  def test_scan_count
+    target_version "2.7.105" do
+      r.debug :populate, 1000
+
+      cursor = 0
+      all_keys   = []
+      loop {
+        cursor, keys = r.scan cursor, :count => 5
+        all_keys += keys
+        break if cursor == "0"
+      }
+
+      assert_equal 1000, all_keys.uniq.size
+    end
+  end
+
+  def test_scan_match
+    target_version "2.7.105" do
+      r.debug :populate, 1000
+
+      cursor = 0
+      all_keys   = []
+      loop {
+        cursor, keys = r.scan cursor, :match => "key:1??"
+        all_keys += keys
+        break if cursor == "0"
+      }
+
+      assert_equal 100, all_keys.uniq.size
+    end
+  end
+
+  def test_scan_each_enumerator
+    target_version "2.7.105" do
+
+      r.debug :populate, 1000
+
+      scan_enumerator = r.scan_each
+      assert_equal true, scan_enumerator.is_a?(::Enumerator)
+
+      keys_from_scan = scan_enumerator.to_a.uniq
+      all_keys = r.keys "*"
+
+      assert all_keys.sort == keys_from_scan.sort
+    end
+  end
+
+  def test_scan_each_enumerator_match
+    target_version "2.7.105" do
+
+      r.debug :populate, 1000
+
+      keys_from_scan = r.scan_each(:match => "key:1??").to_a.uniq
+      all_keys = r.keys "key:1??"
+
+      assert all_keys.sort == keys_from_scan.sort
+    end
+  end
+
+  def test_scan_each_block
+    target_version "2.7.105" do
+
+      r.debug :populate, 100
+
+      keys_from_scan   = []
+      r.scan_each {|key|
+        keys_from_scan << key
+      }
+
+      all_keys = r.keys "*"
+
+      assert all_keys.sort == keys_from_scan.uniq.sort
+    end
+  end
+
+  def test_scan_each_block_match
+    target_version "2.7.105" do
+
+      r.debug :populate, 100
+
+      keys_from_scan   = []
+      r.scan_each(:match => "key:1?") {|key|
+        keys_from_scan << key
+      }
+
+      all_keys = r.keys "key:1?"
+
+      assert all_keys.sort == keys_from_scan.uniq.sort
+    end
+  end
+
+  def test_sscan_with_encoding
+    target_version "2.7.105" do
+      [:intset, :hashtable].each do |enc|
+        r.del "set"
+
+        prefix = ""
+        prefix = "ele:" if enc == :hashtable
+
+        elements = []
+        100.times { |j| elements << "#{prefix}#{j}" }
+
+        r.sadd "set", elements
+
+        assert_equal enc.to_s, r.object("encoding", "set")
+
+        cursor = 0
+        all_keys   = []
+        loop {
+          cursor, keys = r.sscan "set", cursor
+          all_keys += keys
+          break if cursor == "0"
+        }
+
+        assert_equal 100, all_keys.uniq.size
+      end
+    end
+  end
+
+  def test_sscan_each_enumerator
+    target_version "2.7.105" do
+      elements = []
+      100.times { |j| elements << "ele:#{j}" }
+      r.sadd "set", elements
+
+      scan_enumerator = r.sscan_each("set")
+      assert_equal true, scan_enumerator.is_a?(::Enumerator)
+
+      keys_from_scan = scan_enumerator.to_a.uniq
+      all_keys = r.smembers("set")
+
+      assert all_keys.sort == keys_from_scan.sort
+    end
+  end
+
+  def test_sscan_each_enumerator_match
+    target_version "2.7.105" do
+      elements = []
+      100.times { |j| elements << "ele:#{j}" }
+      r.sadd "set", elements
+
+      keys_from_scan = r.sscan_each("set", :match => "ele:1?").to_a.uniq
+
+      all_keys = r.smembers("set").grep(/^ele:1.$/)
+
+      assert all_keys.sort == keys_from_scan.sort
+    end
+  end
+
+  def test_sscan_each_enumerator_block
+    target_version "2.7.105" do
+      elements = []
+      100.times { |j| elements << "ele:#{j}" }
+      r.sadd "set", elements
+
+      keys_from_scan = []
+      r.sscan_each("set") do |key|
+        keys_from_scan << key
+      end
+
+      all_keys = r.smembers("set")
+
+      assert all_keys.sort == keys_from_scan.uniq.sort
+    end
+  end
+
+  def test_sscan_each_enumerator_block_match
+    target_version "2.7.105" do
+      elements = []
+      100.times { |j| elements << "ele:#{j}" }
+      r.sadd "set", elements
+
+      keys_from_scan = []
+      r.sscan_each("set", :match => "ele:1?") do |key|
+        keys_from_scan << key
+      end
+
+      all_keys = r.smembers("set").grep(/^ele:1.$/)
+
+      assert all_keys.sort == keys_from_scan.uniq.sort
+    end
+  end
+
+  def test_hscan_with_encoding
+    target_version "2.7.105" do
+      [:ziplist, :hashtable].each do |enc|
+        r.del "set"
+
+        count = 1000
+        count = 30 if enc == :ziplist
+
+        elements = []
+        count.times { |j| elements << "key:#{j}" << j.to_s }
+
+        r.hmset "hash", *elements
+
+        assert_equal enc.to_s, r.object("encoding", "hash")
+
+        cursor = 0
+        all_key_values   = []
+        loop {
+          cursor, key_values = r.hscan "hash", cursor
+          all_key_values.concat key_values
+          break if cursor == "0"
+        }
+
+        keys2 = []
+        all_key_values.each do |k, v|
+          assert_equal "key:#{v}", k
+          keys2 << k
+        end
+
+        assert_equal count, keys2.uniq.size
+      end
+    end
+  end
+
+  def test_hscan_each_enumerator
+    target_version "2.7.105" do
+      count = 1000
+      elements = []
+      count.times { |j| elements << "key:#{j}" << j.to_s }
+      r.hmset "hash", *elements
+
+      scan_enumerator = r.hscan_each("hash")
+      assert_equal true, scan_enumerator.is_a?(::Enumerator)
+
+      keys_from_scan = scan_enumerator.to_a.uniq
+      all_keys = r.hgetall("hash").to_a
+
+      assert all_keys.sort == keys_from_scan.sort
+    end
+  end
+
+  def test_hscan_each_enumerator_match
+    target_version "2.7.105" do
+      count = 100
+      elements = []
+      count.times { |j| elements << "key:#{j}" << j.to_s }
+      r.hmset "hash", *elements
+
+      keys_from_scan = r.hscan_each("hash", :match => "key:1?").to_a.uniq
+      all_keys = r.hgetall("hash").to_a.select{|k,v| k =~ /^key:1.$/}
+
+      assert all_keys.sort == keys_from_scan.sort
+    end
+  end
+
+  def test_hscan_each_block
+    target_version "2.7.105" do
+      count = 1000
+      elements = []
+      count.times { |j| elements << "key:#{j}" << j.to_s }
+      r.hmset "hash", *elements
+
+      keys_from_scan = []
+      r.hscan_each("hash") do |field, value|
+        keys_from_scan << [field, value]
+      end
+      all_keys = r.hgetall("hash").to_a
+
+      assert all_keys.sort == keys_from_scan.uniq.sort
+    end
+  end
+
+  def test_hscan_each_block_match
+    target_version "2.7.105" do
+      count = 1000
+      elements = []
+      count.times { |j| elements << "key:#{j}" << j.to_s }
+      r.hmset "hash", *elements
+
+      keys_from_scan = []
+      r.hscan_each("hash", :match => "key:1?") do |field, value|
+        keys_from_scan << [field, value]
+      end
+      all_keys = r.hgetall("hash").to_a.select{|k,v| k =~ /^key:1.$/}
+
+      assert all_keys.sort == keys_from_scan.uniq.sort
+    end
+  end
+
+  def test_zscan_with_encoding
+    target_version "2.7.105" do
+      [:ziplist, :skiplist].each do |enc|
+        r.del "zset"
+
+        count = 1000
+        count = 30 if enc == :ziplist
+
+        elements = []
+        count.times { |j| elements << j << "key:#{j}" }
+
+        r.zadd "zset", elements
+
+        assert_equal enc.to_s, r.object("encoding", "zset")
+
+        cursor = 0
+        all_key_scores   = []
+        loop {
+          cursor, key_scores = r.zscan "zset", cursor
+          all_key_scores.concat  key_scores
+          break if cursor == "0"
+        }
+
+        keys2 = []
+        all_key_scores.each do |k, v|
+          assert_equal true, v.is_a?(Float)
+          assert_equal "key:#{Integer(v)}", k
+          keys2 << k
+        end
+
+        assert_equal count, keys2.uniq.size
+      end
+    end
+  end
+
+  def test_zscan_each_enumerator
+    target_version "2.7.105" do
+      count = 1000
+      elements = []
+      count.times { |j| elements << j << "key:#{j}" }
+      r.zadd "zset", elements
+
+      scan_enumerator = r.zscan_each "zset"
+      assert_equal true, scan_enumerator.is_a?(::Enumerator)
+
+      scores_from_scan = scan_enumerator.to_a.uniq
+      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
+
+      assert member_scores.sort == scores_from_scan.sort
+    end
+  end
+
+  def test_zscan_each_enumerator_match
+    target_version "2.7.105" do
+      count = 1000
+      elements = []
+      count.times { |j| elements << j << "key:#{j}" }
+      r.zadd "zset", elements
+
+      scores_from_scan = r.zscan_each("zset", :match => "key:1??").to_a.uniq
+      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
+      filtered_members = member_scores.select{|k,s| k =~ /^key:1..$/}
+
+      assert filtered_members.sort == scores_from_scan.sort
+    end
+  end
+
+  def test_zscan_each_block
+    target_version "2.7.105" do
+      count = 1000
+      elements = []
+      count.times { |j| elements << j << "key:#{j}" }
+      r.zadd "zset", elements
+
+      scores_from_scan = []
+      r.zscan_each("zset") do |member, score|
+        scores_from_scan << [member, score]
+      end
+      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
+
+      assert member_scores.sort == scores_from_scan.sort
+    end
+  end
+
+  def test_zscan_each_block_match
+    target_version "2.7.105" do
+      count = 1000
+      elements = []
+      count.times { |j| elements << j << "key:#{j}" }
+      r.zadd "zset", elements
+
+      scores_from_scan = []
+      r.zscan_each("zset", :match => "key:1??") do |member, score|
+        scores_from_scan << [member, score]
+      end
+      member_scores = r.zrange("zset", 0, -1, :with_scores => true)
+      filtered_members = member_scores.select{|k,s| k =~ /^key:1..$/}
+
+      assert filtered_members.sort == scores_from_scan.sort
+    end
+  end
+
+end