redis 3.3.5 → 4.0.0.rc1

data/test/client_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestClient < Test::Unit::TestCase
 

data/test/command_map_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestCommandMap < Test::Unit::TestCase
 
@@ -11,7 +9,7 @@ class TestCommandMap < Test::Unit::TestCase
 
     assert_equal 2, r.incr("counter")
 
-    r.client.command_map[:incr] = :decr
+    r._client.command_map[:incr] = :decr
 
     assert_equal 1, r.incr("counter")
   end
@@ -23,7 +21,7 @@ class TestCommandMap < Test::Unit::TestCase
       r.idontexist("key")
     end
 
-    r.client.command_map[:idontexist] = :get
+    r._client.command_map[:idontexist] = :get
 
     assert_equal "value", r.idontexist("key")
   end

data/test/commands_on_hashes_test.rb

@@ -1,12 +1,165 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/hashes"
+require_relative "helper"
 
 class TestCommandsOnHashes < Test::Unit::TestCase
 
   include Helper::Client
-  include Lint::Hashes
+
+  def test_hset_and_hget
+    r.hset("foo", "f1", "s1")
+
+    assert_equal "s1", r.hget("foo", "f1")
+  end
+
+  def test_hsetnx
+    r.hset("foo", "f1", "s1")
+    r.hsetnx("foo", "f1", "s2")
+
+    assert_equal "s1", r.hget("foo", "f1")
+
+    r.del("foo")
+    r.hsetnx("foo", "f1", "s2")
+
+    assert_equal "s2", r.hget("foo", "f1")
+  end
+
+  def test_hdel
+    r.hset("foo", "f1", "s1")
+
+    assert_equal "s1", r.hget("foo", "f1")
+
+    assert_equal 1, r.hdel("foo", "f1")
+
+    assert_equal nil, r.hget("foo", "f1")
+  end
+
+  def test_variadic_hdel
+    target_version "2.3.9" do
+      r.hset("foo", "f1", "s1")
+      r.hset("foo", "f2", "s2")
+
+      assert_equal "s1", r.hget("foo", "f1")
+      assert_equal "s2", r.hget("foo", "f2")
+
+      assert_equal 2, r.hdel("foo", ["f1", "f2"])
+
+      assert_equal nil, r.hget("foo", "f1")
+      assert_equal nil, r.hget("foo", "f2")
+    end
+  end
+
+  def test_hexists
+    assert_equal false, r.hexists("foo", "f1")
+
+    r.hset("foo", "f1", "s1")
+
+    assert r.hexists("foo", "f1")
+  end
+
+  def test_hlen
+    assert_equal 0, r.hlen("foo")
+
+    r.hset("foo", "f1", "s1")
+
+    assert_equal 1, r.hlen("foo")
+
+    r.hset("foo", "f2", "s2")
+
+    assert_equal 2, r.hlen("foo")
+  end
+
+  def test_hkeys
+    assert_equal [], r.hkeys("foo")
+
+    r.hset("foo", "f1", "s1")
+    r.hset("foo", "f2", "s2")
+
+    assert_equal ["f1", "f2"], r.hkeys("foo")
+  end
+
+  def test_hvals
+    assert_equal [], r.hvals("foo")
+
+    r.hset("foo", "f1", "s1")
+    r.hset("foo", "f2", "s2")
+
+    assert_equal ["s1", "s2"], r.hvals("foo")
+  end
+
+  def test_hgetall
+    assert({} == r.hgetall("foo"))
+
+    r.hset("foo", "f1", "s1")
+    r.hset("foo", "f2", "s2")
+
+    assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo"))
+  end
+
+  def test_hmset
+    r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
+
+    assert_equal "bar1", r.hget("hash", "foo1")
+    assert_equal "bar2", r.hget("hash", "foo2")
+  end
+
+  def test_hmset_with_invalid_arguments
+    assert_raise(Redis::CommandError) do
+      r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
+    end
+  end
+
+  def test_mapped_hmset
+    r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2")
+
+    assert_equal "s1", r.hget("foo", "f1")
+    assert_equal "s2", r.hget("foo", "f2")
+  end
+
+  def test_hmget
+    r.hset("foo", "f1", "s1")
+    r.hset("foo", "f2", "s2")
+    r.hset("foo", "f3", "s3")
+
+    assert_equal ["s2", "s3"], r.hmget("foo", "f2", "f3")
+  end
+
+  def test_hmget_mapped
+    r.hset("foo", "f1", "s1")
+    r.hset("foo", "f2", "s2")
+    r.hset("foo", "f3", "s3")
+
+    assert({"f1" => "s1"} == r.mapped_hmget("foo", "f1"))
+    assert({"f1" => "s1", "f2" => "s2"} == r.mapped_hmget("foo", "f1", "f2"))
+  end
+
+  def test_hincrby
+    r.hincrby("foo", "f1", 1)
+
+    assert_equal "1", r.hget("foo", "f1")
+
+    r.hincrby("foo", "f1", 2)
+
+    assert_equal "3", r.hget("foo", "f1")
+
+    r.hincrby("foo", "f1", -1)
+
+    assert_equal "2", r.hget("foo", "f1")
+  end
+
+  def test_hincrbyfloat
+    target_version "2.5.4" do
+      r.hincrbyfloat("foo", "f1", 1.23)
+
+      assert_equal "1.23", r.hget("foo", "f1")
+
+      r.hincrbyfloat("foo", "f1", 0.77)
+
+      assert_equal "2", r.hget("foo", "f1")
+
+      r.hincrbyfloat("foo", "f1", -0.1)
+
+      assert_equal "1.9", r.hget("foo", "f1")
+    end
+  end
 
   def test_mapped_hmget_in_a_pipeline_returns_hash
     r.hset("foo", "f1", "s1")

