redis 3.0.0.rc1 → 3.0.0.rc2

data/redis.gemspec

@@ -9,13 +9,14 @@ Gem::Specification.new do |s|
 
   s.version = Redis::VERSION
 
-  s.homepage = "https://github.com/ezmobius/redis-rb"
+  s.homepage = "https://github.com/redis/redis-rb"
 
   s.summary = "A Ruby client library for the Redis key-value store."
 
   s.description = <<-EOS
-    A simple Ruby client trying to match Redis' API one-to-one while still providing a Rubystic interface.
-    It features thread safety, client-side sharding, and an obsession for performance.
+    A Ruby client that tries to match Redis' 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.authors = [
@@ -37,7 +38,4 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 
   s.add_development_dependency("rake")
-  s.add_development_dependency("cutest")
-  s.add_development_dependency("hiredis")
-  s.add_development_dependency("em-synchrony")
 end

data/test/blocking_commands_test.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+require "helper"
+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

@@ -1,29 +1,30 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
 
-setup do
-  init Redis.new(OPTIONS)
-end
-
-test "Override existing commands" do |r|
-  r.set("counter", 1)
+class TestCommandMap < Test::Unit::TestCase
 
-  assert 2 == r.incr("counter")
+  include Helper::Client
 
-  r.client.command_map[:incr] = :decr
+  def test_override_existing_commands
+    r.set("counter", 1)
 
-  assert 1 == r.incr("counter")
-end
+    assert_equal 2, r.incr("counter")
 
-test "Override non-existing commands" do |r|
-  r.set("key", "value")
+    r.client.command_map[:incr] = :decr
 
-  assert_raise Redis::CommandError do
-    r.idontexist("key")
+    assert_equal 1, r.incr("counter")
   end
 
-  r.client.command_map[:idontexist] = :get
+  def test_override_non_existing_commands
+    r.set("key", "value")
 
-  assert "value" == r.idontexist("key")
+    assert_raise Redis::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

@@ -1,20 +1,21 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
+require "lint/hashes"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestCommandsOnHashes < Test::Unit::TestCase
 
-load './test/lint/hashes.rb'
+  include Helper::Client
+  include Lint::Hashes
 
-test "Mapped HMGET in a pipeline returns hash" do |r|
-  r.hset("foo", "f1", "s1")
-  r.hset("foo", "f2", "s2")
+  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
+    result = r.pipelined do
+      r.mapped_hmget("foo", "f1", "f2")
+    end
 
-  assert result[0] == { "f1" => "s1", "f2" => "s2" }
+    assert_equal result[0], { "f1" => "s1", "f2" => "s2" }
+  end
 end

data/test/commands_on_lists_test.rb

@@ -1,60 +1,50 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
+require "lint/lists"
 
-setup do
-  init Redis.new(OPTIONS)
-end
-
-load './test/lint/lists.rb'
-
-test "RPUSHX" do |r|
-  r.rpushx "foo", "s1"
-  r.rpush "foo", "s2"
-  r.rpushx "foo", "s3"
+class TestCommandsOnLists < Test::Unit::TestCase
 
-  assert 2 == r.llen("foo")
-  assert ["s2", "s3"] == r.lrange("foo", 0, -1)
-end
-
-test "LPUSHX" do |r|
-  r.lpushx "foo", "s1"
-  r.lpush "foo", "s2"
-  r.lpushx "foo", "s3"
+  include Helper::Client
+  include Lint::Lists
 
-  assert 2 == r.llen("foo")
-  assert ["s3", "s2"] == r.lrange("foo", 0, -1)
-end
+  def test_rpushx
+    r.rpushx "foo", "s1"
+    r.rpush "foo", "s2"
+    r.rpushx "foo", "s3"
 
-test "LINSERT" do |r|
-  r.rpush "foo", "s1"
-  r.rpush "foo", "s3"
-  r.linsert "foo", :before, "s3", "s2"
+    assert_equal 2, r.llen("foo")
+    assert_equal ["s2", "s3"], r.lrange("foo", 0, -1)
+  end
 
-  assert ["s1", "s2", "s3"] == r.lrange("foo", 0, -1)
+  def test_lpushx
+    r.lpushx "foo", "s1"
+    r.lpush "foo", "s2"
+    r.lpushx "foo", "s3"
 
