redis 3.0.0.rc1 → 3.0.0.rc2

data/test/lint/strings.rb

@@ -1,133 +1,151 @@
-require File.expand_path("../redis_mock", File.dirname(__FILE__))
+module Lint
 
-include RedisMock::Helper
+  module Strings
 
-test "SET and GET" do |r|
-  r.set("foo", "s1")
+    def test_set_and_get
+      r.set("foo", "s1")
 
-  assert "s1" == r.get("foo")
-end
+      assert_equal "s1", r.get("foo")
+    end
 
-test "SET and GET with brackets" do |r|
-  r["foo"] = "s1"
+    def test_set_and_get_with_brackets
+      r["foo"] = "s1"
 
-  assert "s1" == r["foo"]
-end
+      assert_equal "s1", r["foo"]
+    end
 
-test "SET and GET with brackets and symbol" do |r|
-  r[:foo] = "s1"
+    def test_set_and_get_with_brackets_and_symbol
+      r[:foo] = "s1"
 
-  assert "s1" == r[:foo]
-end
+      assert_equal "s1", r[:foo]
+    end
 
-test "SET and GET with newline characters" do |r|
-  r.set("foo", "1\n")
+    def test_set_and_get_with_newline_characters
+      r.set("foo", "1\n")
 
-  assert "1\n" == r.get("foo")
-end
+      assert_equal "1\n", r.get("foo")
+    end
 
-test "SET and GET with ASCII characters" do |r|
-  with_external_encoding("ASCII-8BIT") do
-    (0..255).each do |i|
-      str = "#{i.chr}---#{i.chr}"
-      r.set("foo", str)
+    def test_set_and_get_with_ascii_characters
+      if defined?(Encoding)
+        with_external_encoding("ASCII-8BIT") do
+          (0..255).each do |i|
+            str = "#{i.chr}---#{i.chr}"
+            r.set("foo", str)
+
+            assert_equal str, r.get("foo")
+          end
+        end
+      end
+    end
 
-      assert str == r.get("foo")
+    def test_setex
+      assert r.setex("foo", 1, "bar")
+      assert_equal "bar", r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
     end
-  end
-end if defined?(Encoding)
 
-test "SETEX" do
-  redis_mock(:setex => lambda { |*args| "+#{args.join(" ")}" }) do
-    r = Redis.new(OPTIONS.merge(:port => 6380))
+    def test_psetex
+      return if version < "2.5.4"
 
-    assert_equal "foo 1 s1", r.setex("foo", 1, "s1")
-  end
-end
+      assert r.psetex("foo", 1000, "bar")
+      assert_equal "bar", r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
 
-test "GETSET" do |r|
-  r.set("foo", "bar")
+    def test_getset
+      r.set("foo", "bar")
 
-  assert "bar" == r.getset("foo", "baz")
-  assert "baz" == r.get("foo")
-end
+      assert_equal "bar", r.getset("foo", "baz")
+      assert_equal "baz", r.get("foo")
+    end
 
-test "SETNX" do |r|
-  r.set("foo", "s1")
+    def test_setnx
+      r.set("foo", "s1")
 
-  assert "s1" == r.get("foo")
+      assert_equal "s1", r.get("foo")
 
-  r.setnx("foo", "s2")
+      r.setnx("foo", "s2")
 
-  assert "s1" == r.get("foo")
-end
+      assert_equal "s1", r.get("foo")
+    end
 
-test "INCR" do |r|
-  assert 1 == r.incr("foo")
-  assert 2 == r.incr("foo")
-  assert 3 == r.incr("foo")
-end
+    def test_incr
+      assert_equal 1, r.incr("foo")
+      assert_equal 2, r.incr("foo")
+      assert_equal 3, r.incr("foo")
+    end
 
-test "INCRBY" do |r|
-  assert 1 == r.incrby("foo", 1)
-  assert 3 == r.incrby("foo", 2)
-  assert 6 == r.incrby("foo", 3)
-end
+    def test_incrby
+      assert_equal 1, r.incrby("foo", 1)
+      assert_equal 3, r.incrby("foo", 2)
+      assert_equal 6, r.incrby("foo", 3)
+    end
 
-test "DECR" do |r|
-  r.set("foo", 3)
+    def test_incrbyfloat
+      return if version < "2.5.4"
 
