redis 3.0.0.rc1 → 3.0.0.rc2

data/test/commands_on_strings_test.rb

@@ -1,80 +1,89 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
+require "lint/strings"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestCommandsOnStrings < Test::Unit::TestCase
 
-load './test/lint/strings.rb'
+  include Helper::Client
+  include Lint::Strings
 
-test "MGET" do |r|
-  r.set("foo", "s1")
-  r.set("bar", "s2")
+  def test_mget
+    r.set("foo", "s1")
+    r.set("bar", "s2")
 
-  assert ["s1", "s2"]      == r.mget("foo", "bar")
-  assert ["s1", "s2", nil] == r.mget("foo", "bar", "baz")
-end
+    assert_equal ["s1", "s2"]     , r.mget("foo", "bar")
+    assert_equal ["s1", "s2", nil], r.mget("foo", "bar", "baz")
+  end
 
-test "MGET mapped" do |r|
-  r.set("foo", "s1")
-  r.set("bar", "s2")
+  def test_mget_mapped
+    r.set("foo", "s1")
+    r.set("bar", "s2")
 
-  response = r.mapped_mget("foo", "bar")
+    response = r.mapped_mget("foo", "bar")
 
-  assert "s1" == response["foo"]
-  assert "s2" == response["bar"]
+    assert_equal "s1", response["foo"]
+    assert_equal "s2", response["bar"]
 
-  response = r.mapped_mget("foo", "bar", "baz")
+    response = r.mapped_mget("foo", "bar", "baz")
 
-  assert "s1" == response["foo"]
-  assert "s2" == response["bar"]
-  assert nil  == response["baz"]
-end
+    assert_equal "s1", response["foo"]
+    assert_equal "s2", response["bar"]
+    assert_equal nil , response["baz"]
+  end
 
-test "Mapped MGET in a pipeline returns hash" do |r|
-  r.set("foo", "s1")
-  r.set("bar", "s2")
+  def test_mapped_mget_in_a_pipeline_returns_hash
+    r.set("foo", "s1")
+    r.set("bar", "s2")
 
-  result = r.pipelined do
-    r.mapped_mget("foo", "bar")
-  end
+    result = r.pipelined do
+      r.mapped_mget("foo", "bar")
+    end
 
-  assert result[0] == { "foo" => "s1", "bar" => "s2" }
-end
+    assert_equal result[0], { "foo" => "s1", "bar" => "s2" }
+  end
 
-test "MSET" do |r|
-  r.mset(:foo, "s1", :bar, "s2")
+  def test_mset
+    r.mset(:foo, "s1", :bar, "s2")
 
-  assert "s1" == r.get("foo")
-  assert "s2" == r.get("bar")
-end
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+  end
 
-test "MSET mapped" do |r|
-  r.mapped_mset(:foo => "s1", :bar => "s2")
+  def test_mset_mapped
+    r.mapped_mset(:foo => "s1", :bar => "s2")
 
-  assert "s1" == r.get("foo")
-  assert "s2" == r.get("bar")
-end
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+  end
 
-test "MSETNX" do |r|
-  r.set("foo", "s1")
-  r.msetnx(:foo, "s2", :bar, "s3")
+  def test_msetnx
+    r.set("foo", "s1")
+    assert_equal false, r.msetnx(:foo, "s2", :bar, "s3")
+    assert_equal "s1", r.get("foo")
+    assert_equal nil, r.get("bar")
 
-  assert "s1" == r.get("foo")
-  assert nil == r.get("bar")
-end
+    r.del("foo")
+    assert_equal true, r.msetnx(:foo, "s2", :bar, "s3")
+    assert_equal "s2", r.get("foo")
+    assert_equal "s3", r.get("bar")
+  end
 
-test "MSETNX mapped" do |r|
-  r.set("foo", "s1")
-  r.mapped_msetnx(:foo => "s2", :bar => "s3")
+  def test_msetnx_mapped
+    r.set("foo", "s1")
+    assert_equal false, r.mapped_msetnx(:foo => "s2", :bar => "s3")
+    assert_equal "s1", r.get("foo")
+    assert_equal nil, r.get("bar")
 
-  assert "s1" == r.get("foo")
-  assert nil == r.get("bar")
-end
+    r.del("foo")
+    assert_equal true, r.mapped_msetnx(:foo => "s2", :bar => "s3")
+    assert_equal "s2", r.get("foo")
+    assert_equal "s3", r.get("bar")
+  end
 
-test "STRLEN" do |r|
-  r.set "foo", "lorem"
+  def test_strlen
+    r.set "foo", "lorem"
 
-  assert 5 == r.strlen("foo")
+    assert_equal 5, r.strlen("foo")
+  end
 end

data/test/commands_on_value_types_test.rb

