redis 3.2.0 → 4.6.0

data/test/distributed_publish_subscribe_test.rb

@@ -1,92 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-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,66 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class TestDistributedRemoteServerControlCommands < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def test_info
-    keys = [
-     "redis_version",
-     "uptime_in_seconds",
-     "uptime_in_days",
-     "connected_clients",
-     "used_memory",
-     "total_connections_received",
-     "total_commands_processed",
-    ]
-
-    infos = r.info
-
-    infos.each do |info|
-      keys.each do |k|
-        msg = "expected #info to include #{k}"
-        assert info.keys.include?(k), msg
-      end
-    end
-  end
-
-  def test_info_commandstats
-    target_version "2.5.7" do
-      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
-  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
-    target_version "2.5.4" do
-      # 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
-end

data/test/distributed_scripting_test.rb

@@ -1,102 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class TestDistributedScripting < Test::Unit::TestCase
-
-  include Helper::Distributed
-
-  def to_sha(script)
-    r.script(:load, script).first
-  end
-
-  def test_script_exists
-    target_version "2.5.9" do # 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
-  end
-
-  def test_script_flush
-    target_version "2.5.9" do # 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
-  end
-
-  def test_script_kill
-    target_version "2.5.9" do # 2.6-rc1
-      redis_mock(:script => lambda { |arg| "+#{arg.upcase}" }) do |redis|
-        assert_equal ["KILL"], redis.script(:kill)
-      end
-    end
-  end
-
-  def test_eval
-    target_version "2.5.9" do # 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
-  end
-
-  def test_eval_with_options_hash
-    target_version "2.5.9" do # 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
-  end
-
-  def test_evalsha
-    target_version "2.5.9" do # 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
-  end
-
-  def test_evalsha_with_options_hash
-    target_version "2.5.9" do # 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
-end

data/test/distributed_sorting_test.rb

@@ -1,20 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-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 File.expand_path("helper", File.dirname(__FILE__))
-
-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,32 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-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 File.expand_path("helper", File.dirname(__FILE__))
-
-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 File.expand_path("helper", File.dirname(__FILE__))
-
-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,65 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-class TestForkSafety < Test::Unit::TestCase
-
-  include Helper::Client
-  include Helper::Skipable
-
-  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/
-      return skip(error.message)
-    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/
-      return skip(error.message)
-    end
-  end
-end