-  assert_raise(Redis::CommandError) do
-    r.linsert "foo", :anywhere, "s3", "s2"
+    assert_equal 2, r.llen("foo")
+    assert_equal ["s3", "s2"], r.lrange("foo", 0, -1)
   end
-end
-
-test "RPOPLPUSH" do |r|
-  r.rpush "foo", "s1"
-  r.rpush "foo", "s2"
 
-  assert "s2" == r.rpoplpush("foo", "bar")
-  assert ["s2"] == r.lrange("bar", 0, -1)
-  assert "s1" == r.rpoplpush("foo", "bar")
-  assert ["s1", "s2"] == r.lrange("bar", 0, -1)
-end
+  def test_linsert
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s3"
+    r.linsert "foo", :before, "s3", "s2"
 
-test "BRPOPLPUSH" do |r|
-  r.rpush "foo", "s1"
-  r.rpush "foo", "s2"
+    assert_equal ["s1", "s2", "s3"], r.lrange("foo", 0, -1)
 
-  assert_equal "s2", r.brpoplpush("foo", "bar", 1)
+    assert_raise(Redis::CommandError) do
+      r.linsert "foo", :anywhere, "s3", "s2"
+    end
+  end
 
-  assert_equal nil, r.brpoplpush("baz", "qux", 1)
+  def test_rpoplpush
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
 
-  assert_equal ["s2"], r.lrange("bar", 0, -1)
+    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

@@ -1,76 +1,77 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
+require "lint/sets"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestCommandsOnSets < Test::Unit::TestCase
 
-load './test/lint/sets.rb'
+  include Helper::Client
+  include Lint::Sets
 
-test "SMOVE" do |r|
-  r.sadd "foo", "s1"
-  r.sadd "bar", "s2"
+  def test_smove
+    r.sadd "foo", "s1"
+    r.sadd "bar", "s2"
 
-  assert r.smove("foo", "bar", "s1")
-  assert r.sismember("bar", "s1")
-end
+    assert r.smove("foo", "bar", "s1")
+    assert r.sismember("bar", "s1")
+  end
 
-test "SINTER" do |r|
-  r.sadd "foo", "s1"
-  r.sadd "foo", "s2"
-  r.sadd "bar", "s2"
+  def test_sinter
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
 
-  assert ["s2"] == r.sinter("foo", "bar")
-end
+    assert_equal ["s2"], r.sinter("foo", "bar")
+  end
 
-test "SINTERSTORE" do |r|
-  r.sadd "foo", "s1"
-  r.sadd "foo", "s2"
-  r.sadd "bar", "s2"
+  def test_sinterstore
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
 
-  r.sinterstore("baz", "foo", "bar")
+    r.sinterstore("baz", "foo", "bar")
 
-  assert ["s2"] == r.smembers("baz")
-end
+    assert_equal ["s2"], r.smembers("baz")
+  end
 
-test "SUNION" do |r|
-  r.sadd "foo", "s1"
-  r.sadd "foo", "s2"
-  r.sadd "bar", "s2"
-  r.sadd "bar", "s3"
+  def test_sunion
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
+    r.sadd "bar", "s3"
 
-  assert ["s1", "s2", "s3"] == r.sunion("foo", "bar").sort
-end
+    assert_equal ["s1", "s2", "s3"], r.sunion("foo", "bar").sort
+  end
 
-test "SUNIONSTORE" do |r|
-  r.sadd "foo", "s1"
-  r.sadd "foo", "s2"
-  r.sadd "bar", "s2"
-  r.sadd "bar", "s3"
+  def test_sunionstore
+    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")
 
-  assert ["s1", "s2", "s3"] == r.smembers("baz").sort
-end
+    assert_equal ["s1", "s2", "s3"], r.smembers("baz").sort
+  end
 
-test "SDIFF" do |r|
-  r.sadd "foo", "s1"
-  r.sadd "foo", "s2"
-  r.sadd "bar", "s2"
-  r.sadd "bar", "s3"
+  def test_sdiff
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "bar", "s2"
+    r.sadd "bar", "s3"
 
-  assert ["s1"] == r.sdiff("foo", "bar")
-  assert ["s3"] == r.sdiff("bar", "foo")
-end
+    assert_equal ["s1"], r.sdiff("foo", "bar")
+    assert_equal ["s3"], r.sdiff("bar", "foo")
+  end
 
