gorsuch-redis 3.0.0.rc1

data/test/redis_mock.rb

@@ -0,0 +1,89 @@
+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
+
+    # Bail out of @server.accept before closing the socket. This is required
+    # to avoid EADDRINUSE after a couple of iterations.
+    def shutdown
+      @thread.terminate if @thread
+      @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)
+
+            # Convert a nil response to :close
+            response ||= :close
+
+            if response == :exit
+              session.shutdown(Socket::SHUT_RDWR)
+              return # exit server body
+            elsif response == :close
+              session.shutdown(Socket::SHUT_RDWR)
+              break # exit connection body
+            else
+              session.write(response)
+              session.write("\r\n") unless response.end_with?("\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
+    ensure
+      @server.close
+    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

data/test/remote_server_control_commands_test.rb

@@ -0,0 +1,88 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+require File.expand_path("./redis_mock", File.dirname(__FILE__))
+
+include RedisMock::Helper
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "INFO" do |r|
+  %w(last_save_time redis_version total_connections_received connected_clients total_commands_processed connected_slaves uptime_in_seconds used_memory uptime_in_days changes_since_last_save).each do |x|
+    assert r.info.keys.include?(x)
+  end
+end
+
+test "INFO COMMANDSTATS" do |r|
+  # Only available on Redis >= 2.9.0
+  next if version(r) < 209000
+
+  r.config(:resetstat)
+  r.ping
+
+  result = r.info(:commandstats)
+  assert "1" == result["ping"]["calls"]
+end
+
+test "MONITOR" do |r|
+  log = []
+
+  wire = Wire.new do
+    Redis.new(OPTIONS).monitor do |line|
+      log << line
+      break if log.size == 3
+    end
+  end
+
+  Wire.pass while log.empty? # Faster than sleep
+
+  r.set "foo", "s1"
+
+  wire.join
+
+  assert log[-1][%q{(db 15) "set" "foo" "s1"}]
+end
+
+test "MONITOR returns value for break" do |r|
+  result = r.monitor do |line|
+    break line
+  end
+
+  assert result == "OK"
+end
+
+test "ECHO" do |r|
+  assert "foo bar baz\n" == r.echo("foo bar baz\n")
+end
+
+test "DEBUG" do |r|
+  r.set "foo", "s1"
+
+  assert r.debug(:object, "foo").kind_of?(String)
+end
+
+test "OBJECT" do |r|
+  r.lpush "list", "value"
+
+  assert r.object(:refcount, "list") == 1
+  assert r.object(:encoding, "list") == "ziplist"
+  assert r.object(:idletime, "list").kind_of?(Fixnum)
+end
+
+test "SYNC" do |r|
+  replies = {:sync => lambda { "+OK" }}
+
+  redis_mock(replies) do
+    redis = Redis.new(OPTIONS.merge(:port => 6380))
+
+    assert "OK" == redis.sync
+  end
+end
+
+test "SLOWLOG" do |r|
+  r.slowlog(:reset)
+  result = r.slowlog(:len)
+  assert result == 0
+end

data/test/sorting_test.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "SORT" do |r|
+  r.set("foo:1", "s1")
+  r.set("foo:2", "s2")
+
+  r.rpush("bar", "1")
+  r.rpush("bar", "2")
+
+  assert ["s1"] == r.sort("bar", :get => "foo:*", :limit => [0, 1])
+  assert ["s2"] == r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
+end
+
+test "SORT with an array of GETs" do |r|
+  r.set("foo:1:a", "s1a")
+  r.set("foo:1:b", "s1b")
+
+  r.set("foo:2:a", "s2a")
+  r.set("foo:2:b", "s2b")
+
+  r.rpush("bar", "1")
+  r.rpush("bar", "2")
+
+  assert ["s1a", "s1b"] == r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
+  assert ["s2a", "s2b"] == r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+end
+
+test "SORT with STORE" do |r|
+  r.set("foo:1", "s1")
+  r.set("foo:2", "s2")
+
+  r.rpush("bar", "1")
+  r.rpush("bar", "2")
+
+  r.sort("bar", :get => "foo:*", :store => "baz")
+  assert ["s1", "s2"] == r.lrange("baz", 0, -1)
+end

data/test/synchrony_driver.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+require 'em-synchrony'
+
+require 'redis'
+require 'redis/connection/synchrony'
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+#
+# if running under Eventmachine + Synchrony (Ruby 1.9+), then
+# we can simulate the blocking API while performing the network
+# IO via the EM reactor.
+#
+
+EM.synchrony do
+  r = Redis.new
+  r.flushdb
+
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert 2 == r.llen("foo")
+  assert "s2" == r.rpop("foo")
+
+  r.set("foo", "bar")
+
+  assert "bar" == r.getset("foo", "baz")
+  assert "baz" == r.get("foo")
+
+  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)
+
+  r.flushdb
+
+  # command pipelining
+  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")
+
+  assert "OK" == r.client.call(:quit)
+  assert "PONG" == r.ping
+
+  EM.stop
+end

data/test/test.conf

@@ -0,0 +1,9 @@
+dir ./test/db
+pidfile ./redis.pid
+port 6379
+unixsocket /tmp/redis.sock
+timeout 300
+loglevel debug
+logfile stdout
+databases 16
+daemonize yes