-  assert 2 == r.decr("foo")
-  assert 1 == r.decr("foo")
-  assert 0 == r.decr("foo")
-end
+      assert_equal 1.23, r.incrbyfloat("foo", 1.23)
+      assert_equal 2   , r.incrbyfloat("foo", 0.77)
+      assert_equal 1.9 , r.incrbyfloat("foo", -0.1)
+    end
 
-test "DECRBY" do |r|
-  r.set("foo", 6)
+    def test_decr
+      r.set("foo", 3)
 
-  assert 3 == r.decrby("foo", 3)
-  assert 1 == r.decrby("foo", 2)
-  assert 0 == r.decrby("foo", 1)
-end
+      assert_equal 2, r.decr("foo")
+      assert_equal 1, r.decr("foo")
+      assert_equal 0, r.decr("foo")
+    end
 
-test "APPEND" do |r|
-  r.set "foo", "s"
-  r.append "foo", "1"
+    def test_decrby
+      r.set("foo", 6)
 
-  assert "s1" == r.get("foo")
-end
+      assert_equal 3, r.decrby("foo", 3)
+      assert_equal 1, r.decrby("foo", 2)
+      assert_equal 0, r.decrby("foo", 1)
+    end
 
-test "GETBIT" do |r|
-  r.set("foo", "a")
+    def test_append
+      r.set "foo", "s"
+      r.append "foo", "1"
 
-  assert_equal 1, r.getbit("foo", 1)
-  assert_equal 1, r.getbit("foo", 2)
-  assert_equal 0, r.getbit("foo", 3)
-  assert_equal 0, r.getbit("foo", 4)
-  assert_equal 0, r.getbit("foo", 5)
-  assert_equal 0, r.getbit("foo", 6)
-  assert_equal 1, r.getbit("foo", 7)
-end
+      assert_equal "s1", r.get("foo")
+    end
 
-test "SETBIT" do |r|
-  r.set("foo", "a")
+    def test_getbit
+      r.set("foo", "a")
 
-  r.setbit("foo", 6, 1)
+      assert_equal 1, r.getbit("foo", 1)
+      assert_equal 1, r.getbit("foo", 2)
+      assert_equal 0, r.getbit("foo", 3)
+      assert_equal 0, r.getbit("foo", 4)
+      assert_equal 0, r.getbit("foo", 5)
+      assert_equal 0, r.getbit("foo", 6)
+      assert_equal 1, r.getbit("foo", 7)
+    end
 
-  assert_equal "c", r.get("foo")
-end
+    def test_setbit
+      r.set("foo", "a")
 
-test "GETRANGE" do |r|
-  r.set("foo", "abcde")
+      r.setbit("foo", 6, 1)
 
-  assert_equal "bcd", r.getrange("foo", 1, 3)
-  assert_equal "abcde", r.getrange("foo", 0, -1)
-end
+      assert_equal "c", r.get("foo")
+    end
 
-test "SETRANGE" do |r|
-  r.set("foo", "abcde")
+    def test_getrange
+      r.set("foo", "abcde")
 
-  r.setrange("foo", 1, "bar")
+      assert_equal "bcd", r.getrange("foo", 1, 3)
+      assert_equal "abcde", r.getrange("foo", 0, -1)
+    end
 
-  assert_equal "abare", r.get("foo")
+    def test_setrange
+      r.set("foo", "abcde")
+
+      r.setrange("foo", 1, "bar")
+
+      assert_equal "abare", r.get("foo")
+    end
+  end
 end

data/test/lint/value_types.rb

@@ -1,81 +1,102 @@
-require File.expand_path("../redis_mock", File.dirname(__FILE__))
+module Lint
 
-include RedisMock::Helper
+  module ValueTypes
 
-test "EXISTS" do |r|
-  assert false == r.exists("foo")
+    def test_exists
+      assert_equal false, r.exists("foo")
 
-  r.set("foo", "s1")
+      r.set("foo", "s1")
 
-  assert true ==  r.exists("foo")
-end
+      assert_equal true,  r.exists("foo")
+    end
 
-test "TYPE" do |r|
-  assert "none" == r.type("foo")
+    def test_type
+      assert_equal "none", r.type("foo")
 
-  r.set("foo", "s1")
+      r.set("foo", "s1")
 
-  assert "string" == r.type("foo")
-end
+      assert_equal "string", r.type("foo")
+    end
 
-test "KEYS" do |r|
-  r.set("f", "s1")
-  r.set("fo", "s2")
-  r.set("foo", "s3")
+    def test_keys
+      r.set("f", "s1")
+      r.set("fo", "s2")
+      r.set("foo", "s3")
 
