redis 3.0.0.rc1 → 3.0.0.rc2

data/test/distributed_publish_subscribe_test.rb

@@ -1,100 +1,92 @@
 # 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 TestDistributedPublishSubscribe < Test::Unit::TestCase
 
-test "SUBSCRIBE and UNSUBSCRIBE" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.subscribe("foo", "bar") { }
-  end
+  include Helper::Distributed
+
+  def test_subscribe_and_unsubscribe
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.subscribe("foo", "bar") { }
+    end
 
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.subscribe("{qux}foo", "bar") { }
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.subscribe("{qux}foo", "bar") { }
+    end
   end
-end
 
-test "SUBSCRIBE and UNSUBSCRIBE with tags" do |r|
-  listening = false
+  def test_subscribe_and_unsubscribe_with_tags
+    @subscribed = false
+    @unsubscribed = false
 
-  wire = Wire.new do
-    r.subscribe("foo") do |on|
-      on.subscribe do |channel, total|
-        @subscribed = true
-        @t1 = total
-      end
+    wire = Wire.new do
+      r.subscribe("foo") do |on|
+        on.subscribe do |channel, total|
+          @subscribed = true
+          @t1 = total
+        end
 
-      on.message do |channel, message|
-        if message == "s1"
-          r.unsubscribe
-          @message = message
+        on.message do |channel, message|
+          if message == "s1"
+            r.unsubscribe
+            @message = message
+          end
         end
-      end
 
-      on.unsubscribe do |channel, total|
-        @unsubscribed = true
-        @t2 = total
+        on.unsubscribe do |channel, total|
+          @unsubscribed = true
+          @t2 = total
+        end
       end
-
-      listening = true
     end
-  end
 
-  Wire.pass while !listening
+    # Wait until the subscription is active before publishing
+    Wire.pass while !@subscribed
 
-  Redis::Distributed.new(NODES).publish("foo", "s1")
+    Redis::Distributed.new(NODES).publish("foo", "s1")
 
-  wire.join
+    wire.join
 
-  assert @subscribed
-  assert 1 == @t1
-  assert @unsubscribed
-  assert 0 == @t2
-  assert "s1" == @message
-end
+    assert @subscribed
+    assert_equal 1, @t1
+    assert @unsubscribed
+    assert_equal 0, @t2
+    assert_equal "s1", @message
+  end
 
-test "SUBSCRIBE within SUBSCRIBE" do |r|
-  listening = false
-  @channels = []
+  def test_subscribe_within_subscribe
+    @channels = []
 
-  wire = Wire.new do
-    r.subscribe("foo") do |on|
-      on.subscribe do |channel, total|
-        @channels << channel
+    wire = Wire.new do
+      r.subscribe("foo") do |on|
+        on.subscribe do |channel, total|
+          @channels << channel
 
-        r.subscribe("bar") if channel == "foo"
-        r.unsubscribe if channel == "bar"
+          r.subscribe("bar") if channel == "foo"
+          r.unsubscribe if channel == "bar"
+        end
       end
-
-      listening = true
     end
-  end
-
-  Wire.pass while !listening
 
-  Redis::Distributed.new(NODES).publish("foo", "s1")
+    wire.join
 
-  wire.join
-
-  assert ["foo", "bar"] == @channels
-end
+    assert_equal ["foo", "bar"], @channels
+  end
 
-test "other commands within a SUBSCRIBE" do |r|
-  assert_raise Redis::CommandError do
-    r.subscribe("foo") do |on|
-      on.subscribe do |channel, total|
-        r.set("bar", "s2")
+  def test_other_commands_within_a_subscribe
+    assert_raise Redis::CommandError do
+      r.subscribe("foo") do |on|
+        on.subscribe do |channel, total|
+          r.set("bar", "s2")
+        end
       end
     end
   end
-end
 
-test "SUBSCRIBE without a block" do |r|
-  assert_raise LocalJumpError do
-    r.subscribe("foo")
+  def test_subscribe_without_a_block
+    assert_raise LocalJumpError do
+      r.subscribe("foo")
+    end
   end
 end