@@ -1,87 +1,99 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
-require File.expand_path("./redis_mock", File.dirname(__FILE__))
+require "helper"
+require "lint/value_types"
 
-include RedisMock::Helper
+class TestCommandsOnValueTypes < Test::Unit::TestCase
 
-setup do
-  init Redis.new(OPTIONS)
-end
+  include Helper::Client
+  include Lint::ValueTypes
 
-load "./test/lint/value_types.rb"
+  def test_del
+    r.set "foo", "s1"
+    r.set "bar", "s2"
+    r.set "baz", "s3"
 
-test "DEL" do |r|
-  r.set "foo", "s1"
-  r.set "bar", "s2"
-  r.set "baz", "s3"
+    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
 
-  assert ["bar", "baz", "foo"] == r.keys("*").sort
+    assert_equal 1, r.del("foo")
 
-  assert 1 == r.del("foo")
+    assert_equal ["bar", "baz"], r.keys("*").sort
 
-  assert ["bar", "baz"] == r.keys("*").sort
+    assert_equal 2, r.del("bar", "baz")
 
-  assert 2 == r.del("bar", "baz")
+    assert_equal [], r.keys("*").sort
+  end
 
-  assert [] == r.keys("*").sort
-end
+  def test_del_with_array_argument
+    r.set "foo", "s1"
+    r.set "bar", "s2"
+    r.set "baz", "s3"
 
-test "RANDOMKEY" do |r|
-  assert r.randomkey.to_s.empty?
+    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
 
-  r.set("foo", "s1")
+    assert_equal 1, r.del(["foo"])
 
-  assert "foo" == r.randomkey
+    assert_equal ["bar", "baz"], r.keys("*").sort
 
-  r.set("bar", "s2")
+    assert_equal 2, r.del(["bar", "baz"])
 
-  4.times do
-    assert ["foo", "bar"].include?(r.randomkey)
+    assert_equal [], r.keys("*").sort
   end
-end
 
-test "RENAME" do |r|
-  r.set("foo", "s1")
-  r.rename "foo", "bar"
+  def test_randomkey
+    assert r.randomkey.to_s.empty?
 
-  assert "s1" == r.get("bar")
-  assert nil == r.get("foo")
-end
+    r.set("foo", "s1")
 
-test "RENAMENX" do |r|
-  r.set("foo", "s1")
-  r.set("bar", "s2")
+    assert_equal "foo", r.randomkey
 
-  assert false == r.renamenx("foo", "bar")
+    r.set("bar", "s2")
 
-  assert "s1" == r.get("foo")
-  assert "s2" == r.get("bar")
-end
+    4.times do
+      assert ["foo", "bar"].include?(r.randomkey)
+    end
+  end
 
-test "DBSIZE" do |r|
-  assert 0 == r.dbsize
+  def test_rename
+    r.set("foo", "s1")
+    r.rename "foo", "bar"
 
-  r.set("foo", "s1")
+    assert_equal "s1", r.get("bar")
+    assert_equal nil, r.get("foo")
+  end
 
-  assert 1 == r.dbsize
-end
+  def test_renamenx
+    r.set("foo", "s1")
+    r.set("bar", "s2")
 
-test "FLUSHDB" do |r|
-  r.set("foo", "s1")
-  r.set("bar", "s2")
+    assert_equal false, r.renamenx("foo", "bar")
 
-  assert 2 == r.dbsize
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+  end
 
-  r.flushdb
+  def test_dbsize
+    assert_equal 0, r.dbsize
 
-  assert 0 == r.dbsize
-end
+    r.set("foo", "s1")
+
+    assert_equal 1, r.dbsize
+  end
 
-test "FLUSHALL" do
-  redis_mock(:flushall => lambda { "+FLUSHALL" }) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
+  def test_flushdb
+    r.set("foo", "s1")
+    r.set("bar", "s2")
+
+    assert_equal 2, r.dbsize
+
+    r.flushdb
+
+    assert_equal 0, r.dbsize
+  end
 
-    assert "FLUSHALL" == redis.flushall
+  def test_flushall
+    redis_mock(:flushall => lambda { "+FLUSHALL" }) do |redis|
+      assert_equal "FLUSHALL", redis.flushall
+    end
   end
 end

data/test/connection_handling_test.rb

@@ -1,204 +1,189 @@
 # 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 TestConnectionHandling < Test::Unit::TestCase
 
-setup do
-  init Redis.new(OPTIONS)
-end
-
-test "AUTH" do
-  replies = {
-    :auth => lambda { |password| $auth = password; "+OK" },
-    :get  => lambda { |key| $auth == "secret" ? "$3\r\nbar" : "$-1" },
-  }
+  include Helper::Client
 