-  assert ["f","fo", "foo"] == r.keys("f*").sort
-end
+      assert_equal ["f","fo", "foo"], r.keys("f*").sort
+    end
 
-test "EXPIRE" do |r|
-  redis_mock(:expire => lambda { |*args| args == ["foo", "1"] ? ":1" : ":0" }) do
-    r = Redis.new(OPTIONS.merge(:port => 6380))
+    def test_expire
+      r.set("foo", "s1")
+      assert r.expire("foo", 1)
+      assert [0, 1].include? r.ttl("foo")
+    end
 
-    assert r.expire("foo", 1)
-  end
-end
+    def test_pexpire
+      return if version < "2.5.4"
 
-test "EXPIREAT" do |r|
-  redis_mock(:expireat => lambda { |*args| args == ["foo", "1328236326"] ? ":1" : ":0" }) do
-    r = Redis.new(OPTIONS.merge(:port => 6380))
+      r.set("foo", "s1")
+      assert r.pexpire("foo", 1000)
+      assert [0, 1].include? r.ttl("foo")
+    end
 
-    assert r.expireat("foo", 1328236326)
-  end
-end
+    def test_expireat
+      r.set("foo", "s1")
+      assert r.expireat("foo", (Time.now + 1).to_i)
+      assert [0, 1].include? r.ttl("foo")
+    end
 
-test "PERSIST" do |r|
-  r.set("foo", "s1")
-  r.expire("foo", 1)
-  r.persist("foo")
+    def test_pexpireat
+      return if version < "2.5.4"
 
-  assert(-1 == r.ttl("foo"))
-end
+      r.set("foo", "s1")
+      assert r.pexpireat("foo", (Time.now + 1).to_i * 1_000)
+      assert [0, 1].include? r.ttl("foo")
+    end
 
-test "TTL" do |r|
-  r.set("foo", "s1")
-  r.expire("foo", 1)
+    def test_persist
+      r.set("foo", "s1")
+      r.expire("foo", 1)
+      r.persist("foo")
 
-  assert 1 == r.ttl("foo")
-end
+      assert(-1 == r.ttl("foo"))
+    end
+
+    def test_ttl
+      r.set("foo", "s1")
+      r.expire("foo", 1)
+      assert [0, 1].include? r.ttl("foo")
+    end
 
-test "MOVE" do |r|
-  r.select 14
-  r.flushdb
+    def test_pttl
+      return if version < "2.5.4"
 
-  r.set "bar", "s3"
+      r.set("foo", "s1")
+      r.expire("foo", 1)
+      assert 1000 >= r.pttl("foo")
+    end
 
-  r.select 15
+    def test_move
+      r.select 14
+      r.flushdb
 
-  r.set "foo", "s1"
-  r.set "bar", "s2"
+      r.set "bar", "s3"
 
-  assert r.move("foo", 14)
-  assert nil == r.get("foo")
+      r.select 15
 
-  assert !r.move("bar", 14)
-  assert "s2" == r.get("bar")
+      r.set "foo", "s1"
+      r.set "bar", "s2"
 
-  r.select 14
+      assert r.move("foo", 14)
+      assert_equal nil, r.get("foo")
 
-  assert "s1" == r.get("foo")
-  assert "s3" == r.get("bar")
+      assert !r.move("bar", 14)
+      assert_equal "s2", r.get("bar")
+
+      r.select 14
+
+      assert_equal "s1", r.get("foo")
+      assert_equal "s3", r.get("bar")
+    end
+  end
 end

data/test/persistence_control_commands_test.rb

@@ -1,21 +1,26 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestPersistenceControlCommands < Test::Unit::TestCase
+
+  include Helper::Client
 
-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 Time.at(r.lastsave) <= Time.now
+  def test_lastsave
+    redis_mock(:lastsave => lambda { "+LASTSAVE" }) do |redis|
+      assert_equal "LASTSAVE", redis.lastsave
+    end
+  end
 end

data/test/pipelining_commands_test.rb

@@ -1,186 +1,195 @@
 # encoding: UTF-8
 
-require File.expand_path("./helper", File.dirname(__FILE__))
+require "helper"
 
-setup do
-  init Redis.new(OPTIONS)
-end
+class TestPipeliningCommands < Test::Unit::TestCase
 
-test "BULK commands" do |r|
-  r.pipelined do
-    r.lpush "foo", "s1"
-    r.lpush "foo", "s2"
-  end
+  include Helper::Client
 
