redis 3.0.0.rc1 → 3.0.0.rc2

data/test/distributed_blocking_commands_test.rb

@@ -1,53 +1,46 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
+require "lint/blocking_commands"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedBlockingCommands < Test::Unit::TestCase
 
-test "BLPOP" do |r|
-  r.lpush("foo", "s1")
-  r.lpush("foo", "s2")
+  include Helper::Distributed
+  include Lint::BlockingCommands
 
-  wire = Wire.new do
-    redis = Redis::Distributed.new(NODES)
-    Wire.sleep 0.3
-    redis.lpush("foo", "s3")
+  def test_blpop_raises
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.blpop(["foo", "bar"])
+    end
   end
 
-  assert ["foo", "s2"] == r.blpop("foo", 1)
-  assert ["foo", "s1"] == r.blpop("foo", 1)
-  assert ["foo", "s3"] == r.blpop("foo", 1)
-
-  wire.join
-end
-
-test "BRPOP" do |r|
-  r.rpush("foo", "s1")
-  r.rpush("foo", "s2")
-
-  wire = Wire.new do
-    redis = Redis::Distributed.new(NODES)
-    Wire.sleep 0.3
-    redis.rpush("foo", "s3")
+  def test_blpop_raises_with_old_prototype
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.blpop("foo", "bar", 0)
+    end
   end
 
-  assert ["foo", "s2"] == r.brpop("foo", 1)
-  assert ["foo", "s1"] == r.brpop("foo", 1)
-  assert ["foo", "s3"] == r.brpop("foo", 1)
-
-  wire.join
-end
+  def test_brpop_raises
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.brpop(["foo", "bar"])
+    end
+  end
 
-test "BRPOP should unset a configured socket timeout" do |r|
-  r = Redis::Distributed.new(NODES, :timeout => 1)
+  def test_brpop_raises_with_old_prototype
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.brpop("foo", "bar", 0)
+    end
+  end
 
-  assert_nothing_raised do
-    r.brpop("foo", 2)
-  end # Errno::EAGAIN raised if socket times out before redis command times out
+  def test_brpoplpush_raises
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.brpoplpush("foo", "bar")
+    end
+  end
 
-  assert r.nodes.all? { |node| node.client.timeout == 1 }
+  def test_brpoplpush_raises_with_old_prototype
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.brpoplpush("foo", "bar", 0)
+    end
+  end
 end

data/test/distributed_commands_on_hashes_test.rb

@@ -1,11 +1,10 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
+require "lint/hashes"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedCommandsOnHashes < Test::Unit::TestCase
 
-load './test/lint/hashes.rb'
+  include Helper::Distributed
+  include Lint::Hashes
+end

data/test/distributed_commands_on_lists_test.rb

@@ -1,23 +1,22 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
+require "lint/lists"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedCommandsOnLists < Test::Unit::TestCase
 
-load './test/lint/lists.rb'
+  include Helper::Distributed
+  include Lint::Lists
 
-test "RPOPLPUSH" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.rpoplpush("foo", "bar")
+  def test_rpoplpush
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.rpoplpush("foo", "bar")
+    end
   end
-end
 
-test "BRPOPLPUSH" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.brpoplpush("foo", "bar", 1)
+  def test_brpoplpush
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.brpoplpush("foo", "bar", :timeout => 1)
+    end
   end
 end

data/test/distributed_commands_on_sets_test.rb

@@ -1,84 +1,83 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
+require "lint/sets"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedCommandsOnSets < Test::Unit::TestCase
 
-load './test/lint/sets.rb'
+  include Helper::Distributed
+  include Lint::Sets
 
-test "SMOVE" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.sadd "foo", "s1"
-    r.sadd "bar", "s2"
+  def test_smove
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "bar", "s2"
 
-    r.smove("foo", "bar", "s1")
+      r.smove("foo", "bar", "s1")
+    end
   end
-end
 
-test "SINTER" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
+  def test_sinter
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
 
-    r.sinter("foo", "bar")
+      r.sinter("foo", "bar")
+    end
   end
-end
 
-test "SINTERSTORE" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
+  def test_sinterstore
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
 
-    r.sinterstore("baz", "foo", "bar")
+      r.sinterstore("baz", "foo", "bar")
+    end
   end
-end
 
-test "SUNION" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-    r.sadd "bar", "s3"
+  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.sunion("foo", "bar")
+      r.sunion("foo", "bar")
+    end
   end
-end
 
-test "SUNIONSTORE" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-    r.sadd "bar", "s3"
+  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.sunionstore("baz", "foo", "bar")
+      r.sunionstore("baz", "foo", "bar")
+    end
   end
-end
 
-test "SDIFF" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-    r.sadd "bar", "s3"
+  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.sdiff("foo", "bar")
+      r.sdiff("foo", "bar")
+    end
   end
-end
 
-test "SDIFFSTORE" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.sadd "foo", "s1"
-    r.sadd "foo", "s2"
-    r.sadd "bar", "s2"
-    r.sadd "bar", "s3"
+  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.sdiffstore("baz", "foo", "bar")
+      r.sdiffstore("baz", "foo", "bar")
+    end
   end
 end

