redis2-namespaced 3.0.7

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

data/test/scripting_test.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestScripting < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def to_sha(script)
+    r.script(:load, script)
+  end
+
+  def test_script_exists
+    target_version "2.5.9" do # 2.6-rc1
+      a = to_sha("return 1")
+      b = a.succ
+
+      assert_equal true, r.script(:exists, a)
+      assert_equal false, r.script(:exists, b)
+      assert_equal [true], r.script(:exists, [a])
+      assert_equal [false], r.script(:exists, [b])
+      assert_equal [true, false], r.script(:exists, [a, b])
+    end
+  end
+
+  def test_script_flush
+    target_version "2.5.9" do # 2.6-rc1
+      sha = to_sha("return 1")
+      assert r.script(:exists, sha)
+      assert_equal "OK", r.script(:flush)
+      assert !r.script(:exists, sha)
+    end
+  end
+
+  def test_script_kill
+    target_version "2.5.9" do # 2.6-rc1
+      redis_mock(:script => lambda { |arg| "+#{arg.upcase}" }) do |redis|
+        assert_equal "KILL", redis.script(:kill)
+      end
+    end
+  end
+
+  def test_eval
+    target_version "2.5.9" do # 2.6-rc1
+      assert_equal 0, r.eval("return #KEYS")
+      assert_equal 0, r.eval("return #ARGV")
+      assert_equal ["k1", "k2"], r.eval("return KEYS", ["k1", "k2"])
+      assert_equal ["a1", "a2"], r.eval("return ARGV", [], ["a1", "a2"])
+    end
+  end
+
+  def test_eval_with_options_hash
+    target_version "2.5.9" do # 2.6-rc1
+      assert_equal 0, r.eval("return #KEYS", {})
+      assert_equal 0, r.eval("return #ARGV", {})
+      assert_equal ["k1", "k2"], r.eval("return KEYS", { :keys => ["k1", "k2"] })
+      assert_equal ["a1", "a2"], r.eval("return ARGV", { :argv => ["a1", "a2"] })
+    end
+  end
+
+  def test_evalsha
+    target_version "2.5.9" do # 2.6-rc1
+      assert_equal 0, r.evalsha(to_sha("return #KEYS"))
+      assert_equal 0, r.evalsha(to_sha("return #ARGV"))
+      assert_equal ["k1", "k2"], r.evalsha(to_sha("return KEYS"), ["k1", "k2"])
+      assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), [], ["a1", "a2"])
+    end
+  end
+
+  def test_evalsha_with_options_hash
+    target_version "2.5.9" do # 2.6-rc1
+      assert_equal 0, r.evalsha(to_sha("return #KEYS"), {})
+      assert_equal 0, r.evalsha(to_sha("return #ARGV"), {})
+      assert_equal ["k1", "k2"], r.evalsha(to_sha("return KEYS"), { :keys => ["k1", "k2"] })
+      assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), { :argv => ["a1", "a2"] })
+    end
+  end
+end