data/test/distributed_remote_server_control_commands_test.rb

@@ -1,42 +1,53 @@
 # 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 TestDistributedRemoteServerControlCommands < Test::Unit::TestCase
+
+  include Helper::Distributed
 
-test "INFO" do |r|
-  %w(last_save_time redis_version total_connections_received connected_clients total_commands_processed connected_slaves uptime_in_seconds used_memory uptime_in_days changes_since_last_save).each do |x|
-    r.info.each do |info|
-      assert info.keys.include?(x)
+  def test_info
+    %w(last_save_time redis_version total_connections_received connected_clients total_commands_processed connected_slaves uptime_in_seconds used_memory uptime_in_days changes_since_last_save).each do |x|
+      r.info.each do |info|
+        assert info.keys.include?(x)
+      end
     end
   end
-end
 
-test "INFO COMMANDSTATS" do |r|
-  # Only available on Redis >= 2.9.0
-  next if version(r) < 209000
+  def test_info_commandstats
+    return if version < "2.9.0"
 
-  r.nodes.each { |n| n.config(:resetstat) }
-  r.ping # Executed on every node
+    r.nodes.each { |n| n.config(:resetstat) }
+    r.ping # Executed on every node
 
-  r.info(:commandstats).each do |info|
-    assert "1" == info["ping"]["calls"]
+    r.info(:commandstats).each do |info|
+      assert_equal "1", info["ping"]["calls"]
+    end
   end
-end
 
-test "MONITOR" do |r|
-  begin
-    r.monitor
-  rescue Exception => ex
-  ensure
-    assert ex.kind_of?(NotImplementedError)
+  def test_monitor
+    begin
+      r.monitor
+    rescue Exception => ex
+    ensure
+      assert ex.kind_of?(NotImplementedError)
+    end
   end
-end
 
-test "ECHO" do |r|
-  assert ["foo bar baz\n"] == r.echo("foo bar baz\n")
+  def test_echo
+    assert_equal ["foo bar baz\n"], r.echo("foo bar baz\n")
+  end
+
+  def test_time
+    return if version < "2.5.4"
+
+    # Test that the difference between the time that Ruby reports and the time
+    # that Redis reports is minimal (prevents the test from being racy).
+    r.time.each do |rv|
+      redis_usec = rv[0] * 1_000_000 + rv[1]
+      ruby_usec = Integer(Time.now.to_f * 1_000_000)
+
+      assert 500_000 > (ruby_usec - redis_usec).abs
+    end
+  end
 end

data/test/distributed_sorting_test.rb

@@ -1,21 +1,20 @@
 # 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 TestDistributedSorting < Test::Unit::TestCase
+
+  include Helper::Distributed
 
-test "SORT" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.set("foo:1", "s1")
-    r.set("foo:2", "s2")
+  def test_sort
+    assert_raise(Redis::Distributed::CannotDistribute) do
+      r.set("foo:1", "s1")
+      r.set("foo:2", "s2")
 
-    r.rpush("bar", "1")
-    r.rpush("bar", "2")
+      r.rpush("bar", "1")
+      r.rpush("bar", "2")
 
-    r.sort("bar", :get => "foo:*", :limit => [0, 1])
+      r.sort("bar", :get => "foo:*", :limit => [0, 1])
+    end
   end
 end

data/test/distributed_test.rb

@@ -1,59 +1,58 @@
 # 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 TestDistributed < Test::Unit::TestCase
 
-test "handle multiple servers" do
-  @r = Redis::Distributed.new ["redis://localhost:6379/15", *NODES]
+  include Helper::Distributed
 
-  100.times do |idx|
-    @r.set(idx.to_s, "foo#{idx}")
-  end
+  def test_handle_multiple_servers
+    @r = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
 
-  100.times do |idx|
-    assert "foo#{idx}" == @r.get(idx.to_s)
-  end
+    100.times do |idx|
+      @r.set(idx.to_s, "foo#{idx}")
+    end
 