-test "SDIFFSTORE" do |r|
-  r.sadd "foo", "s1"
-  r.sadd "foo", "s2"
-  r.sadd "bar", "s2"
-  r.sadd "bar", "s3"
+  def test_sdiffstore
+    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")
 
-  assert ["s1"] == r.smembers("baz")
+    assert_equal ["s1"], r.smembers("baz")
+  end
 end

data/test/commands_on_sorted_sets_test.rb

@@ -1,108 +1,109 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-setup do
-  init Redis.new(OPTIONS)
-end
-
-load './test/lint/sorted_sets.rb'
-
-test "ZCOUNT" do |r|
-  r.zadd "foo", 1, "s1"
-  r.zadd "foo", 2, "s2"
-  r.zadd "foo", 3, "s3"
-
-  assert 2 == r.zcount("foo", 2, 3)
-end
-
-test "ZUNIONSTORE" do |r|
-  r.zadd "foo", 1, "s1"
-  r.zadd "bar", 2, "s2"
-  r.zadd "foo", 3, "s3"
-  r.zadd "bar", 4, "s4"
-
-  assert 4 == r.zunionstore("foobar", ["foo", "bar"])
-  assert ["s1", "s2", "s3", "s4"] == r.zrange("foobar", 0, -1)
-end
-
-test "ZUNIONSTORE with WEIGHTS" do |r|
-  r.zadd "foo", 1, "s1"
-  r.zadd "foo", 3, "s3"
-  r.zadd "bar", 20, "s2"
-  r.zadd "bar", 40, "s4"
-
-  assert 4 == r.zunionstore("foobar", ["foo", "bar"])
-  assert ["s1", "s3", "s2", "s4"] == r.zrange("foobar", 0, -1)
-
-  assert 4 == r.zunionstore("foobar", ["foo", "bar"], :weights => [10, 1])
-  assert ["s1", "s2", "s3", "s4"] == r.zrange("foobar", 0, -1)
-end
-
-test "ZUNIONSTORE with AGGREGATE" do |r|
-  r.zadd "foo", 1, "s1"
-  r.zadd "foo", 2, "s2"
-  r.zadd "bar", 4, "s2"
-  r.zadd "bar", 3, "s3"
-
-  assert 3 == r.zunionstore("foobar", ["foo", "bar"])
-  assert ["s1", "s3", "s2"] == r.zrange("foobar", 0, -1)
-
-  assert 3 == r.zunionstore("foobar", ["foo", "bar"], :aggregate => :min)
-  assert ["s1", "s2", "s3"] == r.zrange("foobar", 0, -1)
-
-  assert 3 == r.zunionstore("foobar", ["foo", "bar"], :aggregate => :max)
-  assert ["s1", "s3", "s2"] == r.zrange("foobar", 0, -1)
-end
-
-test "ZINTERSTORE" do |r|
-  r.zadd "foo", 1, "s1"
-  r.zadd "bar", 2, "s1"
-  r.zadd "foo", 3, "s3"
-  r.zadd "bar", 4, "s4"
-
-  assert 1 == r.zinterstore("foobar", ["foo", "bar"])
-  assert ["s1"] == r.zrange("foobar", 0, -1)
-end
-
-test "ZINTERSTORE with WEIGHTS" do |r|
-  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 2 == r.zinterstore("foobar", ["foo", "bar"])
-  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
-
-  assert 2 == r.zinterstore("foobar", ["foo", "bar"], :weights => [10, 1])
-  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
-
-  assert 40.0 == r.zscore("foobar", "s2")
-  assert 60.0 == r.zscore("foobar", "s3")
-end
-
-test "ZINTERSTORE with AGGREGATE" do |r|
-  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 2 == r.zinterstore("foobar", ["foo", "bar"])
-  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
-  assert 22.0 == r.zscore("foobar", "s2")
-  assert 33.0 == r.zscore("foobar", "s3")
-
-  assert 2 == r.zinterstore("foobar", ["foo", "bar"], :aggregate => :min)
-  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
-  assert 2.0 == r.zscore("foobar", "s2")
-  assert 3.0 == r.zscore("foobar", "s3")
-
-  assert 2 == r.zinterstore("foobar", ["foo", "bar"], :aggregate => :max)
-  assert ["s2", "s3"] == r.zrange("foobar", 0, -1)
-  assert 20.0 == r.zscore("foobar", "s2")
-  assert 30.0 == r.zscore("foobar", "s3")
+require "helper"
+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