data/test/commands_on_hyper_log_log_test.rb

@@ -1,12 +1,61 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/hyper_log_log"
+require_relative "helper"
 
 class TestCommandsOnHyperLogLog < Test::Unit::TestCase
 
   include Helper::Client
-  include Lint::HyperLogLog
+
+  def test_pfadd
+    target_version "2.8.9" do
+      assert_equal true, r.pfadd("foo", "s1")
+      assert_equal true, r.pfadd("foo", "s2")
+      assert_equal false, r.pfadd("foo", "s1")
+
+      assert_equal 2, r.pfcount("foo")
+    end
+  end
+
+  def test_variadic_pfadd
+    target_version "2.8.9" do
+      assert_equal true, r.pfadd("foo", ["s1", "s2"])
+      assert_equal true, r.pfadd("foo", ["s1", "s2", "s3"])
+
+      assert_equal 3, r.pfcount("foo")
+    end
+  end
+
+  def test_pfcount
+    target_version "2.8.9" do
+      assert_equal 0, r.pfcount("foo")
+
+      assert_equal true, r.pfadd("foo", "s1")
+
+      assert_equal 1, r.pfcount("foo")
+    end
+  end
+
+  def test_variadic_pfcount
+    target_version "2.8.9" do
+      assert_equal 0, r.pfcount(["{1}foo", "{1}bar"])
+
+      assert_equal true, r.pfadd("{1}foo", "s1")
+      assert_equal true, r.pfadd("{1}bar", "s1")
+      assert_equal true, r.pfadd("{1}bar", "s2")
+
+      assert_equal 2, r.pfcount("{1}foo", "{1}bar")
+    end
+  end
+
+  def test_variadic_pfcount_expanded
+    target_version "2.8.9" do
+      assert_equal 0, r.pfcount("{1}foo", "{1}bar")
+
+      assert_equal true, r.pfadd("{1}foo", "s1")
+      assert_equal true, r.pfadd("{1}bar", "s1")
+      assert_equal true, r.pfadd("{1}bar", "s2")
+
+      assert_equal 2, r.pfcount("{1}foo", "{1}bar")
+    end
+  end
 
   def test_pfmerge
     target_version "2.8.9" do
@@ -18,4 +67,4 @@ class TestCommandsOnHyperLogLog < Test::Unit::TestCase
     end
   end
 
