redis 4.0.1 → 4.1.0

data/test/distributed_test.rb

@@ -1,56 +0,0 @@
-require_relative "helper"
-
-class TestDistributed < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_handle_multiple_servers
-    @r = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
-
-    100.times do |idx|
-      @r.set(idx.to_s, "foo#{idx}")
-    end
-
-    100.times do |idx|
-      assert_equal "foo#{idx}", @r.get(idx.to_s)
-    end
-
-    assert_equal "0", @r.keys("*").sort.first
-    assert_equal "string", @r.type("1")
-  end
-
-  def test_add_nodes
-    logger = Logger.new("/dev/null")
-
-    @r = Redis::Distributed.new NODES, :logger => logger, :timeout => 10
-
-    assert_equal "127.0.0.1", @r.nodes[0]._client.host
-    assert_equal PORT, @r.nodes[0]._client.port
-    assert_equal 15, @r.nodes[0]._client.db
-    assert_equal 10, @r.nodes[0]._client.timeout
-    assert_equal logger, @r.nodes[0]._client.logger
-
-    @r.add_node("redis://127.0.0.1:6380/14")
-
-    assert_equal "127.0.0.1", @r.nodes[1]._client.host
-    assert_equal 6380, @r.nodes[1]._client.port
-    assert_equal 14, @r.nodes[1]._client.db
-    assert_equal 10, @r.nodes[1]._client.timeout
-    assert_equal logger, @r.nodes[1]._client.logger
-  end
-
-  def test_pipelining_commands_cannot_be_distributed
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.pipelined do
-        r.lpush "foo", "s1"
-        r.lpush "foo", "s2"
-      end
-    end
-  end
-
-  def test_unknown_commands_does_not_work_by_default
-    assert_raise NoMethodError do
-      r.not_yet_implemented_command
-    end
-  end
-end

data/test/distributed_transactions_test.rb

@@ -1,30 +0,0 @@
-require_relative "helper"
-
-class TestDistributedTransactions < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_multi_discard
-    @foo = nil
-
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.multi { @foo = 1 }
-    end
-
-    assert_equal nil, @foo
-
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.discard
-    end
-  end
-
-  def test_watch_unwatch
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.watch("foo")
-    end
-
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.unwatch
-    end
-  end
-end

data/test/encoding_test.rb

@@ -1,14 +0,0 @@
-require_relative "helper"
-
-class TestEncoding < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_returns_properly_encoded_strings
-    with_external_encoding("UTF-8") do
-      r.set "foo", "שלום"
-
-      assert_equal "Shalom שלום", "Shalom " + r.get("foo")
-    end
-  end
-end

data/test/error_replies_test.rb

@@ -1,57 +0,0 @@
-require_relative "helper"
-
-class TestErrorReplies < Test::Unit::TestCase
-
-  include Helper::Client
-
-  # Every test shouldn't disconnect from the server. Also, when error replies are
-  # in play, the protocol should never get into an invalid state where there are
-  # pending replies in the connection. Calling INFO after every test ensures that
-  # the protocol is still in a valid state.
-  def with_reconnection_check
-    before = r.info["total_connections_received"]
-    yield(r)
-    after = r.info["total_connections_received"]
-  ensure
-    assert_equal before, after
-  end
-
-  def test_error_reply_for_single_command
-    with_reconnection_check do
-      begin
-        r.unknown_command
-      rescue => ex
-      ensure
-        assert ex.message =~ /unknown command/i
-      end
-    end
-  end
-
-  def test_raise_first_error_reply_in_pipeline
-    with_reconnection_check do
-      begin
-        r.pipelined do
-          r.set("foo", "s1")
-          r.incr("foo") # not an integer
-          r.lpush("foo", "value") # wrong kind of value
-        end
-      rescue => ex
-      ensure
-        assert ex.message =~ /not an integer/i
-      end
-    end
-  end
-
-  def test_recover_from_raise_in__call_loop
-    with_reconnection_check do
-      begin
-        r._client.call_loop([:invalid_monitor]) do
-          assert false # Should never be executed
-        end
-      rescue => ex
-      ensure
-        assert ex.message =~ /unknown command/i
-      end
-    end
-  end
-end

data/test/fork_safety_test.rb

@@ -1,60 +0,0 @@
-require_relative "helper"
-
-class TestForkSafety < Test::Unit::TestCase
-
-  include Helper::Client
-
-  driver(:ruby, :hiredis) do
-    def test_fork_safety
-      redis = Redis.new(OPTIONS)
-      redis.set "foo", 1
-
-      child_pid = fork do
-        begin
-          # InheritedError triggers a reconnect,
-          # so we need to disable reconnects to force
-          # the exception bubble up
-          redis.without_reconnect do
-            redis.set "foo", 2
-          end
-        rescue Redis::InheritedError
-          exit 127
-        end
-      end
-
-      _, status = Process.wait2(child_pid)
-
-      assert_equal 127, status.exitstatus
-      assert_equal "1", redis.get("foo")
-
-    rescue NotImplementedError => error
-      raise unless error.message =~ /fork is not available/
-    end
-
-    def test_fork_safety_with_enabled_inherited_socket
-      redis = Redis.new(OPTIONS.merge(:inherit_socket => true))
-      redis.set "foo", 1
-
-      child_pid = fork do
-        begin
-          # InheritedError triggers a reconnect,
-          # so we need to disable reconnects to force
-          # the exception bubble up
-          redis.without_reconnect do
-            redis.set "foo", 2
-          end
-        rescue Redis::InheritedError
-          exit 127
-        end
-      end
-
-      _, status = Process.wait2(child_pid)
-
-      assert_equal 0, status.exitstatus
-      assert_equal "2", redis.get("foo")
-
-    rescue NotImplementedError => error
-      raise unless error.message =~ /fork is not available/
-    end
-  end
-end

