gorsuch-redis 3.0.0.rc1

data/test/lint/hashes.rb

@@ -0,0 +1,140 @@
+test "HSET and HGET" do |r|
+  r.hset("foo", "f1", "s1")
+
+  assert "s1" == r.hget("foo", "f1")
+end
+
+test "HSETNX" do |r|
+  r.hset("foo", "f1", "s1")
+  r.hsetnx("foo", "f1", "s2")
+
+  assert "s1" == r.hget("foo", "f1")
+
+  r.del("foo")
+  r.hsetnx("foo", "f1", "s2")
+
+  assert "s2" == r.hget("foo", "f1")
+end
+
+test "HDEL" do |r|
+  r.hset("foo", "f1", "s1")
+
+  assert "s1" == r.hget("foo", "f1")
+
+  assert 1 == r.hdel("foo", "f1")
+
+  assert nil == r.hget("foo", "f1")
+end
+
+test "Variadic HDEL" do |r|
+  next if version(r) < 203090
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert "s1" == r.hget("foo", "f1")
+  assert "s2" == r.hget("foo", "f2")
+
+  assert 2 == r.hdel("foo", ["f1", "f2"])
+
+  assert nil == r.hget("foo", "f1")
+  assert nil == r.hget("foo", "f2")
+end
+
+test "HEXISTS" do |r|
+  assert false == r.hexists("foo", "f1")
+
+  r.hset("foo", "f1", "s1")
+
+  assert r.hexists("foo", "f1")
+end
+
+test "HLEN" do |r|
+  assert 0 == r.hlen("foo")
+
+  r.hset("foo", "f1", "s1")
+
+  assert 1 == r.hlen("foo")
+
+  r.hset("foo", "f2", "s2")
+
+  assert 2 == r.hlen("foo")
+end
+
+test "HKEYS" do |r|
+  assert [] == r.hkeys("foo")
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert ["f1", "f2"] == r.hkeys("foo")
+end
+
+test "HVALS" do |r|
+  assert [] == r.hvals("foo")
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert ["s1", "s2"] == r.hvals("foo")
+end
+
+test "HGETALL" do |r|
+  assert({} == r.hgetall("foo"))
+
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+
+  assert({"f1" => "s1", "f2" => "s2"} == r.hgetall("foo"))
+end
+
+test "HMSET" do |r|
+  r.hmset("hash", "foo1", "bar1", "foo2", "bar2")
+
+  assert "bar1" == r.hget("hash", "foo1")
+  assert "bar2" == r.hget("hash", "foo2")
+end
+
+test "HMSET with invalid arguments" do |r|
+  assert_raise(Redis::CommandError) do
+    r.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3")
+  end
+end
+
+test "Mapped HMSET" do |r|
+  r.mapped_hmset("foo", :f1 => "s1", :f2 => "s2")
+
+  assert "s1" == r.hget("foo", "f1")
+  assert "s2" == r.hget("foo", "f2")
+end
+
+test "HMGET" do |r|
+  r.hset("foo", "f1", "s1")
+  r.hset("foo", "f2", "s2")
+  r.hset("foo", "f3", "s3")
+
+  assert ["s2", "s3"] == r.hmget("foo", "f2", "f3")
+end
+
+test "HMGET mapped" do |r|
+  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
+
+test "HINCRBY" do |r|
+  r.hincrby("foo", "f1", 1)
+
+  assert "1" == r.hget("foo", "f1")
+
+  r.hincrby("foo", "f1", 2)
+
+  assert "3" == r.hget("foo", "f1")
+
+  r.hincrby("foo", "f1", -1)
+
+  assert "2" == r.hget("foo", "f1")
+end

data/test/lint/internals.rb

