redis 3.0.0 → 4.5.0

data/test/distributed_key_tags_test.rb

@@ -1,52 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestDistributedKeyTags < Test::Unit::TestCase
-
-  include Helper
-  include Helper::Distributed
-
-  def test_hashes_consistently
-    r1 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
-    r2 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
-    r3 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
-
-    assert_equal r1.node_for("foo").id, r2.node_for("foo").id
-    assert_equal r1.node_for("foo").id, r3.node_for("foo").id
-  end
-
-  def test_allows_clustering_of_keys
-    r = Redis::Distributed.new(NODES)
-    r.add_node("redis://localhost:#{PORT}/14")
-    r.flushdb
-
-    100.times do |i|
-      r.set "{foo}users:#{i}", i
-    end
-
-    assert_equal [0, 100], r.nodes.map { |node| node.keys.size }
-  end
-
-  def test_distributes_keys_if_no_clustering_is_used
-    r.add_node("redis://localhost:#{PORT}/14")
-    r.flushdb
-
-    r.set "users:1", 1
-    r.set "users:4", 4
-
-    assert_equal [1, 1], r.nodes.map { |node| node.keys.size }
-  end
-
-  def test_allows_passing_a_custom_tag_extractor
-    r = Redis::Distributed.new(NODES, :tag => /^(.+?):/)
-    r.add_node("redis://localhost:#{PORT}/14")
-    r.flushdb
-
-    100.times do |i|
-      r.set "foo:users:#{i}", i
-    end
-
-    assert_equal [0, 100], r.nodes.map { |node| node.keys.size }
-  end
-end

data/test/distributed_persistence_control_commands_test.rb

@@ -1,26 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestDistributedPersistenceControlCommands < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_save
-    redis_mock(:save => lambda { "+SAVE" }) do |redis|
-      assert_equal ["SAVE"], redis.save
-    end
-  end
-
-  def test_bgsave
-    redis_mock(:bgsave => lambda { "+BGSAVE" }) do |redis|
-      assert_equal ["BGSAVE"], redis.bgsave
-    end
-  end
-
-  def test_lastsave
-    redis_mock(:lastsave => lambda { "+LASTSAVE" }) do |redis|
-      assert_equal ["LASTSAVE"], redis.lastsave
-    end
-  end
-end

data/test/distributed_publish_subscribe_test.rb

@@ -1,92 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestDistributedPublishSubscribe < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_subscribe_and_unsubscribe
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.subscribe("foo", "bar") { }
-    end
-
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.subscribe("{qux}foo", "bar") { }
-    end
-  end
-
-  def test_subscribe_and_unsubscribe_with_tags
-    @subscribed = false
-    @unsubscribed = false
-
-    wire = Wire.new do
-      r.subscribe("foo") do |on|
-        on.subscribe do |channel, total|
-          @subscribed = true
-          @t1 = total
-        end
-
-        on.message do |channel, message|
-          if message == "s1"
-            r.unsubscribe
-            @message = message
-          end
-        end
-
-        on.unsubscribe do |channel, total|
-          @unsubscribed = true
-          @t2 = total
-        end
-      end
-    end
-
-    # Wait until the subscription is active before publishing
-    Wire.pass while !@subscribed
-
-    Redis::Distributed.new(NODES).publish("foo", "s1")
-
-    wire.join
-
-    assert @subscribed
-    assert_equal 1, @t1
-    assert @unsubscribed
-    assert_equal 0, @t2
-    assert_equal "s1", @message
-  end
-
-  def test_subscribe_within_subscribe
-    @channels = []
-
-    wire = Wire.new do
-      r.subscribe("foo") do |on|
-        on.subscribe do |channel, total|
-          @channels << channel
-
-          r.subscribe("bar") if channel == "foo"
-          r.unsubscribe if channel == "bar"
-        end
-      end
-    end
-
-    wire.join
-
-    assert_equal ["foo", "bar"], @channels
-  end
-
-  def test_other_commands_within_a_subscribe
-    assert_raise Redis::CommandError do
-      r.subscribe("foo") do |on|
-        on.subscribe do |channel, total|
-          r.set("bar", "s2")
-        end
-      end
-    end
-  end
-
-  def test_subscribe_without_a_block
-    assert_raise LocalJumpError do
-      r.subscribe("foo")
-    end
-  end
-end

data/test/distributed_remote_server_control_commands_test.rb