-  redis_mock(replies) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380, :password => "secret"))
+  def test_auth
+    commands = {
+      :auth => lambda { |password| $auth = password; "+OK" },
+      :get  => lambda { |key| $auth == "secret" ? "$3\r\nbar" : "$-1" },
+    }
 
-    assert "bar" == redis.get("foo")
+    redis_mock(commands, :password => "secret") do |redis|
+      assert_equal "bar", redis.get("foo")
+    end
   end
-end
-
-test "PING" do |r|
-  assert "PONG" == r.ping
-end
 
-test "SELECT" do |r|
-  r.set "foo", "bar"
+  def test_ping
+    assert_equal "PONG", r.ping
+  end
 
-  r.select 14
-  assert nil == r.get("foo")
+  def test_select
+    r.set "foo", "bar"
 
-  r.client.disconnect
+    r.select 14
+    assert_equal nil, r.get("foo")
 
-  assert nil == r.get("foo")
-end
+    r.client.disconnect
 
-test "QUIT" do |r|
-  r.quit
+    assert_equal nil, r.get("foo")
+  end
 
-  assert !r.client.connected?
-end
+  def test_quit
+    r.quit
 
-test "SHUTDOWN" do
-  commands = {
-    :shutdown => lambda { :exit }
-  }
+    assert !r.client.connected?
+  end
 
-  redis_mock(commands) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
+  def test_shutdown
+    commands = {
+      :shutdown => lambda { :exit }
+    }
 
-    # SHUTDOWN does not reply: test that it does not raise here.
-    assert nil == redis.shutdown
+    redis_mock(commands) do |redis|
+      # SHUTDOWN does not reply: test that it does not raise here.
+      assert_equal nil, redis.shutdown
+    end
   end
-end
 
-test "SHUTDOWN with error" do
-  connections = 0
-  commands = {
-    :select => lambda { |*_| connections += 1; "+OK\r\n" },
-    :connections => lambda { ":#{connections}\r\n" },
-    :shutdown => lambda { "-ERR could not shutdown\r\n" }
-  }
+  def test_shutdown_with_error
+    connections = 0
+    commands = {
+      :select => lambda { |*_| connections += 1; "+OK\r\n" },
+      :connections => lambda { ":#{connections}\r\n" },
+      :shutdown => lambda { "-ERR could not shutdown\r\n" }
+    }
 
-  redis_mock(commands) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
+    redis_mock(commands) do |redis|
+      connections = redis.connections
 
-    connections = redis.connections
+      # SHUTDOWN replies with an error: test that it gets raised
+      assert_raise Redis::CommandError do
+        redis.shutdown
+      end
 
-    # SHUTDOWN replies with an error: test that it gets raised
-    assert_raise Redis::CommandError do
-      redis.shutdown
+      # The connection should remain in tact
+      assert_equal connections, redis.connections
     end
-
-    # The connection should remain in tact
-    assert connections == redis.connections
   end
-end
 
-test "SHUTDOWN from pipeline" do
-  commands = {
-    :shutdown => lambda { :exit }
-  }
+  def test_shutdown_from_pipeline
+    commands = {
+      :shutdown => lambda { :exit }
+    }
 
-  redis_mock(commands) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
+    redis_mock(commands) do |redis|
+      result = redis.pipelined do
+        redis.shutdown
+      end
 
-    result = redis.pipelined do
-      redis.shutdown
+      assert_equal nil, result
+      assert !redis.client.connected?
     end
-
-    assert nil == result
-    assert !redis.client.connected?
   end
-end
 
-test "SHUTDOWN with error from pipeline" do
-  connections = 0
-  commands = {
-    :select => lambda { |*_| connections += 1; "+OK\r\n" },
-    :connections => lambda { ":#{connections}\r\n" },
-    :shutdown => lambda { "-ERR could not shutdown\r\n" }
-  }
+  def test_shutdown_with_error_from_pipeline
+    connections = 0
+    commands = {
+      :select => lambda { |*_| connections += 1; "+OK\r\n" },
+      :connections => lambda { ":#{connections}\r\n" },
+      :shutdown => lambda { "-ERR could not shutdown\r\n" }
+    }
+
+    redis_mock(commands) do |redis|
+      connections = redis.connections
+
+      # SHUTDOWN replies with an error: test that it gets raised
+      assert_raise Redis::CommandError do
+        redis.pipelined do
+          redis.shutdown
+        end
+      end
 
-  redis_mock(commands) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
+      # The connection should remain in tact
+      assert_equal connections, redis.connections
+    end
+  end
 
-    connections = redis.connections
+  def test_shutdown_from_multi_exec
+    commands = {
+      :multi => lambda { "+OK\r\n" },
+      :shutdown => lambda { "+QUEUED\r\n" },
+      :exec => lambda { :exit }
+    }
 
