finsync_redis 3.3.5

data/test/lint/hashes.rb

@@ -0,0 +1,162 @@
+module Lint
+
+  module 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
+  end
+end

data/test/lint/hyper_log_log.rb

@@ -0,0 +1,60 @@
+module Lint
+
+  module 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
+
+  end
+
+end

data/test/lint/lists.rb

@@ -0,0 +1,143 @@
+module Lint
+
+  module 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
+  end
+end

data/test/lint/sets.rb

@@ -0,0 +1,140 @@
+module Lint
+
+  module 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
+  end
+end