data/test/distributed_commands_on_sorted_sets_test.rb

@@ -1,19 +1,18 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
+require "lint/sorted_sets"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase
 
-load './test/lint/sorted_sets.rb'
+  include Helper::Distributed
+  include Lint::SortedSets
 
-test "ZCOUNT" do |r|
-  r.zadd "foo", 1, "s1"
-  r.zadd "foo", 2, "s2"
-  r.zadd "foo", 3, "s3"
+  def test_zcount
+    r.zadd "foo", 1, "s1"
+    r.zadd "foo", 2, "s2"
+    r.zadd "foo", 3, "s3"
 
-  assert 2 == r.zcount("foo", 2, 3)
+    assert_equal 2, r.zcount("foo", 2, 3)
+  end
 end

data/test/distributed_commands_on_strings_test.rb

@@ -1,49 +1,48 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
+require "lint/strings"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedCommandsOnStrings < Test::Unit::TestCase
 
-load './test/lint/strings.rb'
+  include Helper::Distributed
+  include Lint::Strings
 
-test "MGET" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.mget("foo", "bar")
+  def test_mget
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.mget("foo", "bar")
+    end
   end
-end
 
-test "MGET mapped" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.mapped_mget("foo", "bar")
+  def test_mget_mapped
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.mapped_mget("foo", "bar")
+    end
   end
-end
 
-test "MSET" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.mset(:foo, "s1", :bar, "s2")
+  def test_mset
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.mset(:foo, "s1", :bar, "s2")
+    end
   end
-end
 
-test "MSET mapped" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.mapped_mset(:foo => "s1", :bar => "s2")
+  def test_mset_mapped
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.mapped_mset(:foo => "s1", :bar => "s2")
+    end
   end
-end
 
-test "MSETNX" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.set("foo", "s1")
-    r.msetnx(:foo, "s2", :bar, "s3")
+  def test_msetnx
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "s1")
+      r.msetnx(:foo, "s2", :bar, "s3")
+    end
   end
-end
 
-test "MSETNX mapped" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.set("foo", "s1")
-    r.mapped_msetnx(:foo => "s2", :bar => "s3")
+  def test_msetnx_mapped
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "s1")
+      r.mapped_msetnx(:foo => "s2", :bar => "s3")
+    end
   end
 end

data/test/distributed_commands_on_value_types_test.rb

@@ -1,72 +1,87 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
+require "lint/value_types"
 
-setup do
-  log = StringIO.new
-  init(Redis::Distributed.new(NODES, :logger => ::Logger.new(log)))
-end
+class TestDistributedCommandsOnValueTypes < Test::Unit::TestCase
 
-load "./test/lint/value_types.rb"
+  include Helper::Distributed
+  include Lint::ValueTypes
 
-test "DEL" do |r|
-  r.set "foo", "s1"
-  r.set "bar", "s2"
-  r.set "baz", "s3"
+  def test_del
+    r.set "foo", "s1"
+    r.set "bar", "s2"
+    r.set "baz", "s3"
 
-  assert ["bar", "baz", "foo"] == r.keys("*").sort
+    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
 
-  assert 1 == r.del("foo")
+    assert_equal 1, r.del("foo")
 
-  assert ["bar", "baz"] == r.keys("*").sort
+    assert_equal ["bar", "baz"], r.keys("*").sort
 
-  assert 2 == r.del("bar", "baz")
+    assert_equal 2, r.del("bar", "baz")
 
-  assert [] == r.keys("*").sort
-end
+    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
 
-test "RANDOMKEY" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.randomkey
+    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
-end
 
-test "RENAME" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.set("foo", "s1")
-    r.rename "foo", "bar"
+  def test_randomkey
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.randomkey
+    end
   end
 
-  assert "s1" == r.get("foo")
-  assert nil == r.get("bar")
-end
+  def test_rename
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "s1")
+      r.rename "foo", "bar"
+    end
 
-test "RENAMENX" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.set("foo", "s1")
-    r.rename "foo", "bar"
+    assert_equal "s1", r.get("foo")
+    assert_equal nil, r.get("bar")
   end
 
-  assert "s1" == r.get("foo")
-  assert nil  == r.get("bar")
-end
+  def test_renamenx
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.set("foo", "s1")
+      r.rename "foo", "bar"
+    end
 
-test "DBSIZE" do |r|
-  assert [0] == r.dbsize
+    assert_equal "s1", r.get("foo")
+    assert_equal nil , r.get("bar")
+  end
 
-  r.set("foo", "s1")
+  def test_dbsize
+    assert_equal [0], r.dbsize
 
-  assert [1] == r.dbsize
-end
+    r.set("foo", "s1")
 
-test "FLUSHDB" do |r|
-  r.set("foo", "s1")
-  r.set("bar", "s2")
+    assert_equal [1], r.dbsize
+  end
 
-  assert [2] == r.dbsize
+  def test_flushdb
+    r.set("foo", "s1")
+    r.set("bar", "s2")
 
-  r.flushdb
+    assert_equal [2], r.dbsize
 
-  assert [0] == r.dbsize
+    r.flushdb
+
+    assert_equal [0], r.dbsize
+  end
 end