-    # SHUTDOWN replies with an error: test that it gets raised
-    assert_raise Redis::CommandError do
-      redis.pipelined do
+    redis_mock(commands) do |redis|
+      result = redis.multi do
         redis.shutdown
       end
-    end
 
-    # The connection should remain in tact
-    assert connections == redis.connections
+      assert_equal nil, result
+      assert !redis.client.connected?
+    end
   end
-end
 
-test "SHUTDOWN from MULTI/EXEC" do
-  commands = {
-    :multi => lambda { "+OK\r\n" },
-    :shutdown => lambda { "+QUEUED\r\n" },
-    :exec => lambda { :exit }
-  }
+  def test_shutdown_with_error_from_multi_exec
+    connections = 0
+    commands = {
+      :select => lambda { |*_| connections += 1; "+OK\r\n" },
+      :connections => lambda { ":#{connections}\r\n" },
+      :multi => lambda { "+OK\r\n" },
+      :shutdown => lambda { "+QUEUED\r\n" },
+      :exec => lambda { "*1\r\n-ERR could not shutdown\r\n" }
+    }
+
+    redis_mock(commands) do |redis|
+      connections = redis.connections
+
+      # SHUTDOWN replies with an error: test that it gets returned
+      # We should test for Redis::CommandError here, but hiredis doesn't yet do
+      # custom error classes.
+      err = nil
+
+      begin
+        redis.multi { redis.shutdown }
+      rescue => err
+      end
 
-  redis_mock(commands) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
+      assert err.kind_of?(StandardError)
 
-    result = redis.multi do
-      redis.shutdown
+      # The connection should remain intact
+      assert_equal connections, redis.connections
     end
-
-    assert nil == result
-    assert !redis.client.connected?
   end
-end
 
-test "SHUTDOWN with error from MULTI/EXEC" do
-  connections = 0
-  commands = {
-    :select => lambda { |*_| connections += 1; "+OK\r\n" },
-    :connections => lambda { ":#{connections}\r\n" },
-    :multi => lambda { "+OK\r\n" },
-    :shutdown => lambda { "+QUEUED\r\n" },
-    :exec => lambda { "*1\r\n-ERR could not shutdown\r\n" }
-  }
-
-  redis_mock(commands) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
-
-    connections = redis.connections
-
-    # SHUTDOWN replies with an error: test that it gets returned
-    # We should test for Redis::CommandError here, but hiredis doesn't yet do
-    # custom error classes.
-    assert_raise(StandardError) do
-      redis.multi { redis.shutdown }
+  def test_slaveof
+    redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do |redis|
+      assert_equal "SLAVEOF localhost 6381", redis.slaveof("localhost", 6381)
     end
-
-    # The connection should remain intact
-    assert connections == redis.connections
   end
-end
-
-test "SLAVEOF" do
-  redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
 
-    assert "SLAVEOF localhost 6381" == redis.slaveof("localhost", 6381)
+  def test_bgrewriteaof
+    redis_mock(:bgrewriteaof => lambda { "+BGREWRITEAOF" }) do |redis|
+      assert_equal "BGREWRITEAOF", redis.bgrewriteaof
+    end
   end
-end
 
-test "BGREWRITEAOF" do
-  redis_mock(:bgrewriteaof => lambda { "+BGREWRITEAOF" }) do
-    redis = Redis.new(OPTIONS.merge(:port => 6380))
+  def test_config_get
+    assert r.config(:get, "*")["timeout"] != nil
 
-    assert "BGREWRITEAOF" == redis.bgrewriteaof
+    config = r.config(:get, "timeout")
+    assert_equal ["timeout"], config.keys
+    assert config.values.compact.size > 0
   end
-end
-
-test "CONFIG GET" do |r|
-  assert r.config(:get, "*")["timeout"] != nil
 
-  config = r.config(:get, "timeout")
-  assert ["timeout"] == config.keys
-  assert config.values.compact.size > 0
-end
+  def test_config_set
+    begin
+      assert_equal "OK", r.config(:set, "timeout", 200)
+      assert_equal "200", r.config(:get, "*")["timeout"]
 
-test "CONFIG SET" do |r|
-  begin
-    assert "OK" == r.config(:set, "timeout", 200)
-    assert "200" == r.config(:get, "*")["timeout"]
-
-    assert "OK" == r.config(:set, "timeout", 100)
-    assert "100" == r.config(:get, "*")["timeout"]
-  ensure
-    r.config :set, "timeout", 300
+      assert_equal "OK", r.config(:set, "timeout", 100)
+      assert_equal "100", r.config(:get, "*")["timeout"]
+    ensure
+      r.config :set, "timeout", 300
+    end
   end
 end