discourse-redis 3.2.2

data/test/support/connection/hiredis.rb

@@ -0,0 +1 @@
+require "support/wire/thread"

data/test/support/connection/ruby.rb

@@ -0,0 +1 @@
+require "support/wire/thread"

data/test/support/connection/synchrony.rb

@@ -0,0 +1,17 @@
+require "support/wire/synchrony"
+
+module Helper
+  def around
+    rv = nil
+
+    EM.synchrony do
+      begin
+        rv = yield
+      ensure
+        EM.stop
+      end
+    end
+
+    rv
+  end
+end

data/test/support/redis_mock.rb

@@ -0,0 +1,119 @@
+require "socket"
+
+module RedisMock
+  class Server
+    def initialize(options = {}, &block)
+      @server = TCPServer.new(options[:host] || "127.0.0.1", 0)
+      @server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+    end
+
+    def port
+      @server.addr[1]
+    end
+
+    def start(&block)
+      @thread = Thread.new { run(&block) }
+    end
+
+    def shutdown
+      @thread.kill
+    end
+
+    def run
+      begin
+        loop do
+          session = @server.accept
+
+          begin
+            return if yield(session) == :exit
+          ensure
+            session.close
+          end
+        end
+      rescue => ex
+        $stderr.puts "Error running mock server: #{ex.message}"
+        $stderr.puts ex.backtrace
+        retry
+      ensure
+        @server.close
+      end
+    end
+  end
+
+  # Starts a mock Redis server in a thread.
+  #
+  # The server will use the lambda handler passed as argument to handle
+  # connections. For example:
+  #
+  #   handler = lambda { |session| session.close }
+  #   RedisMock.start_with_handler(handler) do
+  #     # Every connection will be closed immediately
+  #   end
+  #
+  def self.start_with_handler(blk, options = {})
+    server = Server.new(options)
+    port = server.port
+
+    begin
+      server.start(&blk)
+      yield(port)
+    ensure
+      server.shutdown
+    end
+  end
+
+  # Starts a mock Redis server in a thread.
+  #
+  # The server will reply with a `+OK` to all commands, but you can
+  # customize it by providing a hash. For example:
+  #
+  #   RedisMock.start(:ping => lambda { "+PONG" }) do |port|
+  #     assert_equal "PONG", Redis.new(:port => port).ping
+  #   end
+  #
+  def self.start(commands, options = {}, &blk)
+    handler = lambda do |session|
+      while line = session.gets
+        argv = Array.new(line[1..-3].to_i) do
+          bytes = session.gets[1..-3].to_i
+          arg = session.read(bytes)
+          session.read(2) # Discard \r\n
+          arg
+        end
+
+        command = argv.shift
+        blk = commands[command.to_sym]
+        blk ||= lambda { |*_| "+OK" }
+
+        response = blk.call(*argv)
+
+        # Convert a nil response to :close
+        response ||= :close
+
+        if response == :exit
+          break :exit
+        elsif response == :close
+          break :close
+        elsif response.is_a?(Array)
+          session.write("*%d\r\n" % response.size)
+
+          response.each do |resp|
+            if resp.is_a?(Array)
+              session.write("*%d\r\n" % resp.size)
+              resp.each do |r|
+                session.write("$%d\r\n%s\r\n" % [r.length, r])
+              end
+            else
+              session.write("$%d\r\n%s\r\n" % [resp.length, resp])
+            end
+          end
+        else
+          session.write(response)
+          session.write("\r\n") unless response.end_with?("\r\n")
+        end
+      end
+    end
+
+    start_with_handler(handler, options, &blk)
+  end
+end

data/test/support/wire/synchrony.rb

@@ -0,0 +1,24 @@
+class Wire < Fiber
+  # We cannot run this fiber explicitly because EM schedules it. Resuming the
+  # current fiber on the next tick to let the reactor do work.
+  def self.pass
+    f = Fiber.current
+    EM.next_tick { f.resume }
+    Fiber.yield
+  end
+
+  def self.sleep(sec)
+    EM::Synchrony.sleep(sec)
+  end
+
+  def initialize(&blk)
+    super
+
+    # Schedule run in next tick
+    EM.next_tick { resume }
+  end
+
+  def join
+    self.class.pass while alive?
+  end
+end