data/test/helper.rb

@@ -1,201 +0,0 @@
-require "test/unit"
-require "logger"
-require "stringio"
-
-$VERBOSE = true
-
-ENV["DRIVER"] ||= "ruby"
-
-require_relative "../lib/redis"
-require_relative "../lib/redis/distributed"
-require_relative "../lib/redis/connection/#{ENV["DRIVER"]}"
-
-require_relative "support/redis_mock"
-require_relative "support/connection/#{ENV["DRIVER"]}"
-
-PORT    = 6381
-OPTIONS = {:port => PORT, :db => 15, :timeout => Float(ENV["TIMEOUT"] || 0.1)}
-NODES   = ["redis://127.0.0.1:#{PORT}/15"]
-
-def init(redis)
-  begin
-    redis.select 14
-    redis.flushdb
-    redis.select 15
-    redis.flushdb
-    redis
-  rescue Redis::CannotConnectError
-    puts <<-EOS
-
-      Cannot connect to Redis.
-
-      Make sure Redis is running on localhost, port #{PORT}.
-      This testing suite connects to the database 15.
-
-      Try this once:
-
-        $ make clean
-
-      Then run the build again:
-
-        $ make
-
-    EOS
-    exit 1
-  end
-end
-
-def driver(*drivers, &blk)
-  if drivers.map(&:to_s).include?(ENV["DRIVER"])
-    class_eval(&blk)
-  end
-end
-
-module Helper
-
-  def run(runner)
-    if respond_to?(:around)
-      around { super(runner) }
-    else
-      super
-    end
-  end
-
-  def silent
-    verbose, $VERBOSE = $VERBOSE, false
-
-    begin
-      yield
-    ensure
-      $VERBOSE = verbose
-    end
-  end
-
-  def with_external_encoding(encoding)
-    original_encoding = Encoding.default_external
-
-    begin
-      silent { Encoding.default_external = Encoding.find(encoding) }
-      yield
-    ensure
-      silent { Encoding.default_external = original_encoding }
-    end
-  end
-
-  class Version
-
-    include Comparable
-
-    attr :parts
-
-    def initialize(v)
-      case v
-      when Version
-        @parts = v.parts
-      else
-        @parts = v.to_s.split(".")
-      end
-    end
-
-    def <=>(other)
-      other = Version.new(other)
-      length = [self.parts.length, other.parts.length].max
-      length.times do |i|
-        a, b = self.parts[i], other.parts[i]
-
-        return -1 if a.nil?
-        return +1 if b.nil?
-        return a.to_i <=> b.to_i if a != b
-      end
-
-      0
-    end
-  end
-
-  module Generic
-
-    include Helper
-
-    attr_reader :log
-    attr_reader :redis
-
-    alias :r :redis
-
-    def setup
-      @log = StringIO.new
-      @redis = init _new_client
-
-      # Run GC to make sure orphaned connections are closed.
-      GC.start
-    end
-
-    def teardown
-      @redis.quit if @redis
-    end
-
-    def redis_mock(commands, options = {}, &blk)
-      RedisMock.start(commands, options) do |port|
-        yield _new_client(options.merge(:port => port))
-      end
-    end
-
-    def redis_mock_with_handler(handler, options = {}, &blk)
-      RedisMock.start_with_handler(handler, options) do |port|
-        yield _new_client(options.merge(:port => port))
-      end
-    end
-
-    def assert_in_range(range, value)
-      assert range.include?(value), "expected #{value} to be in #{range.inspect}"
-    end
-
-    def target_version(target)
-      if version < target
-        skip("Requires Redis > #{target}") if respond_to?(:skip)
-      else
-        yield
-      end
-    end
-  end
-
-  module Client
-
-    include Generic
-
-    def version
-      Version.new(redis.info["redis_version"])
-    end
-
-    private
-
-    def _format_options(options)
-      OPTIONS.merge(:logger => ::Logger.new(@log)).merge(options)
-    end
-
-    def _new_client(options = {})
-      Redis.new(_format_options(options).merge(:driver => ENV["DRIVER"]))
-    end
-  end
-
-  module Distributed
-
-    include Generic
-
-    def version
-      Version.new(redis.info.first["redis_version"])
-    end
-
-    private
-
-    def _format_options(options)
-      {
-        :timeout => OPTIONS[:timeout],
-        :logger => ::Logger.new(@log),
-      }.merge(options)
-    end
-
-    def _new_client(options = {})
-      Redis::Distributed.new(NODES, _format_options(options).merge(:driver => ENV["conn"]))
-    end
-  end
-end

data/test/helper_test.rb

@@ -1,22 +0,0 @@
-require_relative "helper"
-
-class TestHelper < Test::Unit::TestCase
-
-  include Helper
-
-  def test_version_comparison
-    v = Version.new("2.0.1")
-
-    assert v > "1"
-    assert v > "2"
-    assert v < "3"
-    assert v < "10"
-
-    assert v < "2.1"
-    assert v < "2.0.2"
-    assert v < "2.0.1.1"
-    assert v < "2.0.10"
-
-    assert v == "2.0.1"
-  end
-end