redis 3.0.0.rc1 → 3.0.0.rc2

data/test/publish_subscribe_test.rb

@@ -1,158 +1,153 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestPublishSubscribe < Test::Unit::TestCase
 
-test "SUBSCRIBE and UNSUBSCRIBE" do |r|
-  listening = false
+  include Helper::Client
 
-  wire = Wire.new do
-    r.subscribe("foo") do |on|
-      on.subscribe do |channel, total|
-        @subscribed = true
-        @t1 = total
-      end
+  def test_subscribe_and_unsubscribe
+    @subscribed = false
+    @unsubscribed = false
 
-      on.message do |channel, message|
-        if message == "s1"
-          r.unsubscribe
-          @message = message
+    wire = Wire.new do
+      r.subscribe("foo") do |on|
+        on.subscribe do |channel, total|
+          @subscribed = true
+          @t1 = total
         end
-      end
 
-      on.unsubscribe do |channel, total|
-        @unsubscribed = true
-        @t2 = total
-      end
+        on.message do |channel, message|
+          if message == "s1"
+            r.unsubscribe
+            @message = message
+          end
+        end
 
-      listening = true
+        on.unsubscribe do |channel, total|
+          @unsubscribed = true
+          @t2 = total
+        end
+      end
     end
-  end
 
-  Wire.pass while !listening
+    # Wait until the subscription is active before publishing
+    Wire.pass while !@subscribed
 
-  Redis.new(OPTIONS).publish("foo", "s1")
+    Redis.new(OPTIONS).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 "PSUBSCRIBE and PUNSUBSCRIBE" do |r|
-  listening = false
+  def test_psubscribe_and_punsubscribe
+    @subscribed = false
+    @unsubscribed = false
 
-  wire = Wire.new do
-    r.psubscribe("f*") do |on|
-      on.psubscribe do |pattern, total|
-        @subscribed = true
-        @t1 = total
-      end
+    wire = Wire.new do
+      r.psubscribe("f*") do |on|
+        on.psubscribe do |pattern, total|
+          @subscribed = true
+          @t1 = total
+        end
 
-      on.pmessage do |pattern, channel, message|
-        if message == "s1"
-          r.punsubscribe
-          @message = message
+        on.pmessage do |pattern, channel, message|
+          if message == "s1"
+            r.punsubscribe
+            @message = message
+          end
         end
-      end
 
-      on.punsubscribe do |pattern, total|
-        @unsubscribed = true
-        @t2 = total
-      end
+        on.punsubscribe do |pattern, total|
+          @unsubscribed = true
+          @t2 = total
+        end
 
-      listening = true
+        listening = true
+      end
     end
-  end
 
-  Wire.pass while !listening
+    # Wait until the subscription is active before publishing
+    Wire.pass while !@subscribed
 
-  Redis.new(OPTIONS).publish("foo", "s1")
+    Redis.new(OPTIONS).publish("foo", "s1")
 
-  wire.join
-
-  assert @subscribed
-  assert 1 == @t1
-  assert @unsubscribed
-  assert 0 == @t2
-  assert "s1" == @message
-end
+    wire.join
 
-test "SUBSCRIBE within SUBSCRIBE" do |r|
-  listening = false
+    assert @subscribed
+    assert_equal 1, @t1
+    assert @unsubscribed
+    assert_equal 0, @t2
+    assert_equal "s1", @message
+  end
 
-  @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.new(OPTIONS).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
 
-test "UNSUBSCRIBE without a SUBSCRIBE" do |r|
-  assert_raise RuntimeError do
-    r.unsubscribe
-  end
+  def test_unsubscribe_without_a_subscribe
+    assert_raise RuntimeError do
+      r.unsubscribe
+    end
 
-  assert_raise RuntimeError do
-    r.punsubscribe
+    assert_raise RuntimeError do
+      r.punsubscribe
+    end
   end
-end
 