data/test/support/wire/thread.rb

@@ -0,0 +1,5 @@
+class Wire < Thread
+  def self.sleep(sec)
+    Kernel.sleep(sec)
+  end
+end

data/test/synchrony_driver.rb

@@ -0,0 +1,88 @@
+# encoding: UTF-8
+
+require 'em-synchrony'
+require 'em-synchrony/connection_pool'
+
+require 'redis'
+require 'redis/connection/synchrony'
+
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+PORT    = 6381
+OPTIONS = {:port => PORT, :db => 15}
+
+#
+# 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 OPTIONS
+  r.flushdb
+
+  r.rpush "foo", "s1"
+  r.rpush "foo", "s2"
+
+  assert_equal 2, r.llen("foo")
+  assert_equal "s2", r.rpop("foo")
+
+  r.set("foo", "bar")
+
+  assert_equal "bar", r.getset("foo", "baz")
+  assert_equal "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_equal 2, r.llen("foo")
+  assert_equal "s2", r.lpop("foo")
+  assert_equal "s1", r.lpop("foo")
+
+  assert_equal "OK", r.client.call(:quit)
+  assert_equal "PONG", r.ping
+
+
+  rpool = EM::Synchrony::ConnectionPool.new(size: 5) { Redis.new OPTIONS }
+
+  result = rpool.watch 'foo' do |rd|
+    assert_kind_of Redis, rd
+
+    rd.set "foo", "s1"
+    rd.multi do |multi|
+      multi.set "foo", "s2"
+    end
+  end
+
+  assert_equal nil, result
+  assert_equal "s1", rpool.get("foo")
+
+  result = rpool.watch "foo" do |rd|
+    assert_kind_of Redis, rd
+
+    rd.multi do |multi|
+      multi.set "foo", "s3"
+    end
+  end
+
+  assert_equal ["OK"], result
+  assert_equal "s3", rpool.get("foo")
+
+  EM.stop
+end

data/test/test.conf.erb

@@ -0,0 +1,9 @@
+dir <%=        REDIS_DIR %>
+pidfile <%=    REDIS_PID %>
+port 6381
+unixsocket <%= REDIS_SOCKET %>
+timeout 300
+loglevel debug
+logfile <%=    REDIS_LOG %>
+databases 16
+daemonize yes

data/test/thread_safety_test.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestThreadSafety < Test::Unit::TestCase
+
+  include Helper::Client
+
+  driver(:ruby, :hiredis) do
+    def test_thread_safety
+      redis = Redis.new(OPTIONS)
+      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
+  end
+end

data/test/transactions_test.rb

