redis 2.0.0 → 2.2.1

data/test/lint/sets.rb

@@ -0,0 +1,66 @@
+test "SADD" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+
+  assert ["s1", "s2"] == r.smembers("foo").sort
+end
+
+test "SREM" do |r|
+  r.sadd "foo", "s1"
+  r.sadd "foo", "s2"
+
+  r.srem("foo", "s1")
+
+  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,167 @@
+test "ZADD" do |r|
+  assert 0 == r.zcard("foo")
+
+  r.zadd "foo", 1, "s1"
+
+  assert 1 == r.zcard("foo")
+end
+
+test "ZREM" do |r|
+  r.zadd "foo", 1, "s1"
+
+  assert 1 == r.zcard("foo")
+
+  r.zadd "foo", 2, "s2"
+
+  assert 2 == r.zcard("foo")
+
+  r.zrem "foo", "s1"
+
+  assert 1 == r.zcard("foo")
+end
+
+test "ZINCRBY" do |r|
+  r.zincrby "foo", 1, "s1"
+
+  assert "1" == r.zscore("foo", "s1")
+
+  r.zincrby "foo", 10, "s1"
+
+  assert "11" == r.zscore("foo", "s1")
+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", "s2", "2"] == r.zrange("foo", 0, 1, :with_scores => true)
+  assert ["s1", "1", "s2", "2"] == 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", "s2", "2"] == r.zrevrange("foo", 0, 1, :with_scores => true)
+  assert ["s3", "3", "s2", "2"] == 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"] == r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :with_scores => true)
+  assert ["s3", "3"] == r.zrangebyscore("foo", 2, 4, :limit => [1, 1], :with_scores => true)
+  assert ["s2", "2"] == r.zrangebyscore("foo", 2, 4, :limit => [0, 1], :withscores => true)
+  assert ["s3", "3"] == 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"] == r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :with_scores => true)
+  assert ["s3", "3"] == r.zrevrangebyscore("foo", 4, 2, :limit => [1, 1], :with_scores => true)
+  assert ["s4", "4"] == r.zrevrangebyscore("foo", 4, 2, :limit => [0, 1], :withscores => true)
+  assert ["s3", "3"] == 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" == 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
+

data/test/lint/strings.rb

@@ -0,0 +1,137 @@
+test "SET and GET" do |r|
+  r.set("foo", "s1")
+
+  assert "s1" == r.get("foo")
+end
+
+test "SET and GET with brackets" do |r|
+  r["foo"] = "s1"
+
+  assert "s1" == r["foo"]
+end
+
+test "SET and GET with brackets and symbol" do |r|
+  r[:foo] = "s1"
+
+  assert "s1" == r[:foo]
+end
+
+test "SET and GET with newline characters" do |r|
+  r.set("foo", "1\n")
+
+  assert "1\n" == r.get("foo")
+end
+
+test "SET and GET with ASCII characters" do |r|
+  with_external_encoding("ASCII-8BIT") do
+    (0..255).each do |i|
+      str = "#{i.chr}---#{i.chr}"
+      r.set("foo", str)
+
+      assert str == r.get("foo")
+    end
+  end
+end if defined?(Encoding)
+
+test "SETEX" do |r|
+  r.setex("foo", 1, "s1")
+
+  assert "s1" == r.get("foo")
+
+  sleep 2
+
+  assert nil == r.get("foo")
+end
+
+test "GETSET" do |r|
+  r.set("foo", "bar")
+
+  assert "bar" == r.getset("foo", "baz")
+  assert "baz" == r.get("foo")
+end
+
+test "SETNX" do |r|
+  r.set("foo", "s1")
+
+  assert "s1" == r.get("foo")
+
+  r.setnx("foo", "s2")
+
+  assert "s1" == r.get("foo")
+end
+
+test "INCR" do |r|
+  assert 1 == r.incr("foo")
+  assert 2 == r.incr("foo")
+  assert 3 == r.incr("foo")
+end
+
+test "INCRBY" do |r|
+  assert 1 == r.incrby("foo", 1)
+  assert 3 == r.incrby("foo", 2)
+  assert 6 == r.incrby("foo", 3)
+end
+
+test "DECR" do |r|
+  r.set("foo", 3)
+
+  assert 2 == r.decr("foo")
+  assert 1 == r.decr("foo")
+  assert 0 == r.decr("foo")
+end
+
+test "DECRBY" do |r|
+  r.set("foo", 6)
+
+  assert 3 == r.decrby("foo", 3)
+  assert 1 == r.decrby("foo", 2)
+  assert 0 == r.decrby("foo", 1)
+end
+
+test "APPEND" do |r|
+  r.set "foo", "s"
+  r.append "foo", "1"
+
+  assert "s1" == r.get("foo")
+end
+
+test "SUBSTR" do |r|
+  r.set "foo", "lorem"
+
+  assert "ore" == r.substr("foo", 1, 3)
+end
+
+test "GETBIT" do |r|
+  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
+
+test "SETBIT" do |r|
+  r.set("foo", "a")
+
+  r.setbit("foo", 6, 1)
+
+  assert_equal "c", r.get("foo")
+end
+
+test "GETRANGE" do |r|
+  r.set("foo", "abcde")
+
+  assert_equal "bcd", r.getrange("foo", 1, 3)
+  assert_equal "abcde", r.getrange("foo", 0, -1)
+end
+
+test "SETRANGE" do |r|
+  r.set("foo", "abcde")
+
+  r.setrange("foo", 1, "bar")
+
+  assert_equal "abare", r.get("foo")
+end