@@ -0,0 +1,36 @@
+test "Logger" do |r, log|
+  r.ping
+
+  assert log.string =~ /Redis >> PING/
+  assert log.string =~ /Redis >> \d+\.\d+ms/
+end
+
+test "Logger with pipelining" do |r, log|
+  r.pipelined do
+    r.set "foo", "bar"
+    r.get "foo"
+  end
+
+  assert log.string["SET foo bar"]
+  assert log.string["GET foo"]
+end if $TEST_PIPELINING
+
+test "Recovers from failed commands" do |r, _|
+  # See http://github.com/ezmobius/redis-rb/issues#issue/28
+
+  assert_raise do
+    r.command_that_doesnt_exist
+  end
+
+  assert_nothing_raised do
+    r.info
+  end
+end
+
+test "raises on protocol errors" do
+  redis_mock(:ping => lambda { |*_| "foo" }) do
+    assert_raise(Redis::ProtocolError) do
+      Redis.connect(:port => 6380).ping
+    end
+  end
+end

data/test/lint/lists.rb

@@ -0,0 +1,107 @@
+test "RPUSH" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.rpop("foo")
+end
+
+test "Variadic RPUSH" do |r|
+  next if version(r) < 203090 # 2.4-rc6
+
+  assert 3 == r.rpush("foo", ["s1", "s2", "s3"])
+  assert 3 == r.llen("foo")
+  assert "s3" == r.rpop("foo")
+end
+
+test "LPUSH" do |r|
+  r.lpush "foo", "s1"
+  r.lpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.lpop("foo")
+end
+
+test "Variadic LPUSH" do |r|
+  next if version(r) < 203090 # 2.4-rc6
+
+  assert 3 == r.lpush("foo", ["s1", "s2", "s3"])
+  assert 3 == r.llen("foo")
+  assert "s3" == r.lpop("foo")
+end
+
+test "LLEN" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+end
+
+test "LRANGE" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+  r.rpush "foo", "s3"
+
+  assert ["s2", "s3"] == r.lrange("foo", 1, -1)
+  assert ["s1", "s2"] == r.lrange("foo", 0, 1)
+
+  assert [] == r.lrange("bar", 0, -1)
+end
+
+test "LTRIM" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+  r.rpush "foo", "s3"
+
+  r.ltrim "foo", 0, 1
+
+  assert 2 == r.llen("foo")
+  assert ["s1", "s2"] == r.lrange("foo", 0, -1)
+end
+
+test "LINDEX" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert "s1" == r.lindex("foo", 0)
+  assert "s2" == r.lindex("foo", 1)
+end
+
+test "LSET" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert "s2" == r.lindex("foo", 1)
+  assert r.lset("foo", 1, "s3")
+  assert "s3" == r.lindex("foo", 1)
+
+  assert_raise Redis::CommandError do
+    r.lset("foo", 4, "s3")
+  end
+end
+
+test "LREM" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 1 == r.lrem("foo", 1, "s1")
+  assert ["s2"] == r.lrange("foo", 0, -1)
+end
+
+test "LPOP" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s1" == r.lpop("foo")
+  assert 1 == r.llen("foo")
+end
+
+test "RPOP" do |r|
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.rpop("foo")
+  assert 1 == r.llen("foo")
+end

data/test/lint/sets.rb

