redis 3.0.0 → 4.2.2

data/test/scripting_test.rb

@@ -1,78 +0,0 @@
-# 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/test/sorting_test.rb

@@ -1,45 +0,0 @@
-# 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/test/support/connection/hiredis.rb

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

data/test/support/connection/ruby.rb

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

data/test/support/connection/synchrony.rb

@@ -1,17 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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
-          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
-
-  MOCK_PORT = 6382
-
-  # 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 = {})
-    server = Server.new(MOCK_PORT)
-
-    begin
-      server.start do |command, *args|
-        (commands[command.to_sym] || lambda { |*_| "+OK" }).call(*args)
-      end
-
-      yield(MOCK_PORT)
-
-    ensure
-      server.shutdown
-    end
-  end
-end

data/test/support/wire/synchrony.rb

@@ -1,24 +0,0 @@
-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

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

data/test/synchrony_driver.rb

@@ -1,57 +0,0 @@
-# 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_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
-
-  EM.stop
-end

data/test/test.conf

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

data/test/thread_safety_test.rb

@@ -1,32 +0,0 @@
-# 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

data/test/transactions_test.rb

@@ -1,244 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-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)
-        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
-
-  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_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
-      r.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
-      r.set "foo", "s1"
-      r.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