discourse-redis 3.2.2

data/test/lint/blocking_commands.rb

@@ -0,0 +1,150 @@
+module Lint
+
+  module BlockingCommands
+
+    def setup
+      super
+
+      r.rpush("{zap}foo", "s1")
+      r.rpush("{zap}foo", "s2")
+      r.rpush("{zap}bar", "s1")
+      r.rpush("{zap}bar", "s2")
+    end
+
+    def to_protocol(obj)
+      case obj
+      when String
+        "$#{obj.length}\r\n#{obj}\r\n"
+      when Array
+        "*#{obj.length}\r\n" + obj.map { |e| to_protocol(e) }.join
+      else
+        fail
+      end
+    end
+
+    def mock(options = {}, &blk)
+      commands = {
+        :blpop => lambda do |*args|
+          sleep options[:delay] if options.has_key?(:delay)
+          to_protocol([args.first, args.last])
+        end,
+        :brpop => lambda do |*args|
+          sleep options[:delay] if options.has_key?(:delay)
+          to_protocol([args.first, args.last])
+        end,
+        :brpoplpush => lambda do |*args|
+          sleep options[:delay] if options.has_key?(:delay)
+          to_protocol(args.last)
+        end,
+      }
+
+      redis_mock(commands, &blk)
+    end
+
+    def test_blpop
+      assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo")
+      assert_equal ["{zap}foo", "s2"], r.blpop(["{zap}foo"])
+      assert_equal ["{zap}bar", "s1"], r.blpop(["{zap}bar", "{zap}foo"])
+      assert_equal ["{zap}bar", "s2"], r.blpop(["{zap}foo", "{zap}bar"])
+    end
+
+    def test_blpop_timeout
+      mock do |r|
+        assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo")
+        assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", :timeout => 1)
+      end
+    end
+
+    def test_blpop_with_old_prototype
+      assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo", 0)
+      assert_equal ["{zap}foo", "s2"], r.blpop("{zap}foo", 0)
+      assert_equal ["{zap}bar", "s1"], r.blpop("{zap}bar", "{zap}foo", 0)
+      assert_equal ["{zap}bar", "s2"], r.blpop("{zap}foo", "{zap}bar", 0)
+    end
+
+    def test_blpop_timeout_with_old_prototype
+      mock do |r|
+        assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo", 0)
+        assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", 1)
+      end
+    end
+
+    def test_brpop
+      assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo")
+      assert_equal ["{zap}foo", "s1"], r.brpop(["{zap}foo"])
+      assert_equal ["{zap}bar", "s2"], r.brpop(["{zap}bar", "{zap}foo"])
+      assert_equal ["{zap}bar", "s1"], r.brpop(["{zap}foo", "{zap}bar"])
+    end
+
+    def test_brpop_timeout
+      mock do |r|
+        assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo")
+        assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", :timeout => 1)
+      end
+    end
+
+    def test_brpop_with_old_prototype
+      assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo", 0)
+      assert_equal ["{zap}foo", "s1"], r.brpop("{zap}foo", 0)
+      assert_equal ["{zap}bar", "s2"], r.brpop("{zap}bar", "{zap}foo", 0)
+      assert_equal ["{zap}bar", "s1"], r.brpop("{zap}foo", "{zap}bar", 0)
+    end
+
+    def test_brpop_timeout_with_old_prototype
+      mock do |r|
+        assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo", 0)
+        assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", 1)
+      end
+    end
+
+    def test_brpoplpush
+      assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux")
+      assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
+    end
+
+    def test_brpoplpush_timeout
+      mock do |r|
+        assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar")
+        assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
+      end
+    end
+
+    def test_brpoplpush_with_old_prototype
+      assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux", 0)
+      assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
+    end
+
+    def test_brpoplpush_timeout_with_old_prototype
+      mock do |r|
+        assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar", 0)
+        assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", 1)
+      end
+    end
+
+    driver(:ruby, :hiredis) do
+      def test_blpop_socket_timeout
+        mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+          assert_raises(Redis::TimeoutError) do
+            r.blpop("{zap}foo", :timeout => 1)
+          end
+        end
+      end
+
+      def test_brpop_socket_timeout
+        mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+          assert_raises(Redis::TimeoutError) do
+            r.brpop("{zap}foo", :timeout => 1)
+          end
+        end
+      end
+
+      def test_brpoplpush_socket_timeout
+        mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
+          assert_raises(Redis::TimeoutError) do
+            r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
+          end
+        end
+      end
+    end
+  end
+end

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