data/test/lint/value_types.rb

@@ -0,0 +1,84 @@
+test "EXISTS" do |r|
+  assert false == r.exists("foo")
+
+  r.set("foo", "s1")
+
+  assert true ==  r.exists("foo")
+end
+
+test "TYPE" do |r|
+  assert "none" == r.type("foo")
+
+  r.set("foo", "s1")
+
+  assert "string" == r.type("foo")
+end
+
+test "KEYS" do |r|
+  r.set("f", "s1")
+  r.set("fo", "s2")
+  r.set("foo", "s3")
+
+  assert ["f","fo", "foo"] == r.keys("f*").sort
+end
+
+test "EXPIRE" do |r|
+  r.set("foo", "s1")
+  r.expire("foo", 1)
+
+  assert "s1" == r.get("foo")
+
+  sleep 2
+
+  assert nil == r.get("foo")
+end
+
+test "EXPIREAT" do |r|
+  r.set("foo", "s1")
+  r.expireat("foo", Time.now.to_i + 1)
+
+  assert "s1" == r.get("foo")
+
+  sleep 2
+
+  assert nil == r.get("foo")
+end
+
+test "PERSIST" do |r|
+  r.set("foo", "s1")
+  r.expire("foo", 1)
+  r.persist("foo")
+
+  assert(-1 == r.ttl("foo"))
+end
+
+test "TTL" do |r|
+  r.set("foo", "s1")
+  r.expire("foo", 1)
+
+  assert 1 == r.ttl("foo")
+end
+
+test "MOVE" do |r|
+  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 nil == r.get("foo")
+
+  assert !r.move("bar", 14)
+  assert "s2" == r.get("bar")
+
+  r.select 14
+
+  assert "s1" == r.get("foo")
+  assert "s3" == r.get("bar")
+end
+

data/test/persistence_control_commands_test.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "SAVE and BGSAVE" do |r|
+  assert_nothing_raised do
+    r.save
+  end
+
+  assert_nothing_raised do
+    r.bgsave
+  end
+end
+
+test "LASTSAVE" do |r|
+  assert Time.at(r.lastsave) <= Time.now
+end
+

data/test/pipelining_commands_test.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "BULK commands" do |r|
+  r.pipelined do
+    r.lpush "foo", "s1"
+    r.lpush "foo", "s2"
+  end
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.lpop("foo")
+  assert "s1" == r.lpop("foo")
+end
+
+test "MULTI_BULK commands" do |r|
+  r.pipelined do
+    r.mset("foo", "s1", "bar", "s2")
+    r.mset("baz", "s3", "qux", "s4")
+  end
+
+  assert "s1" == r.get("foo")
+  assert "s2" == r.get("bar")
+  assert "s3" == r.get("baz")
+  assert "s4" == r.get("qux")
+end
+
+test "BULK and MULTI_BULK commands mixed" do |r|
+  r.pipelined do
+    r.lpush "foo", "s1"
+    r.lpush "foo", "s2"
+    r.mset("baz", "s3", "qux", "s4")
+  end
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.lpop("foo")
+  assert "s1" == r.lpop("foo")
+  assert "s3" == r.get("baz")
+  assert "s4" == r.get("qux")
+end
+
+test "MULTI_BULK and BULK commands mixed" do |r|
+  r.pipelined do
+    r.mset("baz", "s3", "qux", "s4")
+    r.lpush "foo", "s1"
+    r.lpush "foo", "s2"
+  end
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.lpop("foo")
+  assert "s1" == r.lpop("foo")
+  assert "s3" == r.get("baz")
+  assert "s4" == r.get("qux")
+end
+
+test "Pipelined with an empty block" do |r|
+  assert_nothing_raised do
+    r.pipelined do
+    end
+  end
+
+  assert 0 == r.dbsize
+end
+
+test "Returning the result of a pipeline" do |r|
+  result = r.pipelined do
+    r.set "foo", "bar"
+    r.get "foo"
+    r.get "bar"
+  end
+
+  assert ["OK", "bar", nil] == result
+end
+
+test "Nesting pipeline blocks" do |r|
+  r.pipelined do
+    r.set("foo", "s1")
+    r.pipelined do
+      r.set("bar", "s2")
+    end
+  end
+
+  assert "s1" == r.get("foo")
+  assert "s2" == r.get("bar")
+end
+
+test "INFO in a pipeline" do |r|
+  result = r.pipelined do
+    r.info
+  end
+
+  assert result.first.kind_of?(String)
+end
+
+test "CONFIG GET in a pipeline" do |r|
+  result = r.pipelined do
+    r.config(:get, "*")
+  end
+
+  assert result.first.kind_of?(Array)
+end
+
+test "HGETALL in a pipeline should not return hash" do |r|
+  r.hmset("hash", "field", "value")
+  result = r.pipelined do
+    r.hgetall("hash")
+  end
+
+  assert ["field", "value"] == result.first
+end
+
+test "KEYS in a pipeline" do |r|
+  r.set("key", "value")
+  result = r.pipelined do
+    r.keys("*")
+  end
+
+  assert ["key"] == result.first
+end