redis 3.0.0.rc1 → 3.0.0.rc2

data/test/distributed_commands_requiring_clustering_test.rb

@@ -1,148 +1,148 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedCommandsRequiringClustering < Test::Unit::TestCase
 
-test "RENAME" do |r|
-  r.set("{qux}foo", "s1")
-  r.rename "{qux}foo", "{qux}bar"
+  include Helper::Distributed
 
-  assert "s1" == r.get("{qux}bar")
-  assert nil == r.get("{qux}foo")
-end
+  def test_rename
+    r.set("{qux}foo", "s1")
+    r.rename "{qux}foo", "{qux}bar"
 
-test "RENAMENX" do |r|
-  r.set("{qux}foo", "s1")
-  r.set("{qux}bar", "s2")
+    assert_equal "s1", r.get("{qux}bar")
+    assert_equal nil, r.get("{qux}foo")
+  end
 
-  assert false == r.renamenx("{qux}foo", "{qux}bar")
+  def test_renamenx
+    r.set("{qux}foo", "s1")
+    r.set("{qux}bar", "s2")
 
-  assert "s1" == r.get("{qux}foo")
-  assert "s2" == r.get("{qux}bar")
-end
+    assert_equal false, r.renamenx("{qux}foo", "{qux}bar")
 
-test "BRPOPLPUSH" do |r|
-  r.rpush "{qux}foo", "s1"
-  r.rpush "{qux}foo", "s2"
+    assert_equal "s1", r.get("{qux}foo")
+    assert_equal "s2", r.get("{qux}bar")
+  end
 
-  assert_equal "s2", r.brpoplpush("{qux}foo", "{qux}bar", 1)
-  assert_equal ["s2"], r.lrange("{qux}bar", 0, -1)
-end
+  def test_brpoplpush
+    r.rpush "{qux}foo", "s1"
+    r.rpush "{qux}foo", "s2"
 
-test "RPOPLPUSH" do |r|
-  r.rpush "{qux}foo", "s1"
-  r.rpush "{qux}foo", "s2"
+    assert_equal "s2", r.brpoplpush("{qux}foo", "{qux}bar", :timeout => 1)
+    assert_equal ["s2"], r.lrange("{qux}bar", 0, -1)
+  end
 
-  assert "s2" == r.rpoplpush("{qux}foo", "{qux}bar")
-  assert ["s2"] == r.lrange("{qux}bar", 0, -1)
-  assert "s1" == r.rpoplpush("{qux}foo", "{qux}bar")
-  assert ["s1", "s2"] == r.lrange("{qux}bar", 0, -1)
-end
+  def test_rpoplpush
+    r.rpush "{qux}foo", "s1"
+    r.rpush "{qux}foo", "s2"
 
-test "SMOVE" do |r|
-  r.sadd "{qux}foo", "s1"
-  r.sadd "{qux}bar", "s2"
+    assert_equal "s2", r.rpoplpush("{qux}foo", "{qux}bar")
+    assert_equal ["s2"], r.lrange("{qux}bar", 0, -1)
+    assert_equal "s1", r.rpoplpush("{qux}foo", "{qux}bar")
+    assert_equal ["s1", "s2"], r.lrange("{qux}bar", 0, -1)
+  end
 
-  assert r.smove("{qux}foo", "{qux}bar", "s1")
-  assert r.sismember("{qux}bar", "s1")
-end
+  def test_smove
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}bar", "s2"
 
-test "SINTER" do |r|
-  r.sadd "{qux}foo", "s1"
-  r.sadd "{qux}foo", "s2"
-  r.sadd "{qux}bar", "s2"
+    assert r.smove("{qux}foo", "{qux}bar", "s1")
+    assert r.sismember("{qux}bar", "s1")
+  end
 
-  assert ["s2"] == r.sinter("{qux}foo", "{qux}bar")
-end
+  def test_sinter
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
 
-test "SINTERSTORE" do |r|
-  r.sadd "{qux}foo", "s1"
-  r.sadd "{qux}foo", "s2"
-  r.sadd "{qux}bar", "s2"
+    assert_equal ["s2"], r.sinter("{qux}foo", "{qux}bar")
+  end
 
