remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/redis-3.0.2/test/remote_server_control_commands_test.rb

@@ -0,0 +1,117 @@
+# encoding: UTF-8
+
+require "helper"
+
+class TestRemoteServerControlCommands < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_info
+    keys = [
+     "redis_version",
+     "uptime_in_seconds",
+     "uptime_in_days",
+     "connected_clients",
+     "used_memory",
+     "total_connections_received",
+     "total_commands_processed",
+    ]
+
+    info = r.info
+
+    keys.each do |k|
+      msg = "expected #info to include #{k}"
+      assert info.keys.include?(k), msg
+    end
+  end
+
+  def test_info_commandstats
+    return if version < "2.5.7"
+
+    r.config(:resetstat)
+    r.ping
+
+    result = r.info(:commandstats)
+    assert_equal "1", result["ping"]["calls"]
+  end
+
+  def test_monitor_redis_lt_2_5_0
+    return unless version < "2.5.0"
+
+    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
+
+  def test_monitor_redis_gte_2_5_0
+    return unless version >= "2.5.0"
+
+    log = []
+
+    wire = Wire.new do
+      Redis.new(OPTIONS).monitor do |line|
+        log << line
+        break if line =~ /set/
+      end
+    end
+
+    Wire.pass while log.empty? # Faster than sleep
+
+    r.set "foo", "s1"
+
+    wire.join
+
+    assert log[-1] =~ /\b15\b.* "set" "foo" "s1"/
+  end
+
+  def test_monitor_returns_value_for_break
+    result = r.monitor do |line|
+      break line
+    end
+
+    assert_equal result, "OK"
+  end
+
+  def test_echo
+    assert_equal "foo bar baz\n", r.echo("foo bar baz\n")
+  end
+
+  def test_debug
+    r.set "foo", "s1"
+
+    assert r.debug(:object, "foo").kind_of?(String)
+  end
+
+  def test_object
+    r.lpush "list", "value"
+
+    assert_equal r.object(:refcount, "list"), 1
+    assert_equal r.object(:encoding, "list"), "ziplist"
+    assert r.object(:idletime, "list").kind_of?(Fixnum)
+  end
+
+  def test_sync
+    redis_mock(:sync => lambda { "+OK" }) do |redis|
+      assert_equal "OK", redis.sync
+    end
+  end
+
+  def test_slowlog
+    r.slowlog(:reset)
+    result = r.slowlog(:len)
+    assert_equal result, 0
+  end
+end

data/vendor/bundle/gems/redis-3.0.2/test/scripting_test.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+require "helper"
+
+class TestScripting < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def to_sha(script)
+    r.script(:load, script)
+  end
+
+  def test_script_exists
+    return if version < "2.5.9" # 2.6-rc1
+
+    a = to_sha("return 1")
+    b = a.succ
+
+    assert_equal true, r.script(:exists, a)
+    assert_equal false, r.script(:exists, b)
+    assert_equal [true], r.script(:exists, [a])
+    assert_equal [false], r.script(:exists, [b])
+    assert_equal [true, false], r.script(:exists, [a, b])
+  end
+
+  def test_script_flush
+    return if version < "2.5.9" # 2.6-rc1
+
+    sha = to_sha("return 1")
+    assert r.script(:exists, sha)
+    assert_equal "OK", r.script(:flush)
+    assert !r.script(:exists, sha)
+  end
+
+  def test_script_kill
+    return if version < "2.5.9" # 2.6-rc1
+
+    redis_mock(:script => lambda { |arg| "+#{arg.upcase}" }) do |redis|
+      assert_equal "KILL", redis.script(:kill)
+    end
+  end
+
+  def test_eval
+    return if version < "2.5.9" # 2.6-rc1
+
+    assert_equal 0, r.eval("return #KEYS")
+    assert_equal 0, r.eval("return #ARGV")
+    assert_equal ["k1", "k2"], r.eval("return KEYS", ["k1", "k2"])
+    assert_equal ["a1", "a2"], r.eval("return ARGV", [], ["a1", "a2"])
+  end
+
+  def test_eval_with_options_hash
+    return if version < "2.5.9" # 2.6-rc1
+
+    assert_equal 0, r.eval("return #KEYS", {})
+    assert_equal 0, r.eval("return #ARGV", {})
+    assert_equal ["k1", "k2"], r.eval("return KEYS", { :keys => ["k1", "k2"] })
+    assert_equal ["a1", "a2"], r.eval("return ARGV", { :argv => ["a1", "a2"] })
+  end
+
+  def test_evalsha
+    return if version < "2.5.9" # 2.6-rc1
+
+    assert_equal 0, r.evalsha(to_sha("return #KEYS"))
+    assert_equal 0, r.evalsha(to_sha("return #ARGV"))
+    assert_equal ["k1", "k2"], r.evalsha(to_sha("return KEYS"), ["k1", "k2"])
+    assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), [], ["a1", "a2"])
+  end
+
+  def test_evalsha_with_options_hash
+    return if version < "2.5.9" # 2.6-rc1
+
+    assert_equal 0, r.evalsha(to_sha("return #KEYS"), {})
+    assert_equal 0, r.evalsha(to_sha("return #ARGV"), {})
+    assert_equal ["k1", "k2"], r.evalsha(to_sha("return KEYS"), { :keys => ["k1", "k2"] })
+    assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), { :argv => ["a1", "a2"] })
+  end
+end