@@ -0,0 +1,264 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestTransactions < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_multi_discard
+    r.multi
+
+    assert_equal "QUEUED", r.set("foo", "1")
+    assert_equal "QUEUED", r.get("foo")
+
+    r.discard
+
+    assert_equal nil, r.get("foo")
+  end
+
+  def test_multi_exec_with_a_block
+    r.multi do |multi|
+      multi.set "foo", "s1"
+    end
+
+    assert_equal "s1", r.get("foo")
+  end
+
+  def test_multi_exec_with_a_block_doesn_t_return_replies_for_multi_and_exec
+    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
+
+  def test_assignment_inside_multi_exec_block
+    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.
+  def test_assignment_inside_multi_exec_block_with_delayed_command_errors
+    assert_raise(Redis::CommandError) 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(Redis::CommandError) { @second.value }
+    assert_raise(Redis::FutureNotReady) { @third.value }
+  end
+
+  def test_assignment_inside_multi_exec_block_with_immediate_command_errors
+    assert_raise(Redis::CommandError) do
+      r.multi do |m|
+        m.doesnt_exist
+        @first = m.sadd("foo", 1)
+        @second = m.sadd("foo", 1)
+      end
+    end
+
+    assert_raise(Redis::FutureNotReady) { @first.value }
+    assert_raise(Redis::FutureNotReady) { @second.value }
+  end
+
+  def test_raise_immediate_errors_in_multi_exec
+    assert_raise(RuntimeError) do
+      r.multi do |multi|
+        multi.set "bar", "s2"
+        raise "Some error"
+        multi.set "baz", "s3"
+      end
+    end
+
+    assert_equal nil, r.get("bar")
+    assert_equal nil, r.get("baz")
+  end
+
+  def test_transformed_replies_as_return_values_for_multi_exec_block
+    info, _ = r.multi do |m|
+      r.info
+    end
+
+    assert info.kind_of?(Hash)
+  end
+
+  def test_transformed_replies_inside_multi_exec_block
+    r.multi do |m|
+      @info = r.info
+    end
+
+    assert @info.value.kind_of?(Hash)
+  end
+
+  def test_raise_command_errors_in_multi_exec
+    assert_raise(Redis::CommandError) 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_equal "s1", r.get("foo")
+  end
+
+  def test_raise_command_errors_when_accessing_futures_after_multi_exec
+    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.
+    err = nil
+    begin
+      @counter.value
+    rescue => err
+    end
+
+    assert err.kind_of?(RuntimeError)
+  end
+
+  def test_multi_with_a_block_yielding_the_client
+    r.multi do |multi|
+      multi.set "foo", "s1"
+    end
+
+    assert_equal "s1", r.get("foo")
+  end
+
+  def test_raise_command_error_when_exec_fails
+    redis_mock(:exec => lambda { |*_| "-ERROR" }) do |redis|
+      assert_raise(Redis::CommandError) do
+        redis.multi do |m|
+          m.set "foo", "s1"
+        end
+      end
+    end
+  end
+
+  def test_watch
+    res = r.watch "foo"
+
+    assert_equal "OK", res
+  end
+
+  def test_watch_with_an_unmodified_key
+    r.watch "foo"
+    r.multi do |multi|
+      multi.set "foo", "s1"
+    end
+
+    assert_equal "s1", r.get("foo")
+  end
+
+  def test_watch_with_an_unmodified_key_passed_as_array
+    r.watch ["foo", "bar"]
+    r.multi do |multi|
+      multi.set "foo", "s1"
+    end
+
+    assert_equal "s1", r.get("foo")
+  end
+
+  def test_watch_with_a_modified_key
+    r.watch "foo"
+    r.set "foo", "s1"
+    res = r.multi do |multi|
+      multi.set "foo", "s2"
+    end
+
+    assert_equal nil, res
+    assert_equal "s1", r.get("foo")
+  end
+
+  def test_watch_with_a_modified_key_passed_as_array
+    r.watch ["foo", "bar"]
+    r.set "foo", "s1"
+    res = r.multi do |multi|
+      multi.set "foo", "s2"
+    end
+
+    assert_equal nil, res
+    assert_equal "s1", r.get("foo")
+  end
+
+  def test_watch_with_a_block_and_an_unmodified_key
+    result = r.watch "foo" do |rd|
+
+      assert_same r, rd
+
+      rd.multi do |multi|
+        multi.set "foo", "s1"
+      end
+    end
+
+    assert_equal ["OK"], result
+    assert_equal "s1", r.get("foo")
+  end
+
+  def test_watch_with_a_block_and_a_modified_key
+    result = r.watch "foo" do |rd|
+
+      assert_same r, rd
+
+      rd.set "foo", "s1"
+      rd.multi do |multi|
+        multi.set "foo", "s2"
+      end
+    end
+
+    assert_equal nil, result
+    assert_equal "s1", r.get("foo")
+  end
+
+  def test_watch_with_a_block_that_raises_an_exception
+    r.set("foo", "s1")
+
+    begin
+      r.watch "foo" do
+        raise "test"
+      end
+    rescue RuntimeError
+    end
+
+    r.set("foo", "s2")
+
+    # If the watch was still set from within the block above, this multi/exec
+    # would fail. This proves that raising an exception above unwatches.
+    r.multi do |multi|
+      multi.set "foo", "s3"
+    end
+
+    assert_equal "s3", r.get("foo")
+  end
+
+  def test_unwatch_with_a_modified_key
+    r.watch "foo"
+    r.set "foo", "s1"
+    r.unwatch
+    r.multi do |multi|
+      multi.set "foo", "s2"
+    end
+
+    assert_equal "s2", r.get("foo")
+  end
+end