-  r.sinterstore("{qux}baz", "{qux}foo", "{qux}bar")
+  def test_sinterstore
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
 
-  assert ["s2"] == r.smembers("{qux}baz")
-end
+    r.sinterstore("{qux}baz", "{qux}foo", "{qux}bar")
 
-test "SUNION" do |r|
-  r.sadd "{qux}foo", "s1"
-  r.sadd "{qux}foo", "s2"
-  r.sadd "{qux}bar", "s2"
-  r.sadd "{qux}bar", "s3"
+    assert_equal ["s2"], r.smembers("{qux}baz")
+  end
 
-  assert ["s1", "s2", "s3"] == r.sunion("{qux}foo", "{qux}bar").sort
-end
+  def test_sunion
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
+    r.sadd "{qux}bar", "s3"
 
-test "SUNIONSTORE" do |r|
-  r.sadd "{qux}foo", "s1"
-  r.sadd "{qux}foo", "s2"
-  r.sadd "{qux}bar", "s2"
-  r.sadd "{qux}bar", "s3"
+    assert_equal ["s1", "s2", "s3"], r.sunion("{qux}foo", "{qux}bar").sort
+  end
 
-  r.sunionstore("{qux}baz", "{qux}foo", "{qux}bar")
+  def test_sunionstore
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
+    r.sadd "{qux}bar", "s3"
 
-  assert ["s1", "s2", "s3"] == r.smembers("{qux}baz").sort
-end
+    r.sunionstore("{qux}baz", "{qux}foo", "{qux}bar")
 
-test "SDIFF" do |r|
-  r.sadd "{qux}foo", "s1"
-  r.sadd "{qux}foo", "s2"
-  r.sadd "{qux}bar", "s2"
-  r.sadd "{qux}bar", "s3"
+    assert_equal ["s1", "s2", "s3"], r.smembers("{qux}baz").sort
+  end
 
-  assert ["s1"] == r.sdiff("{qux}foo", "{qux}bar")
-  assert ["s3"] == r.sdiff("{qux}bar", "{qux}foo")
-end
+  def test_sdiff
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
+    r.sadd "{qux}bar", "s3"
 
-test "SDIFFSTORE" do |r|
-  r.sadd "{qux}foo", "s1"
-  r.sadd "{qux}foo", "s2"
-  r.sadd "{qux}bar", "s2"
-  r.sadd "{qux}bar", "s3"
+    assert_equal ["s1"], r.sdiff("{qux}foo", "{qux}bar")
+    assert_equal ["s3"], r.sdiff("{qux}bar", "{qux}foo")
+  end
 
-  r.sdiffstore("{qux}baz", "{qux}foo", "{qux}bar")
+  def test_sdiffstore
+    r.sadd "{qux}foo", "s1"
+    r.sadd "{qux}foo", "s2"
+    r.sadd "{qux}bar", "s2"
+    r.sadd "{qux}bar", "s3"
 
-  assert ["s1"] == r.smembers("{qux}baz")
-end
+    r.sdiffstore("{qux}baz", "{qux}foo", "{qux}bar")
 
-test "SORT" do |r|
-  r.set("{qux}foo:1", "s1")
-  r.set("{qux}foo:2", "s2")
+    assert_equal ["s1"], r.smembers("{qux}baz")
+  end
 
-  r.rpush("{qux}bar", "1")
-  r.rpush("{qux}bar", "2")
+  def test_sort
+    r.set("{qux}foo:1", "s1")
+    r.set("{qux}foo:2", "s2")
 
-  assert ["s1"] == r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1])
-  assert ["s2"] == r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1], :order => "desc alpha")
-end
+    r.rpush("{qux}bar", "1")
+    r.rpush("{qux}bar", "2")
 
-test "SORT with an array of GETs" do |r|
-  r.set("{qux}foo:1:a", "s1a")
-  r.set("{qux}foo:1:b", "s1b")
+    assert_equal ["s1"], r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1])
+    assert_equal ["s2"], r.sort("{qux}bar", :get => "{qux}foo:*", :limit => [0, 1], :order => "desc alpha")
+  end
 