@@ -0,0 +1,90 @@
+test "SADD" do |r|
+  assert true == r.sadd("foo", "s1")
+  assert true == r.sadd("foo", "s2")
+  assert false == r.sadd("foo", "s1")
+
+  assert ["s1", "s2"] == r.smembers("foo").sort
+end
+
+test "Variadic SADD" do |r|
+  next if version(r) < 203090 # 2.4-rc6
+
+  assert 2 == r.sadd("foo", ["s1", "s2"])
+  assert 1 == r.sadd("foo", ["s1", "s2", "s3"])
+
+  assert ["s1", "s2", "s3"] == r.smembers("foo").sort
+end
+
+test "SREM" do |r|
+  r.sadd("foo", "s1")
+  r.sadd("foo", "s2")
+
+  assert true == r.srem("foo", "s1")
+  assert false == r.srem("foo", "s3")
+
+  assert ["s2"] == r.smembers("foo")
+end
+
+test "Variadic SREM" do |r|
+  next if version(r) < 203090 # 2.4-rc6
+
+  r.sadd("foo", "s1")
+  r.sadd("foo", "s2")
+  r.sadd("foo", "s3")
+
+  assert 1 == r.srem("foo", ["s1", "aaa"])
+  assert 0 == r.srem("foo", ["bbb", "ccc" "ddd"])
+  assert 1 == r.srem("foo", ["eee", "s3"])
+
+  assert ["s2"] == r.smembers("foo")
+end
+
+test "SPOP" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+
+  assert ["s1", "s2"].include?(r.spop("foo"))
+  assert ["s1", "s2"].include?(r.spop("foo"))
+  assert nil == r.spop("foo")
+end
+
+test "SCARD" do |r|
+  assert 0 == r.scard("foo")
+
+  r.sadd "foo", "s1"
+
+  assert 1 == r.scard("foo")
+
+  r.sadd "foo", "s2"
+
+  assert 2 == r.scard("foo")
+end
+
+test "SISMEMBER" do |r|
+  assert false == r.sismember("foo", "s1")
+
+  r.sadd "foo", "s1"
+
+  assert true ==  r.sismember("foo", "s1")
+  assert false == r.sismember("foo", "s2")
+end
+
+test "SMEMBERS" do |r|
+  assert [] == r.smembers("foo")
+
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+
+  assert ["s1", "s2"] == r.smembers("foo").sort
+end
+
+test "SRANDMEMBER" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+
+  4.times do
+    assert ["s1", "s2"].include?(r.srandmember("foo"))
+  end
+
+  assert 2 == r.scard("foo")
+end

data/test/lint/sorted_sets.rb