data/test/thread_safety_test.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "thread safety" do
+  redis = Redis.connect(OPTIONS.merge(:thread_safe => true))
+
+  redis.set "foo", 1
+  redis.set "bar", 2
+
+  sample = 100
+
+  t1 = Thread.new do
+    $foos = Array.new(sample) { redis.get "foo" }
+  end
+
+  t2 = Thread.new do
+    $bars = Array.new(sample) { redis.get "bar" }
+  end
+
+  t1.join
+  t2.join
+
+  assert_equal ["1"], $foos.uniq
+  assert_equal ["2"], $bars.uniq
+end

data/test/transactions_test.rb

@@ -0,0 +1,173 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+setup do
+  init Redis.new(OPTIONS)
+end
+
+test "MULTI/DISCARD" do |r|
+  r.multi
+
+  assert "QUEUED" == r.set("foo", "1")
+  assert "QUEUED" == r.get("foo")
+
+  r.discard
+
+  assert nil == r.get("foo")
+end
+
+test "MULTI/EXEC with a block" do |r|
+  r.multi do |multi|
+    multi.set "foo", "s1"
+  end
+
+  assert "s1" == r.get("foo")
+end
+
+test "MULTI/EXEC with a block doesn't return replies for MULTI and EXEC" do |r|
+  r1, r2, nothing_else = r.multi do |multi|
+    multi.set "foo", "s1"
+    multi.get "foo"
+  end
+
+  assert_equal "OK", r1
+  assert_equal "s1", r2
+  assert_equal nil, nothing_else
+end
+
+test "Assignment inside MULTI/EXEC block" do |r|
+  r.multi do |m|
+    @first = m.sadd("foo", 1)
+    @second = m.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 inside MULTI/EXEC block with delayed command errors" do |r|
+  assert_raise do
+    r.multi do |m|
+      @first = m.set("foo", "s1")
+      @second = m.incr("foo") # not an integer
+      @third = m.lpush("foo", "value") # wrong kind of value
+    end
+  end
+
+  assert_equal "OK", @first.value
+  assert_raise { @second.value }
+  assert_raise { @third.value }
+end
+
+test "Assignment inside MULTI/EXEC block with immediate command errors" do |r|
+  assert_raise do
+    r.multi do |m|
+      m.doesnt_exist
+      @first = m.sadd("foo", 1)
+      m.doesnt_exist
+      @second = m.sadd("foo", 1)
+      m.doesnt_exist
+    end
+  end
+
+  assert_raise(Redis::FutureNotReady) { @first.value }
+  assert_raise(Redis::FutureNotReady) { @second.value }
+end
+
+test "Raise immediate errors in MULTI/EXEC" do |r|
+  assert_raise(RuntimeError) do
+    r.multi do |multi|
+      multi.set "bar", "s2"
+      raise "Some error"
+      multi.set "baz", "s3"
+    end
+  end
+
+  assert nil == r.get("bar")
+  assert nil == r.get("baz")
+end
+
+test "Transformed replies as return values for MULTI/EXEC block" do |r|
+  info, _ = r.multi do |m|
+    r.info
+  end
+
+  assert info.kind_of?(Hash)
+end
+
+test "Transformed replies inside MULTI/EXEC block" do |r|
+  r.multi do |m|
+    @info = r.info
+  end
+
+  assert @info.value.kind_of?(Hash)
+end
+
+test "Raise command errors in MULTI/EXEC" do |r|
+  assert_raise do
+    r.multi do |m|
+      m.set("foo", "s1")
+      m.incr("foo") # not an integer
+      m.lpush("foo", "value") # wrong kind of value
+    end
+  end
+
+  assert "s1" == r.get("foo")
+end
+
+test "Raise command errors when accessing futures after MULTI/EXEC" do |r|
+  begin
+    r.multi do |m|
+      m.set("foo", "s1")
+      @counter = m.incr("foo") # not an integer
+    end
+  rescue Exception
+    # Not gonna deal with it
+  end
+
+  # We should test for Redis::Error here, but hiredis doesn't yet do
+  # custom error classes.
+  assert_raise(RuntimeError) { @counter.value }
+end
+
+test "MULTI with a block yielding the client" do |r|
+  r.multi do |multi|
+    multi.set "foo", "s1"
+  end
+
+  assert "s1" == r.get("foo")
+end
+
+test "WATCH with an unmodified key" do |r|
+  r.watch "foo"
+  r.multi do |multi|
+    multi.set "foo", "s1"
+  end
+
+  assert "s1" == r.get("foo")
+end
+
+test "WATCH with a modified key" do |r|
+  r.watch "foo"
+  r.set "foo", "s1"
+  res = r.multi do |multi|
+    multi.set "foo", "s2"
+  end
+
+  assert nil == res
+  assert "s1" == r.get("foo")
+end
+
+test "UNWATCH with a modified key" do |r|
+  r.watch "foo"
+  r.set "foo", "s1"
+  r.unwatch
+  r.multi do |multi|
+    multi.set "foo", "s2"
+  end
+
+  assert "s2" == r.get("foo")
+end