-  r.set("{qux}foo:2:a", "s2a")
-  r.set("{qux}foo:2:b", "s2b")
+  def test_sort_with_an_array_of_gets
+    r.set("{qux}foo:1:a", "s1a")
+    r.set("{qux}foo:1:b", "s1b")
 
-  r.rpush("{qux}bar", "1")
-  r.rpush("{qux}bar", "2")
+    r.set("{qux}foo:2:a", "s2a")
+    r.set("{qux}foo:2:b", "s2b")
 
-  assert ["s1a", "s1b"] == r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1])
-  assert ["s2a", "s2b"] == r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1], :order => "desc alpha")
-end
+    r.rpush("{qux}bar", "1")
+    r.rpush("{qux}bar", "2")
+
+    assert_equal [["s1a", "s1b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1])
+    assert_equal [["s2a", "s2b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+    assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("{qux}bar", :get => ["{qux}foo:*:a", "{qux}foo:*:b"])
+  end
 
-test "SORT with STORE" do |r|
-  r.set("{qux}foo:1", "s1")
-  r.set("{qux}foo:2", "s2")
+  def test_sort_with_store
+    r.set("{qux}foo:1", "s1")
+    r.set("{qux}foo:2", "s2")
 
-  r.rpush("{qux}bar", "1")
-  r.rpush("{qux}bar", "2")
+    r.rpush("{qux}bar", "1")
+    r.rpush("{qux}bar", "2")
 
-  r.sort("{qux}bar", :get => "{qux}foo:*", :store => "{qux}baz")
-  assert ["s1", "s2"] == r.lrange("{qux}baz", 0, -1)
+    r.sort("{qux}bar", :get => "{qux}foo:*", :store => "{qux}baz")
+    assert_equal ["s1", "s2"], r.lrange("{qux}baz", 0, -1)
+  end
 end

data/test/distributed_connection_handling_test.rb

@@ -1,24 +1,23 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedConnectionHandling < Test::Unit::TestCase
 
-test "PING" do |r|
-  assert ["PONG"] == r.ping
-end
+  include Helper::Distributed
+
+  def test_ping
+    assert_equal ["PONG"], r.ping
+  end
 
-test "SELECT" do |r|
-  r.set "foo", "bar"
+  def test_select
+    r.set "foo", "bar"
 
-  r.select 14
-  assert nil == r.get("foo")
+    r.select 14
+    assert_equal nil, r.get("foo")
 
-  r.select 15
+    r.select 15
 
-  assert "bar" == r.get("foo")
+    assert_equal "bar", r.get("foo")
+  end
 end

data/test/distributed_internals_test.rb

@@ -1,27 +1,15 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require File.expand_path("./redis_mock", File.dirname(__FILE__))
+require "helper"
 
-include RedisMock::Helper
+class TestDistributedInternals < Test::Unit::TestCase
 
-require "redis/distributed"
+  include Helper::Distributed
 
-setup do
-  log = StringIO.new
-  [init(Redis::Distributed.new(NODES, :logger => ::Logger.new(log))), log]
-end
-
-$TEST_PIPELINING = false
-
-load File.expand_path("./lint/internals.rb", File.dirname(__FILE__))
-
-test "provides a meaningful inspect" do |r, _|
-  nodes = ["redis://localhost:6379/15", *NODES]
-  @r = Redis::Distributed.new nodes
+  def test_provides_a_meaningful_inspect
+    nodes = ["redis://localhost:#{PORT}/15", *NODES]
+    redis = Redis::Distributed.new nodes
 
-  node_info = nodes.map do |node|
-    "#{node} (Redis v#{@r.info.first["redis_version"]})"
+    assert_equal "#<Redis client v#{Redis::VERSION} for #{redis.nodes.map(&:id).join(', ')}>", redis.inspect
   end
-  assert "#<Redis client v#{Redis::VERSION} connected to #{node_info.join(', ')}>" == @r.inspect
 end

data/test/distributed_key_tags_test.rb

@@ -1,52 +1,52 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
-
-test "hashes consistently" do
-  r1 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
-  r2 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
-  r3 = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
+class TestDistributedKeyTags < Test::Unit::TestCase
 
-  assert r1.node_for("foo").id == r2.node_for("foo").id
-  assert r1.node_for("foo").id == r3.node_for("foo").id
-end
+  include Helper
+  include Helper::Distributed
 
-test "allows clustering of keys" do |r|
-  r = Redis::Distributed.new(NODES)
-  r.add_node("redis://localhost:6379/14")
-  r.flushdb
+  def test_hashes_consistently
+    r1 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
+    r2 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
+    r3 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
 
-  100.times do |i|
-    r.set "{foo}users:#{i}", i
+    assert_equal r1.node_for("foo").id, r2.node_for("foo").id
+    assert_equal r1.node_for("foo").id, r3.node_for("foo").id
   end
 
-  assert [0, 100] == r.nodes.map { |node| node.keys.size }
-end
+  def test_allows_clustering_of_keys
+    r = Redis::Distributed.new(NODES)
+    r.add_node("redis://localhost:#{PORT}/14")
+    r.flushdb
 
-test "distributes keys if no clustering is used" do |r|
-  r.add_node("redis://localhost:6379/14")
-  r.flushdb
+    100.times do |i|
+      r.set "{foo}users:#{i}", i
+    end
 
-  r.set "users:1", 1
-  r.set "users:4", 4
+    assert_equal [0, 100], r.nodes.map { |node| node.keys.size }
+  end
 
-  assert [1, 1] == r.nodes.map { |node| node.keys.size }
-end
+  def test_distributes_keys_if_no_clustering_is_used
+    r.add_node("redis://localhost:#{PORT}/14")
+    r.flushdb
 
-test "allows passing a custom tag extractor" do |r|
-  r = Redis::Distributed.new(NODES, :tag => /^(.+?):/)
-  r.add_node("redis://localhost:6379/14")
-  r.flushdb
+    r.set "users:1", 1
+    r.set "users:4", 4
 
-  100.times do |i|
-    r.set "foo:users:#{i}", i
+    assert_equal [1, 1], r.nodes.map { |node| node.keys.size }
   end
 
-  assert [0, 100] == r.nodes.map { |node| node.keys.size }
+  def test_allows_passing_a_custom_tag_extractor
+    r = Redis::Distributed.new(NODES, :tag => /^(.+?):/)
+    r.add_node("redis://localhost:#{PORT}/14")
+    r.flushdb
+
+    100.times do |i|
+      r.set "foo:users:#{i}", i
+    end
+
+    assert_equal [0, 100], r.nodes.map { |node| node.keys.size }
+  end
 end

data/test/distributed_persistence_control_commands_test.rb

@@ -1,23 +1,26 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require "redis/distributed"
+require "helper"
 
-setup do
-  log = StringIO.new
-  init Redis::Distributed.new(NODES, :logger => ::Logger.new(log))
-end
+class TestDistributedPersistenceControlCommands < Test::Unit::TestCase
+
+  include Helper::Distributed
 
-test "SAVE and BGSAVE" do |r|
-  assert_nothing_raised do
-    r.save
+  def test_save
+    redis_mock(:save => lambda { "+SAVE" }) do |redis|
+      assert_equal ["SAVE"], redis.save
+    end
   end
 
-  assert_nothing_raised do
-    r.bgsave
+  def test_bgsave
+    redis_mock(:bgsave => lambda { "+BGSAVE" }) do |redis|
+      assert_equal ["BGSAVE"], redis.bgsave
+    end
   end
-end
 
-test "LASTSAVE" do |r|
-  assert r.lastsave.all? { |t| Time.at(t) <= Time.now }
+  def test_lastsave
+    redis_mock(:lastsave => lambda { "+LASTSAVE" }) do |redis|
+      assert_equal ["LASTSAVE"], redis.lastsave
+    end
+  end
 end