-test "SUBSCRIBE past a timeout" do |r|
-  # For some reason, a thread here doesn't reproduce the issue.
-  sleep = %{sleep #{OPTIONS[:timeout] + 1}}
-  publish = %{echo "publish foo bar\r\n" | nc localhost #{OPTIONS[:port]}}
-  cmd = [sleep, publish].join("; ")
+  def test_subscribe_past_a_timeout
+    # For some reason, a thread here doesn't reproduce the issue.
+    sleep = %{sleep #{OPTIONS[:timeout] * 2}}
+    publish = %{echo "publish foo bar\r\n" | nc localhost #{OPTIONS[:port]}}
+    cmd = [sleep, publish].join("; ")
 
-  IO.popen(cmd, "r+") do |pipe|
-    received = false
+    IO.popen(cmd, "r+") do |pipe|
+      received = false
 
-    r.subscribe "foo" do |on|
-      on.message do |channel, message|
-        received = true
-        r.unsubscribe
+      r.subscribe "foo" do |on|
+        on.message do |channel, message|
+          received = true
+          r.unsubscribe
+        end
       end
-    end
 
-    assert received
+      assert received
+    end
   end
 end

data/test/remote_server_control_commands_test.rb

@@ -1,88 +1,104 @@
 # 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 TestRemoteServerControlCommands < Test::Unit::TestCase
 
-setup do
-  init Redis.new(OPTIONS)
-end
+  include Helper::Client
 
-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|
-    assert r.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|
+      assert r.info.keys.include?(x)
+    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.config(:resetstat)
-  r.ping
+    r.config(:resetstat)
+    r.ping
 
-  result = r.info(:commandstats)
-  assert "1" == result["ping"]["calls"]
-end
+    result = r.info(:commandstats)
+    assert_equal "1", result["ping"]["calls"]
+  end
+
+  def test_monitor_redis_lt_2_5_0
+    return unless version < "2.5.0"
 
-test "MONITOR" do |r|
-  log = []
+    log = []
 
-  wire = Wire.new do
-    Redis.new(OPTIONS).monitor do |line|
-      log << line
-      break if log.size == 3
+    wire = Wire.new do
+      Redis.new(OPTIONS).monitor do |line|
+        log << line
+        break if log.size == 3
+      end
     end
+
+    Wire.pass while log.empty? # Faster than sleep
+
+    r.set "foo", "s1"
+
+    wire.join
+
+    assert log[-1][%q{(db 15) "set" "foo" "s1"}]
   end
 
-  Wire.pass while log.empty? # Faster than sleep
+  def test_monitor_redis_gte_2_5_0
+    return unless version >= "2.5.0"
 
-  r.set "foo", "s1"
+    log = []
 
-  wire.join
+    wire = Wire.new do
+      Redis.new(OPTIONS).monitor do |line|
+        log << line
+        break if line =~ /set/
+      end
+    end
 
-  assert log[-1][%q{(db 15) "set" "foo" "s1"}]
-end
+    Wire.pass while log.empty? # Faster than sleep
 
-test "MONITOR returns value for break" do |r|
-  result = r.monitor do |line|
-    break line
-  end
+    r.set "foo", "s1"
 
-  assert result == "OK"
-end
+    wire.join
 
-test "ECHO" do |r|
-  assert "foo bar baz\n" == r.echo("foo bar baz\n")
-end
+    assert log[-1] =~ /\b15\b.* "set" "foo" "s1"/
+  end
 
-test "DEBUG" do |r|
-  r.set "foo", "s1"
+  def test_monitor_returns_value_for_break
+    result = r.monitor do |line|
+      break line
+    end
 
-  assert r.debug(:object, "foo").kind_of?(String)
-end
+    assert_equal result, "OK"
+  end
 
-test "OBJECT" do |r|
-  r.lpush "list", "value"
+  def test_echo
+    assert_equal "foo bar baz\n", r.echo("foo bar baz\n")
+  end
 
-  assert r.object(:refcount, "list") == 1
-  assert r.object(:encoding, "list") == "ziplist"
-  assert r.object(:idletime, "list").kind_of?(Fixnum)
-end
+  def test_debug
+    r.set "foo", "s1"
 
-test "SYNC" do |r|
-  replies = {:sync => lambda { "+OK" }}
+    assert r.debug(:object, "foo").kind_of?(String)
+  end
 
-  redis_mock(replies) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
+  def test_object
+    r.lpush "list", "value"
 
-    assert "OK" == redis.sync
+    assert_equal r.object(:refcount, "list"), 1
+    assert_equal r.object(:encoding, "list"), "ziplist"
+    assert r.object(:idletime, "list").kind_of?(Fixnum)
+  end
+
+  def test_sync
+    redis_mock(:sync => lambda { "+OK" }) do |redis|
+      assert_equal "OK", redis.sync
+    end
   end
-end
 
-test "SLOWLOG" do |r|
-  r.slowlog(:reset)
-  result = r.slowlog(:len)
-  assert result == 0
+  def test_slowlog
+    r.slowlog(:reset)
+    result = r.slowlog(:len)
+    assert_equal result, 0
+  end
 end

data/test/sorting_test.rb

@@ -1,43 +1,45 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestSorting < Test::Unit::TestCase
 
-test "SORT" do |r|
-  r.set("foo:1", "s1")
-  r.set("foo:2", "s2")
+  include Helper::Client
 
-  r.rpush("bar", "1")
-  r.rpush("bar", "2")
+  def test_sort
+    r.set("foo:1", "s1")
+    r.set("foo:2", "s2")
 
-  assert ["s1"] == r.sort("bar", :get => "foo:*", :limit => [0, 1])
-  assert ["s2"] == r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
-end
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
 
-test "SORT with an array of GETs" do |r|
-  r.set("foo:1:a", "s1a")
-  r.set("foo:1:b", "s1b")
+    assert_equal ["s1"], r.sort("bar", :get => "foo:*", :limit => [0, 1])
+    assert_equal ["s2"], r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
+  end
 
-  r.set("foo:2:a", "s2a")
-  r.set("foo:2:b", "s2b")
+  def test_sort_with_an_array_of_gets
+    r.set("foo:1:a", "s1a")
+    r.set("foo:1:b", "s1b")
 
-  r.rpush("bar", "1")
-  r.rpush("bar", "2")
+    r.set("foo:2:a", "s2a")
+    r.set("foo:2:b", "s2b")
 
-  assert ["s1a", "s1b"] == r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
-  assert ["s2a", "s2b"] == r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
-end
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
+
+    assert_equal [["s1a", "s1b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
+    assert_equal [["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+    assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"])
+  end
 
-test "SORT with STORE" do |r|
-  r.set("foo:1", "s1")
-  r.set("foo:2", "s2")
+  def test_sort_with_store
+    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:*", :store => "baz")
-  assert ["s1", "s2"] == r.lrange("baz", 0, -1)
+    r.sort("bar", :get => "foo:*", :store => "baz")
+    assert_equal ["s1", "s2"], r.lrange("baz", 0, -1)
+  end
 end