-  assert 2 == r.llen("foo")
-  assert "s2" == r.lpop("foo")
-  assert "s1" == r.lpop("foo")
-end
+  def test_bulk_commands
+    r.pipelined do
+      r.lpush "foo", "s1"
+      r.lpush "foo", "s2"
+    end
 
-test "MULTI_BULK commands" do |r|
-  r.pipelined do
-    r.mset("foo", "s1", "bar", "s2")
-    r.mset("baz", "s3", "qux", "s4")
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.lpop("foo")
+    assert_equal "s1", r.lpop("foo")
   end
 
-  assert "s1" == r.get("foo")
-  assert "s2" == r.get("bar")
-  assert "s3" == r.get("baz")
-  assert "s4" == r.get("qux")
-end
+  def test_multi_bulk_commands
+    r.pipelined do
+      r.mset("foo", "s1", "bar", "s2")
+      r.mset("baz", "s3", "qux", "s4")
+    end
 
-test "BULK and MULTI_BULK commands mixed" do |r|
-  r.pipelined do
-    r.lpush "foo", "s1"
-    r.lpush "foo", "s2"
-    r.mset("baz", "s3", "qux", "s4")
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+    assert_equal "s3", r.get("baz")
+    assert_equal "s4", r.get("qux")
   end
 
-  assert 2 == r.llen("foo")
-  assert "s2" == r.lpop("foo")
-  assert "s1" == r.lpop("foo")
-  assert "s3" == r.get("baz")
-  assert "s4" == r.get("qux")
-end
+  def test_bulk_and_multi_bulk_commands_mixed
+    r.pipelined do
+      r.lpush "foo", "s1"
+      r.lpush "foo", "s2"
+      r.mset("baz", "s3", "qux", "s4")
+    end
 
-test "MULTI_BULK and BULK commands mixed" do |r|
-  r.pipelined do
-    r.mset("baz", "s3", "qux", "s4")
-    r.lpush "foo", "s1"
-    r.lpush "foo", "s2"
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.lpop("foo")
+    assert_equal "s1", r.lpop("foo")
+    assert_equal "s3", r.get("baz")
+    assert_equal "s4", r.get("qux")
   end
 
-  assert 2 == r.llen("foo")
-  assert "s2" == r.lpop("foo")
-  assert "s1" == r.lpop("foo")
-  assert "s3" == r.get("baz")
-  assert "s4" == r.get("qux")
-end
-
-test "Pipelined with an empty block" do |r|
-  assert_nothing_raised do
+  def test_multi_bulk_and_bulk_commands_mixed
     r.pipelined do
+      r.mset("baz", "s3", "qux", "s4")
+      r.lpush "foo", "s1"
+      r.lpush "foo", "s2"
     end
+
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.lpop("foo")
+    assert_equal "s1", r.lpop("foo")
+    assert_equal "s3", r.get("baz")
+    assert_equal "s4", r.get("qux")
   end
 
-  assert 0 == r.dbsize
-end
+  def test_pipelined_with_an_empty_block
+    assert_nothing_raised do
+      r.pipelined do
+      end
+    end
 
-test "Returning the result of a pipeline" do |r|
-  result = r.pipelined do
-    r.set "foo", "bar"
-    r.get "foo"
-    r.get "bar"
+    assert_equal 0, r.dbsize
   end
 
-  assert ["OK", "bar", nil] == result
-end
+  def test_returning_the_result_of_a_pipeline
+    result = r.pipelined do
+      r.set "foo", "bar"
+      r.get "foo"
+      r.get "bar"
+    end
 
-test "Assignment of results inside the block" do |r|
-  r.pipelined do
-    @first = r.sadd("foo", 1)
-    @second = r.sadd("foo", 1)
+    assert_equal ["OK", "bar", nil], result
   end
 
-  assert_equal true, @first.value
-  assert_equal false, @second.value
-end
-
-# Although we could support accessing the values in these futures,
-# it doesn't make a lot of sense.
-test "Assignment of results inside the block with errors" do |r|
-  assert_raise do
+  def test_assignment_of_results_inside_the_block
     r.pipelined do
-      r.doesnt_exist
       @first = r.sadd("foo", 1)
-      r.doesnt_exist
       @second = r.sadd("foo", 1)
-      r.doesnt_exist
     end
-  end
 