@@ -1,53 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestDistributedRemoteServerControlCommands < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_info
-    %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|
-      r.info.each do |info|
-        assert info.keys.include?(x)
-      end
-    end
-  end
-
-  def test_info_commandstats
-    return if version < "2.9.0"
-
-    r.nodes.each { |n| n.config(:resetstat) }
-    r.ping # Executed on every node
-
-    r.info(:commandstats).each do |info|
-      assert_equal "1", info["ping"]["calls"]
-    end
-  end
-
-  def test_monitor
-    begin
-      r.monitor
-    rescue Exception => ex
-    ensure
-      assert ex.kind_of?(NotImplementedError)
-    end
-  end
-
-  def test_echo
-    assert_equal ["foo bar baz\n"], r.echo("foo bar baz\n")
-  end
-
-  def test_time
-    return if version < "2.5.4"
-
-    # Test that the difference between the time that Ruby reports and the time
-    # that Redis reports is minimal (prevents the test from being racy).
-    r.time.each do |rv|
-      redis_usec = rv[0] * 1_000_000 + rv[1]
-      ruby_usec = Integer(Time.now.to_f * 1_000_000)
-
-      assert 500_000 > (ruby_usec - redis_usec).abs
-    end
-  end
-end

data/test/distributed_scripting_test.rb

@@ -1,102 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestDistributedScripting < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def to_sha(script)
-    r.script(:load, script).first
-  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).first
-    assert_equal ["OK"], r.script(:flush)
-    assert !r.script(:exists, sha).first
-  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_raises(Redis::Distributed::CannotDistribute) do
-      r.eval("return #KEYS")
-    end
-
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.eval("return KEYS", ["k1", "k2"])
-    end
-
-    assert_equal ["k1"], r.eval("return KEYS", ["k1"])
-    assert_equal ["a1", "a2"], r.eval("return ARGV", ["k1"], ["a1", "a2"])
-  end
-
-  def test_eval_with_options_hash
-    return if version < "2.5.9" # 2.6-rc1
-
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.eval("return #KEYS", {})
-    end
-
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.eval("return KEYS", { :keys => ["k1", "k2"] })
-    end
-
-    assert_equal ["k1"], r.eval("return KEYS", { :keys => ["k1"] })
-    assert_equal ["a1", "a2"], r.eval("return ARGV", { :keys => ["k1"], :argv => ["a1", "a2"] })
-  end
-
-  def test_evalsha
-    return if version < "2.5.9" # 2.6-rc1
-
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.evalsha(to_sha("return #KEYS"))
-    end
-
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.evalsha(to_sha("return KEYS"), ["k1", "k2"])
-    end
-
-    assert_equal ["k1"], r.evalsha(to_sha("return KEYS"), ["k1"])
-    assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), ["k1"], ["a1", "a2"])
-  end
-
-  def test_evalsha_with_options_hash
-    return if version < "2.5.9" # 2.6-rc1
-
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.evalsha(to_sha("return #KEYS"), {})
-    end
-
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.evalsha(to_sha("return KEYS"), { :keys => ["k1", "k2"] })
-    end
-
-    assert_equal ["k1"], r.evalsha(to_sha("return KEYS"), { :keys => ["k1"] })
-    assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), { :keys => ["k1"], :argv => ["a1", "a2"] })
-  end
-end

data/test/distributed_sorting_test.rb

@@ -1,20 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestDistributedSorting < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_sort
-    assert_raise(Redis::Distributed::CannotDistribute) do
-      r.set("foo:1", "s1")
-      r.set("foo:2", "s2")
-
-      r.rpush("bar", "1")
-      r.rpush("bar", "2")
-
-      r.sort("bar", :get => "foo:*", :limit => [0, 1])
-    end
-  end
-end

data/test/distributed_test.rb

@@ -1,58 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestDistributed < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_handle_multiple_servers
-    @r = Redis::Distributed.new ["redis://localhost:#{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://localhost:6380/14")
-
-    assert_equal "localhost", @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,32 +0,0 @@
-# encoding: UTF-8
-
-require "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,18 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestEncoding < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_returns_properly_encoded_strings
-    if defined?(Encoding)
-      with_external_encoding("UTF-8") do
-        r.set "foo", "שלום"
-
-        assert_equal "Shalom שלום", "Shalom " + r.get("foo")
-      end
-    end
-  end
-end

data/test/error_replies_test.rb

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

@@ -1,188 +0,0 @@
-$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
-
-require "test/unit"
-require "logger"
-require "stringio"
-
-begin
-  require "ruby-debug"
-rescue LoadError
-end
-
-$VERBOSE = true
-
-ENV["conn"] ||= "ruby"
-
-require "redis"
-require "redis/distributed"
-require "redis/connection/#{ENV["conn"]}"
-
-require "support/redis_mock"
-require "support/connection/#{ENV["conn"]}"
-
-PORT    = 6381
-OPTIONS = {:port => PORT, :db => 15, :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.
-
-      To install redis:
-        visit <http://redis.io/download/>.
-
-      To start the server:
-        rake start
-
-      To stop the server:
-        rake stop
-
-    EOS
-    exit 1
-  end
-end
-
-def driver(*drivers, &blk)
-  if drivers.map(&:to_s).include?(ENV["conn"])
-    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 <=> b 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
-    end
-
-    def teardown
-      @redis.quit if @redis
-    end
-
-    def redis_mock(commands, options = {}, &blk)
-      RedisMock.start(commands) do |port|
-        yield _new_client(options.merge(:port => port))
-      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))
-    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))
-    end
-  end
-end