redis2-namespaced 3.0.7

data/redis.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require "redis2/version"
+
+Gem::Specification.new do |s|
+  s.name = "redis2-namespaced"
+
+  s.version = Redis2::VERSION
+
+  s.homepage = "https://github.com/redis/redis-rb"
+
+  s.summary = "A Ruby client library for Redis2"
+
+  s.description = <<-EOS
+    A Ruby client that tries to match Redis2' API one-to-one, while still
+    providing an idiomatic interface. It features thread-safety,
+    client-side sharding, pipelining, and an obsession for performance.
+  EOS
+
+  s.license = "MIT"
+
+  s.authors = [
+    "Ezra Zygmuntowicz",
+    "Taylor Weibley",
+    "Matthew Clark",
+    "Brian McKinney",
+    "Salvatore Sanfilippo",
+    "Luca Guidi",
+    "Michel Martens",
+    "Damian Janowski",
+    "Pieter Noordhuis"
+  ]
+
+  s.email = ["redis-db@googlegroups.com"]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  s.add_development_dependency("rake")
+end

data/test/bitpos_test.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+unless defined?(Enumerator)
+  Enumerator = Enumerable::Enumerator
+end
+
+class TestBitpos < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_bitpos_empty_zero
+    target_version "2.9.11" do
+      r.del "foo"
+      assert_equal 0, r.bitpos("foo", 0)
+    end
+  end
+
+  def test_bitpos_empty_one
+    target_version "2.9.11" do
+      r.del "foo"
+      assert_equal -1, r.bitpos("foo", 1)
+    end
+  end
+
+  def test_bitpos_zero
+    target_version "2.9.11" do
+      r.set "foo", "\xff\xf0\x00"
+      assert_equal 12, r.bitpos("foo", 0)
+    end
+  end
+
+  def test_bitpos_one
+    target_version "2.9.11" do
+      r.set "foo", "\x00\x0f\x00"
+      assert_equal 12, r.bitpos("foo", 1)
+    end
+  end
+
+  def test_bitpos_zero_end_is_given
+    target_version "2.9.11" do
+      r.set "foo", "\xff\xff\xff"
+      assert_equal 24, r.bitpos("foo", 0)
+      assert_equal 24, r.bitpos("foo", 0, 0)
+      assert_equal -1, r.bitpos("foo", 0, 0, -1)
+    end
+  end
+
+  def test_bitpos_one_intervals
+    target_version "2.9.11" do
+      r.set "foo", "\x00\xff\x00"
+      assert_equal 8,  r.bitpos("foo", 1, 0, -1)
+      assert_equal 8,  r.bitpos("foo", 1, 1, -1)
+      assert_equal -1, r.bitpos("foo", 1, 2, -1)
+      assert_equal -1, r.bitpos("foo", 1, 2, 200)
+      assert_equal 8,  r.bitpos("foo", 1, 1, 1)
+    end
+  end
+
+  def test_bitpos_raise_exception_if_stop_not_start
+    target_version "2.9.11" do
+      assert_raises(ArgumentError) do
+        r.bitpos("foo", 0, nil, 2)
+      end
+    end
+  end
+
+end

data/test/blocking_commands_test.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "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/command_map_test.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+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 Redis2::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

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "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_lists_test.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "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

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "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

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/sorted_sets"
+
+class TestCommandsOnSortedSets < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::SortedSets
+
+  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

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "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
+    try_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

@@ -0,0 +1,131 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "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 }
+
+      assert_raise(RuntimeError, /host not specified/) do
+        redis.migrate("foo", options.reject { |key, _| key == :host })
+      end
+
+      assert_raise(RuntimeError, /port not specified/) do
+        redis.migrate("foo", options.reject { |key, _| key == :port })
+      end
+
+      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