-  assert_raise(Redis::FutureNotReady) { @first.value }
-  assert_raise(Redis::FutureNotReady) { @second.value }
-end
+    assert_equal true, @first.value
+    assert_equal false, @second.value
+  end
+
+  # Although we could support accessing the values in these futures,
+  # it doesn't make a lot of sense.
+  def test_assignment_of_results_inside_the_block_with_errors
+    assert_raise(Redis::CommandError) do
+      r.pipelined do
+        r.doesnt_exist
+        @first = r.sadd("foo", 1)
+        r.doesnt_exist
+        @second = r.sadd("foo", 1)
+        r.doesnt_exist
+      end
+    end
 
-test "Assignment of results inside a nested block" do |r|
-  r.pipelined do
-    @first = r.sadd("foo", 1)
+    assert_raise(Redis::FutureNotReady) { @first.value }
+    assert_raise(Redis::FutureNotReady) { @second.value }
+  end
 
+  def test_assignment_of_results_inside_a_nested_block
     r.pipelined do
-      @second = r.sadd("foo", 1)
+      @first = r.sadd("foo", 1)
+
+      r.pipelined do
+        @second = r.sadd("foo", 1)
+      end
     end
+
+    assert_equal true, @first.value
+    assert_equal false, @second.value
   end
 
-  assert_equal true, @first.value
-  assert_equal false, @second.value
-end
+  def test_futures_raise_when_confused_with_something_else
+    r.pipelined do
+      @result = r.sadd("foo", 1)
+    end
 
-test "Futures raise when confused with something else" do |r|
-  r.pipelined do
-    @result = r.sadd("foo", 1)
+    assert_raise(NoMethodError) { @result.to_s }
   end
 
-  assert_raise(NoMethodError) { @result.to_s }
-end
-
-test "Futures raise when trying to access their values too early" do |r|
-  r.pipelined do
-    assert_raise(Redis::FutureNotReady) do
-      r.sadd("foo", 1).value
+  def test_futures_raise_when_trying_to_access_their_values_too_early
+    r.pipelined do
+      assert_raise(Redis::FutureNotReady) do
+        r.sadd("foo", 1).value
+      end
     end
   end
-end
 
-test "Returning the result of an empty pipeline" do |r|
-  result = r.pipelined do
-  end
+  def test_returning_the_result_of_an_empty_pipeline
+    result = r.pipelined do
+    end
 
-  assert [] == result
-end
+    assert_equal [], result
+  end
 
-test "Nesting pipeline blocks" do |r|
-  r.pipelined do
-    r.set("foo", "s1")
+  def test_nesting_pipeline_blocks
     r.pipelined do
-      r.set("bar", "s2")
+      r.set("foo", "s1")
+      r.pipelined do
+        r.set("bar", "s2")
+      end
     end
+
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
   end
 
-  assert "s1" == r.get("foo")
-  assert "s2" == r.get("bar")
-end
+  def test_info_in_a_pipeline_returns_hash
+    result = r.pipelined do
+      r.info
+    end
 
-test "INFO in a pipeline returns hash" do |r|
-  result = r.pipelined do
-    r.info
+    assert result.first.kind_of?(Hash)
   end
 
-  assert result.first.kind_of?(Hash)
-end
+  def test_config_get_in_a_pipeline_returns_hash
+    result = r.pipelined do
+      r.config(:get, "*")
+    end
 
-test "CONFIG GET in a pipeline returns hash" do |r|
-  result = r.pipelined do
-    r.config(:get, "*")
+    assert result.first.kind_of?(Hash)
   end
 
-  assert result.first.kind_of?(Hash)
-end
+  def test_hgetall_in_a_pipeline_returns_hash
+    r.hmset("hash", "field", "value")
+    result = r.pipelined do
+      r.hgetall("hash")
+    end
 
-test "HGETALL in a pipeline returns hash" do |r|
-  r.hmset("hash", "field", "value")
-  result = r.pipelined do
-    r.hgetall("hash")
+    assert_equal result.first, { "field" => "value" }
   end
 
-  assert result.first == { "field" => "value" }
-end
+  def test_keys_in_a_pipeline
+    r.set("key", "value")
+    result = r.pipelined do
+      r.keys("*")
+    end
 
-test "KEYS in a pipeline" do |r|
-  r.set("key", "value")
-  result = r.pipelined do
-    r.keys("*")
+    assert_equal ["key"], result.first
   end
 
-  assert ["key"] == result.first
+  def test_pipeline_yields_a_connection
+    r.pipelined do |p|
+      p.set("foo", "bar")
+    end
+
+    assert_equal "bar", r.get("foo")
+  end
 end