data/vendor/bundle/gems/redis-3.0.2/test/sorting_test.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+require "helper"
+
+class TestSorting < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_sort
+    r.set("foo:1", "s1")
+    r.set("foo:2", "s2")
+
+    r.rpush("bar", "1")
+    r.rpush("bar", "2")
+
+    assert_equal ["s1"], r.sort("bar", :get => "foo:*", :limit => [0, 1])
+    assert_equal ["s2"], r.sort("bar", :get => "foo:*", :limit => [0, 1], :order => "desc alpha")
+  end
+
+  def test_sort_with_an_array_of_gets
+    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_equal [["s1a", "s1b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1])
+    assert_equal [["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :limit => [0, 1], :order => "desc alpha")
+    assert_equal [["s1a", "s1b"], ["s2a", "s2b"]], r.sort("bar", :get => ["foo:*:a", "foo:*:b"])
+  end
+
+  def test_sort_with_store
+    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_equal ["s1", "s2"], r.lrange("baz", 0, -1)
+  end
+end

data/vendor/bundle/gems/redis-3.0.2/test/support/connection/hiredis.rb

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

data/vendor/bundle/gems/redis-3.0.2/test/support/connection/ruby.rb

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

data/vendor/bundle/gems/redis-3.0.2/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/vendor/bundle/gems/redis-3.0.2/test/support/redis_mock.rb

@@ -0,0 +1,110 @@
+require "socket"
+
+module RedisMock
+  class Server
+    VERBOSE = false
+
+    def initialize(port, &block)
+      @server = TCPServer.new("127.0.0.1", port)
+      @server.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+    end
+
+    def start(&block)
+      @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
+          return if yield(session) == :exit
+        ensure
+          session.close
+        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
+
+  MOCK_PORT = 6382
+
+  # 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)
+    server = Server.new(MOCK_PORT)
+
+    begin
+      server.start(&blk)
+
+      yield(MOCK_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
+  #     assert_equal "PONG", Redis.new(:port => MOCK_PORT).ping
+  #   end
+  #
+  def self.start(commands = {}, &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
+        else
+          session.write(response)
+          session.write("\r\n") unless response.end_with?("\r\n")
+        end
+      end
+    end
+
+    start_with_handler(handler, &blk)
+  end
+end

data/vendor/bundle/gems/redis-3.0.2/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/vendor/bundle/gems/redis-3.0.2/test/support/wire/thread.rb

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

data/vendor/bundle/gems/redis-3.0.2/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/vendor/bundle/gems/redis-3.0.2/test/test.conf

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

data/vendor/bundle/gems/redis-3.0.2/test/thread_safety_test.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+require "helper"
+
+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