redis2-namespaced 3.0.7

data/test/lint/sorted_sets.rb

@@ -0,0 +1,238 @@
+module Lint
+
+  module SortedSets
+
+    Infinity = 1.0/0.0
+
+    def test_zadd
+      assert_equal 0, r.zcard("foo")
+      assert_equal true, r.zadd("foo", 1, "s1")
+      assert_equal false, r.zadd("foo", 1, "s1")
+      assert_equal 1, r.zcard("foo")
+    end
+
+    def test_variadic_zadd
+      target_version "2.3.9" do # 2.4-rc6
+        # Non-nested array with pairs
+        assert_equal 0, r.zcard("foo")
+        assert_equal 2, r.zadd("foo", [1, "s1", 2, "s2"])
+        assert_equal 1, r.zadd("foo", [4, "s1", 5, "s2", 6, "s3"])
+        assert_equal 3, r.zcard("foo")
+        r.del "foo"
+
+        # Nested array with pairs
+        assert_equal 0, r.zcard("foo")
+        assert_equal 2, r.zadd("foo", [[1, "s1"], [2, "s2"]])
+        assert_equal 1, r.zadd("foo", [[4, "s1"], [5, "s2"], [6, "s3"]])
+        assert_equal 3, r.zcard("foo")
+        r.del "foo"
+
+        # Wrong number of arguments
+        assert_raise(Redis2::CommandError) { r.zadd("foo", ["bar"]) }
+        assert_raise(Redis2::CommandError) { r.zadd("foo", ["bar", "qux", "zap"]) }
+      end
+    end
+
+    def test_zrem
+      r.zadd("foo", 1, "s1")
+      r.zadd("foo", 2, "s2")
+
+      assert_equal 2, r.zcard("foo")
+      assert_equal true, r.zrem("foo", "s1")
+      assert_equal false, r.zrem("foo", "s1")
+      assert_equal 1, r.zcard("foo")
+    end
+
+    def test_variadic_zrem
+      target_version "2.3.9" do # 2.4-rc6
+        r.zadd("foo", 1, "s1")
+        r.zadd("foo", 2, "s2")
+        r.zadd("foo", 3, "s3")
+
+        assert_equal 3, r.zcard("foo")
+        assert_equal 1, r.zrem("foo", ["s1", "aaa"])
+        assert_equal 0, r.zrem("foo", ["bbb", "ccc" "ddd"])
+        assert_equal 1, r.zrem("foo", ["eee", "s3"])
+        assert_equal 1, r.zcard("foo")
+      end
+    end
+
+    def test_zincrby
+      rv = r.zincrby "foo", 1, "s1"
+      assert_equal 1.0, rv
+
+      rv = r.zincrby "foo", 10, "s1"
+      assert_equal 11.0, rv
+
+      rv = r.zincrby "bar", "-inf", "s1"
+      assert_equal(-Infinity, rv)
+
+      rv = r.zincrby "bar", "+inf", "s2"
+      assert_equal(+Infinity, rv)
+    end
+
+    def test_zrank
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal 2, r.zrank("foo", "s3")
+    end
+
+    def test_zrevrank
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal 0, r.zrevrank("foo", "s3")
+    end
+
+    def test_zrange
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal ["s1", "s2"], r.zrange("foo", 0, 1)
+      assert_equal [["s1", 1.0], ["s2", 2.0]], r.zrange("foo", 0, 1, :with_scores => true)
+      assert_equal [["s1", 1.0], ["s2", 2.0]], r.zrange("foo", 0, 1, :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s1", -Infinity], ["s2", +Infinity]], r.zrange("bar", 0, 1, :with_scores => true)
+      assert_equal [["s1", -Infinity], ["s2", +Infinity]], r.zrange("bar", 0, 1, :withscores => true)
+    end
+
+    def test_zrevrange
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal ["s3", "s2"], r.zrevrange("foo", 0, 1)
+      assert_equal [["s3", 3.0], ["s2", 2.0]], r.zrevrange("foo", 0, 1, :with_scores => true)
+      assert_equal [["s3", 3.0], ["s2", 2.0]], r.zrevrange("foo", 0, 1, :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s2", +Infinity], ["s1", -Infinity]], r.zrevrange("bar", 0, 1, :with_scores => true)
+      assert_equal [["s2", +Infinity], ["s1", -Infinity]], r.zrevrange("bar", 0, 1, :withscores => true)
+    end
+
+    def test_zrangebyscore
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal ["s2", "s3"], r.zrangebyscore("foo", 2, 3)
+    end
+
+    def test_zrevrangebyscore
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+
+      assert_equal ["s3", "s2"], r.zrevrangebyscore("foo", 3, 2)
+    end
+
+    def test_zrangebyscore_with_limit
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal ["s2"], r.zrangebyscore("foo", 2, 4, :limit => [0, 1])
+      assert_equal ["s3"], r.zrangebyscore("foo", 2, 4, :limit => [1, 1])
+      assert_equal ["s3", "s4"], r.zrangebyscore("foo", 2, 4, :limit => [1, 2])
+    end
+
+    def test_zrevrangebyscore_with_limit
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal ["s4"], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1])
+      assert_equal ["s3"], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1])
+      assert_equal ["s3", "s2"], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 2])
+    end
+
+    def test_zrangebyscore_with_withscores
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal [["s2", 2.0]], r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s3", 3.0]], r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s2", 2.0]], r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :withscores => true)
+      assert_equal [["s3", 3.0]], r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s1", -Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s2", +Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s1", -Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [0, 1], :withscores => true)
+      assert_equal [["s2", +Infinity]], r.zrangebyscore("bar", -Infinity, +Infinity, :limit => [1, 1], :withscores => true)
+    end
+
+    def test_zrevrangebyscore_with_withscores
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal [["s4", 4.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s3", 3.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s4", 4.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :withscores => true)
+      assert_equal [["s3", 3.0]], r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :withscores => true)
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal [["s2", +Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [0, 1], :with_scores => true)
+      assert_equal [["s1", -Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [1, 1], :with_scores => true)
+      assert_equal [["s2", +Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [0, 1], :withscores => true)
+      assert_equal [["s1", -Infinity]], r.zrevrangebyscore("bar", +Infinity, -Infinity, :limit => [1, 1], :withscores => true)
+    end
+
+    def test_zcard
+      assert_equal 0, r.zcard("foo")
+
+      r.zadd "foo", 1, "s1"
+
+      assert_equal 1, r.zcard("foo")
+    end
+
+    def test_zscore
+      r.zadd "foo", 1, "s1"
+
+      assert_equal 1.0, r.zscore("foo", "s1")
+
+      assert_equal nil, r.zscore("foo", "s2")
+      assert_equal nil, r.zscore("bar", "s1")
+
+      r.zadd "bar", "-inf", "s1"
+      r.zadd "bar", "+inf", "s2"
+      assert_equal(-Infinity, r.zscore("bar", "s1"))
+      assert_equal(+Infinity, r.zscore("bar", "s2"))
+    end
+
+    def test_zremrangebyrank
+      r.zadd "foo", 10, "s1"
+      r.zadd "foo", 20, "s2"
+      r.zadd "foo", 30, "s3"
+      r.zadd "foo", 40, "s4"
+
+      assert_equal 3, r.zremrangebyrank("foo", 1, 3)
+      assert_equal ["s1"], r.zrange("foo", 0, -1)
+    end
+
+    def test_zremrangebyscore
+      r.zadd "foo", 1, "s1"
+      r.zadd "foo", 2, "s2"
+      r.zadd "foo", 3, "s3"
+      r.zadd "foo", 4, "s4"
+
+      assert_equal 3, r.zremrangebyscore("foo", 2, 4)
+      assert_equal ["s1"], r.zrange("foo", 0, -1)
+    end
+  end
+end

data/test/lint/strings.rb

@@ -0,0 +1,260 @@
+module Lint
+
+  module Strings
+
+    def test_set_and_get
+      r.set("foo", "s1")
+
+      assert_equal "s1", r.get("foo")
+    end
+
+    def test_set_and_get_with_brackets
+      r["foo"] = "s1"
+
+      assert_equal "s1", r["foo"]
+    end
+
+    def test_set_and_get_with_brackets_and_symbol
+      r[:foo] = "s1"
+
+      assert_equal "s1", r[:foo]
+    end
+
+    def test_set_and_get_with_newline_characters
+      r.set("foo", "1\n")
+
+      assert_equal "1\n", r.get("foo")
+    end
+
+    def test_set_and_get_with_non_string_value
+      value = ["a", "b"]
+
+      r.set("foo", value)
+
+      assert_equal value.to_s, r.get("foo")
+    end
+
+    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
+
+    def test_set_with_ex
+      target_version "2.6.12" do
+        r.set("foo", "bar", :ex => 2)
+        assert_in_range 0..2, r.ttl("foo")
+      end
+    end
+
+    def test_set_with_px
+      target_version "2.6.12" do
+        r.set("foo", "bar", :px => 2000)
+        assert_in_range 0..2, r.ttl("foo")
+      end
+    end
+
+    def test_set_with_nx
+      target_version "2.6.12" do
+        r.set("foo", "qux", :nx => true)
+        assert !r.set("foo", "bar", :nx => true)
+        assert_equal "qux", r.get("foo")
+
+        r.del("foo")
+        assert r.set("foo", "bar", :nx => true)
+        assert_equal "bar", r.get("foo")
+      end
+    end
+
+    def test_set_with_xx
+      target_version "2.6.12" do
+        r.set("foo", "qux")
+        assert r.set("foo", "bar", :xx => true)
+        assert_equal "bar", r.get("foo")
+
+        r.del("foo")
+        assert !r.set("foo", "bar", :xx => true)
+      end
+    end
+
+    def test_setex
+      assert r.setex("foo", 1, "bar")
+      assert_equal "bar", r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
+
+    def test_setex_with_non_string_value
+      value = ["b", "a", "r"]
+
+      assert r.setex("foo", 1, value)
+      assert_equal value.to_s, r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+    end
+
+    def test_psetex
+      target_version "2.5.4" do
+        assert r.psetex("foo", 1000, "bar")
+        assert_equal "bar", r.get("foo")
+        assert [0, 1].include? r.ttl("foo")
+      end
+    end
+
+    def test_psetex_with_non_string_value
+      target_version "2.5.4" do
+        value = ["b", "a", "r"]
+
+        assert r.psetex("foo", 1000, value)
+        assert_equal value.to_s, r.get("foo")
+        assert [0, 1].include? r.ttl("foo")
+      end
+    end
+
+    def test_getset
+      r.set("foo", "bar")
+
+      assert_equal "bar", r.getset("foo", "baz")
+      assert_equal "baz", r.get("foo")
+    end
+
+    def test_getset_with_non_string_value
+      r.set("foo", "zap")
+
+      value = ["b", "a", "r"]
+
+      assert_equal "zap", r.getset("foo", value)
+      assert_equal value.to_s, r.get("foo")
+    end
+
+    def test_setnx
+      r.set("foo", "qux")
+      assert !r.setnx("foo", "bar")
+      assert_equal "qux", r.get("foo")
+
+      r.del("foo")
+      assert r.setnx("foo", "bar")
+      assert_equal "bar", r.get("foo")
+    end
+
+    def test_setnx_with_non_string_value
+      value = ["b", "a", "r"]
+
+      r.set("foo", "qux")
+      assert !r.setnx("foo", value)
+      assert_equal "qux", r.get("foo")
+
+      r.del("foo")
+      assert r.setnx("foo", value)
+      assert_equal value.to_s, r.get("foo")
+    end
+
+    def test_incr
+      assert_equal 1, r.incr("foo")
+      assert_equal 2, r.incr("foo")
+      assert_equal 3, r.incr("foo")
+    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
+
+    def test_incrbyfloat
+      target_version "2.5.4" do
+        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
+    end
+
+    def test_decr
+      r.set("foo", 3)
+
+      assert_equal 2, r.decr("foo")
+      assert_equal 1, r.decr("foo")
+      assert_equal 0, r.decr("foo")
+    end
+
+    def test_decrby
+      r.set("foo", 6)
+
+      assert_equal 3, r.decrby("foo", 3)
+      assert_equal 1, r.decrby("foo", 2)
+      assert_equal 0, r.decrby("foo", 1)
+    end
+
+    def test_append
+      r.set "foo", "s"
+      r.append "foo", "1"
+
+      assert_equal "s1", r.get("foo")
+    end
+
+    def test_getbit
+      r.set("foo", "a")
+
+      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
+
+    def test_setbit
+      r.set("foo", "a")
+
+      r.setbit("foo", 6, 1)
+
+      assert_equal "c", r.get("foo")
+    end
+
+    def test_bitcount
+      target_version "2.5.10" do
+        r.set("foo", "abcde")
+
+        assert_equal 10, r.bitcount("foo", 1, 3)
+        assert_equal 17, r.bitcount("foo", 0, -1)
+      end
+    end
+
+    def test_getrange
+      r.set("foo", "abcde")
+
+      assert_equal "bcd", r.getrange("foo", 1, 3)
+      assert_equal "abcde", r.getrange("foo", 0, -1)
+    end
+
+    def test_setrange
+      r.set("foo", "abcde")
+
+      r.setrange("foo", 1, "bar")
+
+      assert_equal "abare", r.get("foo")
+    end
+
+    def test_setrange_with_non_string_value
+      r.set("foo", "abcde")
+
+      value = ["b", "a", "r"]
+
+      r.setrange("foo", 2, value)
+
+      assert_equal "ab#{value.to_s}", r.get("foo")
+    end
+
+    def test_strlen
+      r.set "foo", "lorem"
+
+      assert_equal 5, r.strlen("foo")
+    end
+  end
+end

data/test/lint/value_types.rb

@@ -0,0 +1,122 @@
+module Lint
+
+  module ValueTypes
+
+    def test_exists
+      assert_equal false, r.exists("foo")
+
+      r.set("foo", "s1")
+
+      assert_equal true,  r.exists("foo")
+    end
+
+    def test_type
+      assert_equal "none", r.type("foo")
+
+      r.set("foo", "s1")
+
+      assert_equal "string", r.type("foo")
+    end
+
+    def test_keys
+      r.set("f", "s1")
+      r.set("fo", "s2")
+      r.set("foo", "s3")
+
+      assert_equal ["f","fo", "foo"], r.keys("f*").sort
+    end
+
+    def test_expire
+      r.set("foo", "s1")
+      assert r.expire("foo", 2)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+
+    def test_pexpire
+      target_version "2.5.4" do
+        r.set("foo", "s1")
+        assert r.pexpire("foo", 2000)
+        assert_in_range 0..2, r.ttl("foo")
+      end
+    end
+
+    def test_expireat
+      r.set("foo", "s1")
+      assert r.expireat("foo", (Time.now + 2).to_i)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+
+    def test_pexpireat
+      target_version "2.5.4" do
+        r.set("foo", "s1")
+        assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000)
+        assert_in_range 0..2, r.ttl("foo")
+      end
+    end
+
+    def test_persist
+      r.set("foo", "s1")
+      r.expire("foo", 1)
+      r.persist("foo")
+
+      assert(-1 == r.ttl("foo"))
+    end
+
+    def test_ttl
+      r.set("foo", "s1")
+      r.expire("foo", 2)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+
+    def test_pttl
+      target_version "2.5.4" do
+        r.set("foo", "s1")
+        r.expire("foo", 2)
+        assert_in_range 1..2000, r.pttl("foo")
+      end
+    end
+
+    def test_dump_and_restore
+      target_version "2.5.7" do
+        r.set("foo", "a")
+        v = r.dump("foo")
+        r.del("foo")
+
+        assert r.restore("foo", 1000, v)
+        assert_equal "a", r.get("foo")
+        assert [0, 1].include? r.ttl("foo")
+
+        r.rpush("bar", ["b", "c", "d"])
+        w = r.dump("bar")
+        r.del("bar")
+
+        assert r.restore("bar", 1000, w)
+        assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
+        assert [0, 1].include? r.ttl("bar")
+      end
+    end
+
+    def test_move
+      r.select 14
+      r.flushdb
+
+      r.set "bar", "s3"
+
+      r.select 15
+
+      r.set "foo", "s1"
+      r.set "bar", "s2"
+
+      assert r.move("foo", 14)
+      assert_equal nil, r.get("foo")
+
+      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

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestPersistenceControlCommands < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_save
+    redis_mock(:save => lambda { "+SAVE" }) do |redis|
+      assert_equal "SAVE", redis.save
+    end
+  end
+
+  def test_bgsave
+    redis_mock(:bgsave => lambda { "+BGSAVE" }) do |redis|
+      assert_equal "BGSAVE", redis.bgsave
+    end
+  end
+
+  def test_lastsave
+    redis_mock(:lastsave => lambda { "+LASTSAVE" }) do |redis|
+      assert_equal "LASTSAVE", redis.lastsave
+    end
+  end
+end