data/test/sorting_test.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestSorting < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_sort
+    r.set("foo:1", "s1")
+    r.set("foo:2", "s2")
+
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
+
+    assert_equal ["s1"], r.sort("bar", :get => "foo:*", :limit => [0, 1])
+    assert_equal ["s2"], r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
+  end
+
+  def test_sort_with_an_array_of_gets
+    r.set("foo:1:a", "s1a")
+    r.set("foo:1:b", "s1b")
+
+    r.set("foo:2:a", "s2a")
+    r.set("foo:2:b", "s2b")
+
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
+
+    assert_equal [["s1a", "s1b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
+    assert_equal [["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+    assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"])
+  end
+
+  def test_sort_with_store
+    r.set("foo:1", "s1")
+    r.set("foo:2", "s2")
+
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
+
+    r.sort("bar", :get => "foo:*", :store => "baz")
+    assert_equal ["s1", "s2"], r.lrange("baz", 0, -1)
+  end
+
+  def test_sort_with_an_array_of_gets_and_with_store
+    r.set("foo:1:a", "s1a")
+    r.set("foo:1:b", "s1b")
+
+    r.set("foo:2:a", "s2a")
+    r.set("foo:2:b", "s2b")
+
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
+
+    r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :store => 'baz')
+    assert_equal ["s1a", "s1b", "s2a", "s2b"], r.lrange("baz", 0, -1)
+  end
+end

data/test/support/connection/hiredis.rb

@@ -0,0 +1 @@
+require "support/wire/thread"

data/test/support/connection/ruby.rb

@@ -0,0 +1 @@
+require "support/wire/thread"

data/test/support/connection/synchrony.rb

@@ -0,0 +1,17 @@
+require "support/wire/synchrony"
+
+module Helper
+  def around
+    rv = nil
+
+    EM.synchrony do
+      begin
+        rv = yield
+      ensure
+        EM.stop
+      end
+    end
+
+    rv
+  end
+end

data/test/support/redis_mock.rb

@@ -0,0 +1,115 @@
+require "socket"
+
+module Redis2Mock
+  class Server
+    VERBOSE = false
+
+    def initialize(port, options = {}, &block)
+      @server = TCPServer.new(options[:host] || "127.0.0.1", port)
+      @server.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+    end
+
+    def start(&block)
+      @thread = Thread.new { run(&block) }
+    end
+
+    # Bail out of @server.accept before closing the socket. This is required
+    # to avoid EADDRINUSE after a couple of iterations.
+    def shutdown
+      @thread.terminate if @thread
+      @server.close if @server
+    rescue => ex
+      $stderr.puts "Error closing mock server: #{ex.message}" if VERBOSE
+      $stderr.puts ex.backtrace if VERBOSE
+    end
+
+    def run
+      loop do
+        session = @server.accept
+
+        begin
+          return if yield(session) == :exit
+        ensure
+          session.close
+        end
+      end
+    rescue => ex
+      $stderr.puts "Error running mock server: #{ex.message}" if VERBOSE
+      $stderr.puts ex.backtrace if VERBOSE
+    ensure
+      @server.close
+    end
+  end
+
+  MOCK_PORT = 6382
+
+  # Starts a mock Redis2 server in a thread.
+  #
+  # The server will use the lambda handler passed as argument to handle
+  # connections. For example:
+  #
+  #   handler = lambda { |session| session.close }
+  #   Redis2Mock.start_with_handler(handler) do
+  #     # Every connection will be closed immediately
+  #   end
+  #
+  def self.start_with_handler(blk, options = {})
+    server = Server.new(MOCK_PORT, options)
+
+    begin
+      server.start(&blk)
+
+      yield(MOCK_PORT)
+
+    ensure
+      server.shutdown
+    end
+  end
+
+  # Starts a mock Redis2 server in a thread.
+  #
+  # The server will reply with a `+OK` to all commands, but you can
+  # customize it by providing a hash. For example:
+  #
+  #   Redis2Mock.start(:ping => lambda { "+PONG" }) do
+  #     assert_equal "PONG", Redis2.new(:port => MOCK_PORT).ping
+  #   end
+  #
+  def self.start(commands, options = {}, &blk)
+    handler = lambda do |session|
+      while line = session.gets
+        argv = Array.new(line[1..-3].to_i) do
+          bytes = session.gets[1..-3].to_i
+          arg = session.read(bytes)
+          session.read(2) # Discard \r\n
+          arg
+        end
+
+        command = argv.shift
+        blk = commands[command.to_sym]
+        blk ||= lambda { |*_| "+OK" }
+
+        response = blk.call(*argv)
+
+        # Convert a nil response to :close
+        response ||= :close
+
+        if response == :exit
+          break :exit
+        elsif response == :close
+          break :close
+        elsif response.is_a?(Array)
+          session.write("*%d\r\n" % response.size)
+          response.each do |e|
+            session.write("$%d\r\n%s\r\n" % [e.length, e])
+          end
+        else
+          session.write(response)
+          session.write("\r\n") unless response.end_with?("\r\n")
+        end
+      end
+    end
+
+    start_with_handler(handler, options, &blk)
+  end
+end

data/test/support/wire/synchrony.rb

@@ -0,0 +1,24 @@
+class Wire < Fiber
+  # We cannot run this fiber explicitly because EM schedules it. Resuming the
+  # current fiber on the next tick to let the reactor do work.
+  def self.pass
+    f = Fiber.current
+    EM.next_tick { f.resume }
+    Fiber.yield
+  end
+
+  def self.sleep(sec)
+    EM::Synchrony.sleep(sec)
+  end
+
+  def initialize(&blk)
+    super
+
+    # Schedule run in next tick
+    EM.next_tick { resume }
+  end
+
+  def join
+    self.class.pass while alive?
+  end
+end