@@ -0,0 +1,196 @@
+test "ZADD" do |r|
+  assert 0 == r.zcard("foo")
+  assert true == r.zadd("foo", 1, "s1")
+  assert false == r.zadd("foo", 1, "s1")
+  assert 1 == r.zcard("foo")
+end
+
+test "Variadic ZADD" do |r|
+  next if version(r) < 203090 # 2.4-rc6
+
+  # Non-nested array with pairs
+  assert 0 == r.zcard("foo")
+  assert 2 == r.zadd("foo", [1, "s1", 2, "s2"])
+  assert 1 == r.zadd("foo", [4, "s1", 5, "s2", 6, "s3"])
+  assert 3 == r.zcard("foo")
+  r.del "foo"
+
+  # Nested array with pairs
+  assert 0 == r.zcard("foo")
+  assert 2 == r.zadd("foo", [[1, "s1"], [2, "s2"]])
+  assert 1 == r.zadd("foo", [[4, "s1"], [5, "s2"], [6, "s3"]])
+  assert 3 == r.zcard("foo")
+  r.del "foo"
+
+  # Wrong number of arguments
+  assert_raise { r.zadd("foo") }
+  assert_raise { r.zadd("foo", ["bar"]) }
+  assert_raise { r.zadd("foo", ["bar", "qux", "zap"]) }
+end
+
+test "ZREM" do |r|
+  r.zadd("foo", 1, "s1")
+  r.zadd("foo", 2, "s2")
+
+  assert 2 == r.zcard("foo")
+  assert true == r.zrem("foo", "s1")
+  assert false == r.zrem("foo", "s1")
+  assert 1 == r.zcard("foo")
+end
+
+test "Variadic ZREM" do |r|
+  next if version(r) < 203090 # 2.4-rc6
+
+  r.zadd("foo", 1, "s1")
+  r.zadd("foo", 2, "s2")
+  r.zadd("foo", 3, "s3")
+
+  assert 3 == r.zcard("foo")
+  assert 1 == r.zrem("foo", ["s1", "aaa"])
+  assert 0 == r.zrem("foo", ["bbb", "ccc" "ddd"])
+  assert 1 == r.zrem("foo", ["eee", "s3"])
+  assert 1 == r.zcard("foo")
+end
+
+test "ZINCRBY" do |r|
+  rv = r.zincrby "foo", 1, "s1"
+  assert 1.0 == rv
+
+  rv = r.zincrby "foo", 10, "s1"
+  assert 11.0 == rv
+end
+
+test "ZRANK" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+
+  assert 2 == r.zrank("foo", "s3")
+end
+
+test "ZREVRANK" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+
+  assert 0 == r.zrevrank("foo", "s3")
+end
+
+test "ZRANGE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+
+  assert ["s1", "s2"] == r.zrange("foo", 0, 1)
+  assert [["s1", 1.0], ["s2", 2.0]] == r.zrange("foo", 0, 1, :with_scores => true)
+  assert [["s1", 1.0], ["s2", 2.0]] == r.zrange("foo", 0, 1, :withscores => true)
+end
+
+test "ZREVRANGE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+
+  assert ["s3", "s2"] == r.zrevrange("foo", 0, 1)
+  assert [["s3", 3.0], ["s2", 2.0]] == r.zrevrange("foo", 0, 1, :with_scores => true)
+  assert [["s3", 3.0], ["s2", 2.0]] == r.zrevrange("foo", 0, 1, :withscores => true)
+end
+
+test "ZRANGEBYSCORE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+
+  assert ["s2", "s3"] == r.zrangebyscore("foo", 2, 3)
+end
+
+test "ZREVRANGEBYSCORE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+
+  assert ["s3", "s2"] == r.zrevrangebyscore("foo", 3, 2)
+end
+
+test "ZRANGEBYSCORE with LIMIT" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+  r.zadd "foo", 4, "s4"
+
+  assert ["s2"] == r.zrangebyscore("foo", 2, 4, :limit => [0, 1])
+  assert ["s3"] == r.zrangebyscore("foo", 2, 4, :limit => [1, 1])
+  assert ["s3", "s4"] == r.zrangebyscore("foo", 2, 4, :limit => [1, 2])
+end
+
+test "ZREVRANGEBYSCORE with LIMIT" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+  r.zadd "foo", 4, "s4"
+
+  assert ["s4"] == r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1])
+  assert ["s3"] == r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1])
+  assert ["s3", "s2"] == r.zrevrangebyscore("foo", 4, 2, :limit => [1, 2])
+end
+
+test "ZRANGEBYSCORE with WITHSCORES" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+  r.zadd "foo", 4, "s4"
+
+  assert [["s2", 2.0]] == r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :with_scores => true)
+  assert [["s3", 3.0]] == r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :with_scores => true)
+  assert [["s2", 2.0]] == r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :withscores => true)
+  assert [["s3", 3.0]] == r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :withscores => true)
+end
+
+test "ZREVRANGEBYSCORE with WITHSCORES" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+  r.zadd "foo", 4, "s4"
+
+  assert [["s4", 4.0]] == r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :with_scores => true)
+  assert [["s3", 3.0]] == r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :with_scores => true)
+  assert [["s4", 4.0]] == r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :withscores => true)
+  assert [["s3", 3.0]] == r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :withscores => true)
+end
+
+test "ZCARD" do |r|
+  assert 0 == r.zcard("foo")
+
+  r.zadd "foo", 1, "s1"
+
+  assert 1 == r.zcard("foo")
+end
+
+test "ZSCORE" do |r|
+  r.zadd "foo", 1, "s1"
+
+  assert 1.0 == r.zscore("foo", "s1")
+
+  assert nil == r.zscore("foo", "s2")
+  assert nil == r.zscore("bar", "s1")
+end
+
+test "ZREMRANGEBYRANK" do |r|
+  r.zadd "foo", 10, "s1"
+  r.zadd "foo", 20, "s2"
+  r.zadd "foo", 30, "s3"
+  r.zadd "foo", 40, "s4"
+
+  assert 3 == r.zremrangebyrank("foo", 1, 3)
+  assert ["s1"] == r.zrange("foo", 0, -1)
+end
+
+test "ZREMRANGEBYSCORE" do |r|
+  r.zadd "foo", 1, "s1"
+  r.zadd "foo", 2, "s2"
+  r.zadd "foo", 3, "s3"
+  r.zadd "foo", 4, "s4"
+
+  assert 3 == r.zremrangebyscore("foo", 2, 4)
+  assert ["s1"] == r.zrange("foo", 0, -1)
+end