gorsuch-redis 3.0.0.rc1

data/test/lint/strings.rb

@@ -0,0 +1,133 @@
+require File.expand_path("../redis_mock", File.dirname(__FILE__))
+
+include RedisMock::Helper
+
+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
+  redis_mock(:setex => lambda { |*args| "+#{args.join(" ")}" }) do
+    r = Redis.new(OPTIONS.merge(:port => 6380))
+
+    assert_equal "foo 1 s1", r.setex("foo", 1, "s1")
+  end
+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 "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,81 @@
+require File.expand_path("../redis_mock", File.dirname(__FILE__))
+
+include RedisMock::Helper
+
+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|
+  redis_mock(:expire => lambda { |*args| args == ["foo", "1"] ? ":1" : ":0" }) do
+    r = Redis.new(OPTIONS.merge(:port => 6380))
+
+    assert r.expire("foo", 1)
+  end
+end
+
+test "EXPIREAT" do |r|
+  redis_mock(:expireat => lambda { |*args| args == ["foo", "1328236326"] ? ":1" : ":0" }) do
+    r = Redis.new(OPTIONS.merge(:port => 6380))
+
+    assert r.expireat("foo", 1328236326)
+  end
+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,21 @@
+# 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,186 @@
+# 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 "Assignment of results inside the block" do |r|
+  r.pipelined do
+    @first = r.sadd("foo", 1)
+    @second = r.sadd("foo", 1)
+  end
+
+  assert_equal true, @first.value
+  assert_equal false, @second.value
+end
+
+# Although we could support accessing the values in these futures,
+# it doesn't make a lot of sense.
+test "Assignment of results inside the block with errors" do |r|
+  assert_raise do
+    r.pipelined do
+      r.doesnt_exist
+      @first = r.sadd("foo", 1)
+      r.doesnt_exist
+      @second = r.sadd("foo", 1)
+      r.doesnt_exist
+    end
+  end
+
+  assert_raise(Redis::FutureNotReady) { @first.value }
+  assert_raise(Redis::FutureNotReady) { @second.value }
+end
+
+test "Assignment of results inside a nested block" do |r|
+  r.pipelined do
+    @first = r.sadd("foo", 1)
+
+    r.pipelined do
+      @second = r.sadd("foo", 1)
+    end
+  end
+
+  assert_equal true, @first.value
+  assert_equal false, @second.value
+end
+
+test "Futures raise when confused with something else" do |r|
+  r.pipelined do
+    @result = r.sadd("foo", 1)
+  end
+
+  assert_raise(NoMethodError) { @result.to_s }
+end
+
+test "Futures raise when trying to access their values too early" do |r|
+  r.pipelined do
+    assert_raise(Redis::FutureNotReady) do
+      r.sadd("foo", 1).value
+    end
+  end
+end
+
+test "Returning the result of an empty pipeline" do |r|
+  result = r.pipelined do
+  end
+
+  assert [] == 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 returns hash" do |r|
+  result = r.pipelined do
+    r.info
+  end
+
+  assert result.first.kind_of?(Hash)
+end
+
+test "CONFIG GET in a pipeline returns hash" do |r|
+  result = r.pipelined do
+    r.config(:get, "*")
+  end
+
+  assert result.first.kind_of?(Hash)
+end
+
+test "HGETALL in a pipeline returns hash" do |r|
+  r.hmset("hash", "field", "value")
+  result = r.pipelined do
+    r.hgetall("hash")
+  end
+
+  assert result.first == { "field" => "value" }
+end
+
+test "KEYS in a pipeline" do |r|
+  r.set("key", "value")
+  result = r.pipelined do
+    r.keys("*")
+  end
+
+  assert ["key"] == result.first
+end

data/test/publish_subscribe_test.rb

@@ -0,0 +1,158 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "SUBSCRIBE and UNSUBSCRIBE" do |r|
+  listening = false
+
+  wire = Wire.new do
+    r.subscribe("foo") do |on|
+      on.subscribe do |channel, total|
+        @subscribed = true
+        @t1 = total
+      end
+
+      on.message do |channel, message|
+        if message == "s1"
+          r.unsubscribe
+          @message = message
+        end
+      end
+
+      on.unsubscribe do |channel, total|
+        @unsubscribed = true
+        @t2 = total
+      end
+
+      listening = true
+    end
+  end
+
+  Wire.pass while !listening
+
+  Redis.new(OPTIONS).publish("foo", "s1")
+
+  wire.join
+
+  assert @subscribed
+  assert 1 == @t1
+  assert @unsubscribed
+  assert 0 == @t2
+  assert "s1" == @message
+end
+
+test "PSUBSCRIBE and PUNSUBSCRIBE" do |r|
+  listening = false
+
+  wire = Wire.new do
+    r.psubscribe("f*") do |on|
+      on.psubscribe do |pattern, total|
+        @subscribed = true
+        @t1 = total
+      end
+
+      on.pmessage do |pattern, channel, message|
+        if message == "s1"
+          r.punsubscribe
+          @message = message
+        end
+      end
+
+      on.punsubscribe do |pattern, total|
+        @unsubscribed = true
+        @t2 = total
+      end
+
+      listening = true
+    end
+  end
+
+  Wire.pass while !listening
+
+  Redis.new(OPTIONS).publish("foo", "s1")
+
+  wire.join
+
+  assert @subscribed
+  assert 1 == @t1
+  assert @unsubscribed
+  assert 0 == @t2
+  assert "s1" == @message
+end
+
+test "SUBSCRIBE within SUBSCRIBE" do |r|
+  listening = false
+
+  @channels = []
+
+  wire = Wire.new do
+    r.subscribe("foo") do |on|
+      on.subscribe do |channel, total|
+        @channels << channel
+
+        r.subscribe("bar") if channel == "foo"
+        r.unsubscribe if channel == "bar"
+      end
+
+      listening = true
+    end
+  end
+
+  Wire.pass while !listening
+
+  Redis.new(OPTIONS).publish("foo", "s1")
+
+  wire.join
+
+  assert ["foo", "bar"] == @channels
+end
+
+test "other commands within a SUBSCRIBE" do |r|
+  assert_raise Redis::CommandError do
+    r.subscribe("foo") do |on|
+      on.subscribe do |channel, total|
+        r.set("bar", "s2")
+      end
+    end
+  end
+end
+
+test "SUBSCRIBE without a block" do |r|
+  assert_raise LocalJumpError do
+    r.subscribe("foo")
+  end
+end
+
+test "UNSUBSCRIBE without a SUBSCRIBE" do |r|
+  assert_raise RuntimeError do
+    r.unsubscribe
+  end
+
+  assert_raise RuntimeError do
+    r.punsubscribe
+  end
+end
+
+test "SUBSCRIBE past a timeout" do |r|
+  # For some reason, a thread here doesn't reproduce the issue.
+  sleep = %{sleep #{OPTIONS[:timeout] + 1}}
+  publish = %{echo "publish foo bar\r\n" | nc localhost #{OPTIONS[:port]}}
+  cmd = [sleep, publish].join("; ")
+
+  IO.popen(cmd, "r+") do |pipe|
+    received = false
+
+    r.subscribe "foo" do |on|
+      on.message do |channel, message|
+        received = true
+        r.unsubscribe
+      end
+    end
+
+    assert received
+  end
+end