-  assert "0" == @r.keys("*").sort.first
-  assert "string" == @r.type("1")
-end
+    100.times do |idx|
+      assert_equal "foo#{idx}", @r.get(idx.to_s)
+    end
 
-test "add nodes" do
-  logger = Logger.new("/dev/null")
+    assert_equal "0", @r.keys("*").sort.first
+    assert_equal "string", @r.type("1")
+  end
 
-  @r = Redis::Distributed.new NODES, :logger => logger, :timeout => 10
+  def test_add_nodes
+    logger = Logger.new("/dev/null")
 
-  assert "127.0.0.1" == @r.nodes[0].client.host
-  assert 6379 == @r.nodes[0].client.port
-  assert 15 == @r.nodes[0].client.db
-  assert 10 == @r.nodes[0].client.timeout
-  assert logger == @r.nodes[0].client.logger
+    @r = Redis::Distributed.new NODES, :logger => logger, :timeout => 10
 
-  @r.add_node("redis://localhost:6380/14")
+    assert_equal "127.0.0.1", @r.nodes[0].client.host
+    assert_equal PORT, @r.nodes[0].client.port
+    assert_equal 15, @r.nodes[0].client.db
+    assert_equal 10, @r.nodes[0].client.timeout
+    assert_equal logger, @r.nodes[0].client.logger
 
-  assert "localhost" == @r.nodes[1].client.host
-  assert 6380 == @r.nodes[1].client.port
-  assert 14 == @r.nodes[1].client.db
-  assert 10 == @r.nodes[1].client.timeout
-  assert logger == @r.nodes[1].client.logger
-end
+    @r.add_node("redis://localhost:6380/14")
+
+    assert_equal "localhost", @r.nodes[1].client.host
+    assert_equal 6380, @r.nodes[1].client.port
+    assert_equal 14, @r.nodes[1].client.db
+    assert_equal 10, @r.nodes[1].client.timeout
+    assert_equal logger, @r.nodes[1].client.logger
+  end
 
-test "Pipelining commands cannot be distributed" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.pipelined do
-      r.lpush "foo", "s1"
-      r.lpush "foo", "s2"
+  def test_pipelining_commands_cannot_be_distributed
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.pipelined do
+        r.lpush "foo", "s1"
+        r.lpush "foo", "s2"
+      end
     end
   end
-end
 
-test "Unknown commands does not work by default" do |r|
-  assert_raise NoMethodError do
-    r.not_yet_implemented_command
+  def test_unknown_commands_does_not_work_by_default
+    assert_raise NoMethodError do
+      r.not_yet_implemented_command
+    end
   end
 end

data/test/distributed_transactions_test.rb

@@ -1,33 +1,32 @@
 # 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 TestDistributedTransactions < Test::Unit::TestCase
 
-test "MULTI/DISCARD" do |r|
-  @foo = nil
+  include Helper::Distributed
 
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.multi { @foo = 1 }
-  end
+  def test_multi_discard
+    @foo = nil
 
-  assert nil == @foo
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.multi { @foo = 1 }
+    end
 
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.discard
-  end
-end
+    assert_equal nil, @foo
 
-test "WATCH/UNWATCH" do |r|
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.watch("foo")
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.discard
+    end
   end
 
-  assert_raise Redis::Distributed::CannotDistribute do
-    r.unwatch
+  def test_watch_unwatch
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.watch("foo")
+    end
+
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.unwatch
+    end
   end
 end

data/test/encoding_test.rb

@@ -1,15 +1,18 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestEncoding < Test::Unit::TestCase
+
+  include Helper::Client
 
-test "returns properly encoded strings" do |r|
-  with_external_encoding("UTF-8") do
-    r.set "foo", "שלום"
+  def test_returns_properly_encoded_strings
+    if defined?(Encoding)
+      with_external_encoding("UTF-8") do
+        r.set "foo", "שלום"
 
-    assert "Shalom שלום" == "Shalom " + r.get("foo")
+        assert_equal "Shalom שלום", "Shalom " + r.get("foo")
+      end
+    end
   end
-end if defined?(Encoding)
+end