-end
+end

data/test/commands_on_lists_test.rb

@@ -1,12 +1,146 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/lists"
+require_relative "helper"
 
 class TestCommandsOnLists < Test::Unit::TestCase
 
   include Helper::Client
-  include Lint::Lists
+
+  def test_lpush
+    r.lpush "foo", "s1"
+    r.lpush "foo", "s2"
+
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.lpop("foo")
+  end
+
+  def test_variadic_lpush
+    target_version "2.3.9" do # 2.4-rc6
+      assert_equal 3, r.lpush("foo", ["s1", "s2", "s3"])
+      assert_equal 3, r.llen("foo")
+      assert_equal "s3", r.lpop("foo")
+    end
+  end
+
+  def test_lpushx
+    r.lpushx "foo", "s1"
+    r.lpush "foo", "s2"
+    r.lpushx "foo", "s3"
+
+    assert_equal 2, r.llen("foo")
+    assert_equal ["s3", "s2"], r.lrange("foo", 0, -1)
+  end
+
+  def test_rpush
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.rpop("foo")
+  end
+
+  def test_variadic_rpush
+    target_version "2.3.9" do # 2.4-rc6
+      assert_equal 3, r.rpush("foo", ["s1", "s2", "s3"])
+      assert_equal 3, r.llen("foo")
+      assert_equal "s3", r.rpop("foo")
+    end
+  end
+
+  def test_rpushx
+    r.rpushx "foo", "s1"
+    r.rpush "foo", "s2"
+    r.rpushx "foo", "s3"
+
+    assert_equal 2, r.llen("foo")
+    assert_equal ["s2", "s3"], r.lrange("foo", 0, -1)
+  end
+
+  def test_llen
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+
+    assert_equal 2, r.llen("foo")
+  end
+
+  def test_lrange
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+    r.rpush "foo", "s3"
+
+    assert_equal ["s2", "s3"], r.lrange("foo", 1, -1)
+    assert_equal ["s1", "s2"], r.lrange("foo", 0, 1)
+
+    assert_equal [], r.lrange("bar", 0, -1)
+  end
+
+  def test_ltrim
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+    r.rpush "foo", "s3"
+
+    r.ltrim "foo", 0, 1
+
+    assert_equal 2, r.llen("foo")
+    assert_equal ["s1", "s2"], r.lrange("foo", 0, -1)
+  end
+
+  def test_lindex
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+
+    assert_equal "s1", r.lindex("foo", 0)
+    assert_equal "s2", r.lindex("foo", 1)
+  end
+
+  def test_lset
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+
+    assert_equal "s2", r.lindex("foo", 1)
+    assert r.lset("foo", 1, "s3")
+    assert_equal "s3", r.lindex("foo", 1)
+
+    assert_raise Redis::CommandError do
+      r.lset("foo", 4, "s3")
+    end
+  end
+
+  def test_lrem
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+
+    assert_equal 1, r.lrem("foo", 1, "s1")
+    assert_equal ["s2"], r.lrange("foo", 0, -1)
+  end
+
+  def test_lpop
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+
+    assert_equal 2, r.llen("foo")
+    assert_equal "s1", r.lpop("foo")
+    assert_equal 1, r.llen("foo")
+  end
+
+  def test_rpop
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s2"
+
+    assert_equal 2, r.llen("foo")
+    assert_equal "s2", r.rpop("foo")
+    assert_equal 1, r.llen("foo")
+  end
+
+  def test_linsert
+    r.rpush "foo", "s1"
+    r.rpush "foo", "s3"
+    r.linsert "foo", :before, "s3", "s2"
+
+    assert_equal ["s1", "s2", "s3"], r.lrange("foo", 0, -1)
+
+    assert_raise(Redis::CommandError) do
+      r.linsert "foo", :anywhere, "s3", "s2"
+    end
+  end
 
   def test_rpoplpush
     r.rpush "foo", "s1"

data/test/commands_on_sets_test.rb

