redis 2.1.1 → 2.2.0

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

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 RuntimeError 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

data/test/redis_mock.rb

@@ -0,0 +1,80 @@
+require "socket"
+
+module RedisMock
+  class Server
+    VERBOSE = false
+
+    def initialize(port = 6380, &block)
+      @server = TCPServer.new("127.0.0.1", port)
+      @server.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+      @thread = Thread.new { run(&block) }
+    end
+
+    # This raises an exception in the thread calling @server.accept which
+    # in turn will cause the thread to terminate.
+    def shutdown
+      @server.close if @server
+    rescue => ex
+      $stderr.puts "Error closing mock server: #{ex.message}" if VERBOSE
+      $stderr.puts ex.backtrace if VERBOSE
+    end
+
+    def run
+      loop do
+        session = @server.accept
+
+        begin
+          while line = session.gets
+            parts = Array.new(line[1..-3].to_i) do
+              bytes = session.gets[1..-3].to_i
+              argument = session.read(bytes)
+              session.read(2) # Discard \r\n
+              argument
+            end
+
+            response = yield(*parts)
+
+            if response.nil?
+              session.shutdown(Socket::SHUT_RDWR)
+              break
+            else
+              session.write(response)
+              session.write("\r\n")
+            end
+          end
+        rescue Errno::ECONNRESET
+          # Ignore client closing the connection
+        end
+      end
+    rescue => ex
+      $stderr.puts "Error running mock server: #{ex.message}" if VERBOSE
+      $stderr.puts ex.backtrace if VERBOSE
+    end
+  end
+
+  module Helper
+    # Starts a mock Redis server in a thread on port 6380.
+    #
+    # The server will reply with a `+OK` to all commands, but you can
+    # customize it by providing a hash. For example:
+    #
+    #     redis_mock(:ping => lambda { "+PONG" }) do
+    #       assert_equal "PONG", Redis.new(:port => 6380).ping
+    #     end
+    #
+    def redis_mock(replies = {})
+      begin
+        server = Server.new do |command, *args|
+          (replies[command.to_sym] || lambda { |*_| "+OK" }).call(*args)
+        end
+
+        sleep 0.1 # Give time for the socket to start listening.
+
+        yield
+
+      ensure
+        server.shutdown
+      end
+    end
+  end
+end