@@ -1,12 +1,143 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/sets"
+require_relative "helper"
 
 class TestCommandsOnSets < Test::Unit::TestCase
 
   include Helper::Client
-  include Lint::Sets
+
+  def test_sadd
+    assert_equal true, r.sadd("foo", "s1")
+    assert_equal true, r.sadd("foo", "s2")
+    assert_equal false, r.sadd("foo", "s1")
+
+    assert_equal ["s1", "s2"], r.smembers("foo").sort
+  end
+
+  def test_variadic_sadd
+    target_version "2.3.9" do # 2.4-rc6
+      assert_equal 2, r.sadd("foo", ["s1", "s2"])
+      assert_equal 1, r.sadd("foo", ["s1", "s2", "s3"])
+
+      assert_equal ["s1", "s2", "s3"], r.smembers("foo").sort
+    end
+  end
+
+  def test_srem
+    r.sadd("foo", "s1")
+    r.sadd("foo", "s2")
+
+    assert_equal true, r.srem("foo", "s1")
+    assert_equal false, r.srem("foo", "s3")
+
+    assert_equal ["s2"], r.smembers("foo")
+  end
+
+  def test_variadic_srem
+    target_version "2.3.9" do # 2.4-rc6
+      r.sadd("foo", "s1")
+      r.sadd("foo", "s2")
+      r.sadd("foo", "s3")
+
+      assert_equal 1, r.srem("foo", ["s1", "aaa"])
+      assert_equal 0, r.srem("foo", ["bbb", "ccc" "ddd"])
+      assert_equal 1, r.srem("foo", ["eee", "s3"])
+
+      assert_equal ["s2"], r.smembers("foo")
+    end
+  end
+
+  def test_spop
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+
+    assert ["s1", "s2"].include?(r.spop("foo"))
+    assert ["s1", "s2"].include?(r.spop("foo"))
+    assert_equal nil, r.spop("foo")
+  end
+
+  def test_spop_with_positive_count
+    target_version "3.2.0" do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "foo", "s3"
+      r.sadd "foo", "s4"
+
+      pops = r.spop("foo", 3)
+
+      assert !(["s1", "s2", "s3", "s4"] & pops).empty?
+      assert_equal 3, pops.size
+      assert_equal 1, r.scard("foo")
+    end
+  end
+
+  def test_scard
+    assert_equal 0, r.scard("foo")
+
+    r.sadd "foo", "s1"
+
+    assert_equal 1, r.scard("foo")
+
+    r.sadd "foo", "s2"
+
+    assert_equal 2, r.scard("foo")
+  end
+
+  def test_sismember
+    assert_equal false, r.sismember("foo", "s1")
+
+    r.sadd "foo", "s1"
+
+    assert_equal true,  r.sismember("foo", "s1")
+    assert_equal false, r.sismember("foo", "s2")
+  end
+
+  def test_smembers
+    assert_equal [], r.smembers("foo")
+
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+
+    assert_equal ["s1", "s2"], r.smembers("foo").sort
+  end
+
+  def test_srandmember
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+
+    4.times do
+      assert ["s1", "s2"].include?(r.srandmember("foo"))
+    end
+
+    assert_equal 2, r.scard("foo")
+  end
+
+  def test_srandmember_with_positive_count
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "foo", "s3"
+    r.sadd "foo", "s4"
+
+    4.times do
+      assert !(["s1", "s2", "s3", "s4"] & r.srandmember("foo", 3)).empty?
+
+      assert_equal 3, r.srandmember("foo", 3).size
+    end
+
+    assert_equal 4, r.scard("foo")
+  end
+
+  def test_srandmember_with_negative_count
+    r.sadd "foo", "s1"
+    r.sadd "foo", "s2"
+    r.sadd "foo", "s3"
+    r.sadd "foo", "s4"
+
+    4.times do
+      assert !(["s1", "s2", "s3", "s4"] & r.srandmember("foo", -6)).empty?
+      assert_equal 6, r.srandmember("foo", -6).size
+    end
+
+    assert_equal 4, r.scard("foo")
+  end
 
   def test_smove
     r.sadd "foo", "s1"