redis 4.1.0.beta1 → 4.1.0

data/test/blocking_commands_test.rb

@@ -1,40 +0,0 @@
-require_relative "helper"
-require_relative "lint/blocking_commands"
-
-class TestBlockingCommands < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::BlockingCommands
-
-  def assert_takes_longer_than_client_timeout
-    timeout = OPTIONS[:timeout]
-    delay = timeout * 2
-
-    mock(:delay => delay) do |r|
-      t1 = Time.now
-      yield(r)
-      t2 = Time.now
-
-      assert timeout == r._client.timeout
-      assert delay <= (t2 - t1)
-    end
-  end
-
-  def test_blpop_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal ["foo", "0"], r.blpop("foo")
-    end
-  end
-
-  def test_brpop_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal ["foo", "0"], r.brpop("foo")
-    end
-  end
-
-  def test_brpoplpush_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal "0", r.brpoplpush("foo", "bar")
-    end
-  end
-end

data/test/client_test.rb

@@ -1,76 +0,0 @@
-require_relative "helper"
-
-class TestClient < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_call
-    result = r.call("PING")
-    assert_equal result, "PONG"
-  end
-
-  def test_call_with_arguments
-    result = r.call("SET", "foo", "bar")
-    assert_equal result, "OK"
-  end
-
-  def test_call_integers
-    result = r.call("INCR", "foo")
-    assert_equal result, 1
-  end
-
-  def test_call_raise
-    assert_raises(Redis::CommandError) do
-      r.call("INCR")
-    end
-  end
-
-  def test_queue_commit
-    r.queue("SET", "foo", "bar")
-    r.queue("GET", "foo")
-    result = r.commit
-
-    assert_equal result, ["OK", "bar"]
-  end
-
-  def test_commit_raise
-    r.queue("SET", "foo", "bar")
-    r.queue("INCR")
-
-    assert_raise(Redis::CommandError) do
-      r.commit
-    end
-  end
-
-  def test_queue_after_error
-    r.queue("SET", "foo", "bar")
-    r.queue("INCR")
-
-    assert_raise(Redis::CommandError) do
-      r.commit
-    end
-
-    r.queue("SET",  "foo", "bar")
-    r.queue("INCR", "baz")
-    result = r.commit
-
-    assert_equal result, ["OK", 1]
-  end
-
-  def test_client_with_custom_connector
-    custom_connector = Class.new(Redis::Client::Connector) do
-      def resolve
-        @options[:host] = '127.0.0.5'
-        @options[:port] = '999'
-        @options
-      end
-    end
-
-    assert_raise_message(
-      'Error connecting to Redis on 127.0.0.5:999 (Errno::ECONNREFUSED)'
-    ) do
-      new_redis = _new_client(connector: custom_connector)
-      new_redis.ping
-    end
-  end
-end

data/test/cluster_abnormal_state_test.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_abnormal_state_test.rb
-class TestClusterAbnormalState < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_the_state_of_cluster_down
-    redis_cluster_down do
-      assert_raise(Redis::CommandError, 'CLUSTERDOWN Hash slot not served') do
-        redis.set('key1', 1)
-      end
-
-      assert_equal 'fail', redis.cluster(:info).fetch('cluster_state')
-    end
-  end
-
-  def test_the_state_of_cluster_failover
-    redis_cluster_failover do
-      100.times do |i|
-        assert_equal 'OK', r.set("key#{i}", i)
-      end
-
-      100.times do |i|
-        assert_equal i.to_s, r.get("key#{i}")
-      end
-
-      assert_equal 'ok', redis.cluster(:info).fetch('cluster_state')
-    end
-  end
-
-  def test_raising_error_when_nodes_are_not_cluster_mode
-    assert_raise(Redis::CannotConnectError, 'Redis client could not connect to any cluster nodes') do
-      build_another_client(cluster: %W[redis://127.0.0.1:#{PORT}])
-    end
-  end
-end

data/test/cluster_blocking_commands_test.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require_relative 'lint/blocking_commands'
-
-# ruby -w -Itest test/cluster_blocking_commands_test.rb
-class TestClusterBlockingCommands < Test::Unit::TestCase
-  include Helper::Cluster
-  include Lint::BlockingCommands
-
-  def mock(options = {}, &blk)
-    commands = build_mock_commands(options)
-    redis_cluster_mock(commands, &blk)
-  end
-end

data/test/cluster_client_internals_test.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_internals_test.rb
-class TestClusterClientInternals < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_handle_multiple_servers
-    100.times { |i| redis.set(i.to_s, "hogehoge#{i}") }
-    100.times { |i| assert_equal "hogehoge#{i}", redis.get(i.to_s) }
-  end
-
-  def test_info_of_cluster_mode_is_enabled
-    assert_equal '1', redis.info['cluster_enabled']
-  end
-
-  def test_unknown_commands_does_not_work_by_default
-    assert_raise(Redis::CommandError) do
-      redis.not_yet_implemented_command('boo', 'foo')
-    end
-  end
-
-  def test_with_reconnect
-    assert_equal('Hello World', redis.with_reconnect { 'Hello World' })
-  end
-
-  def test_without_reconnect
-    assert_equal('Hello World', redis.without_reconnect { 'Hello World' })
-  end
-
-  def test_connected?
-    assert_equal true, redis.connected?
-  end
-
-  def test_close
-    assert_equal true, redis.close
-  end
-
-  def test_disconnect!
-    assert_equal true, redis.disconnect!
-  end
-
-  def test_asking
-    assert_equal 'OK', redis.asking
-  end
-
-  def test_id
-    expected = 'redis://127.0.0.1:7000/0 '\
-               'redis://127.0.0.1:7001/0 '\
-               'redis://127.0.0.1:7002/0'
-    assert_equal expected, redis.id
-  end
-
-  def test_inspect
-    expected = "#<Redis client v#{Redis::VERSION} for "\
-               'redis://127.0.0.1:7000/0 '\
-               'redis://127.0.0.1:7001/0 '\
-               'redis://127.0.0.1:7002/0>'
-
-    assert_equal expected, redis.inspect
-  end
-
-  def test_dup
-    assert_instance_of Redis, redis.dup
-  end
-
-  def test_connection
-    expected = [
-      { host: '127.0.0.1', port: 7000, db: 0, id: 'redis://127.0.0.1:7000/0', location: '127.0.0.1:7000' },
-      { host: '127.0.0.1', port: 7001, db: 0, id: 'redis://127.0.0.1:7001/0', location: '127.0.0.1:7001' },
-      { host: '127.0.0.1', port: 7002, db: 0, id: 'redis://127.0.0.1:7002/0', location: '127.0.0.1:7002' }
-    ]
-
-    assert_equal expected, redis.connection
-  end
-end

data/test/cluster_client_key_hash_tags_test.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_key_hash_tags_test.rb
-class TestClusterClientKeyHashTags < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def build_described_class
-    option = Redis::Cluster::Option.new(cluster: ['redis://127.0.0.1:7000'])
-    node = Redis::Cluster::Node.new(option.per_node_key)
-    details = Redis::Cluster::CommandLoader.load(node)
-    Redis::Cluster::Command.new(details)
-  end
-
-  def test_key_extraction
-    described_class = build_described_class
-
-    assert_equal 'dogs:1', described_class.extract_first_key(%w[get dogs:1])
-    assert_equal 'user1000', described_class.extract_first_key(%w[get {user1000}.following])
-    assert_equal 'user1000', described_class.extract_first_key(%w[get {user1000}.followers])
-    assert_equal 'foo{}{bar}', described_class.extract_first_key(%w[get foo{}{bar}])
-    assert_equal '{bar', described_class.extract_first_key(%w[get foo{{bar}}zap])
-    assert_equal 'bar', described_class.extract_first_key(%w[get foo{bar}{zap}])
-
-    assert_equal '', described_class.extract_first_key([:get, ''])
-    assert_equal '', described_class.extract_first_key([:get, nil])
-    assert_equal '', described_class.extract_first_key([:get])
-
-    assert_equal '', described_class.extract_first_key([:set, '', 1])
-    assert_equal '', described_class.extract_first_key([:set, nil, 1])
-    assert_equal '', described_class.extract_first_key([:set])
-
-    # Keyless commands
-    assert_equal '', described_class.extract_first_key([:auth, 'password'])
-    assert_equal '', described_class.extract_first_key(%i[client kill])
-    assert_equal '', described_class.extract_first_key(%i[cluster addslots])
-    assert_equal '', described_class.extract_first_key(%i[command])
-    assert_equal '', described_class.extract_first_key(%i[command count])
-    assert_equal '', described_class.extract_first_key(%i[config get])
-    assert_equal '', described_class.extract_first_key(%i[debug segfault])
-    assert_equal '', described_class.extract_first_key([:echo, 'Hello World'])
-    assert_equal '', described_class.extract_first_key([:flushall, 'ASYNC'])
-    assert_equal '', described_class.extract_first_key([:flushdb, 'ASYNC'])
-    assert_equal '', described_class.extract_first_key([:info, 'cluster'])
-    assert_equal '', described_class.extract_first_key(%i[memory doctor])
-    assert_equal '', described_class.extract_first_key([:ping, 'Hi'])
-    assert_equal '', described_class.extract_first_key([:psubscribe, 'channel'])
-    assert_equal '', described_class.extract_first_key([:pubsub, 'channels', '*'])
-    assert_equal '', described_class.extract_first_key([:publish, 'channel', 'Hi'])
-    assert_equal '', described_class.extract_first_key([:punsubscribe, 'channel'])
-    assert_equal '', described_class.extract_first_key([:subscribe, 'channel'])
-    assert_equal '', described_class.extract_first_key([:unsubscribe, 'channel'])
-    assert_equal '', described_class.extract_first_key(%w[script exists sha1 sha1])
-    assert_equal '', described_class.extract_first_key([:select, 1])
-    assert_equal '', described_class.extract_first_key([:shutdown, 'SAVE'])
-    assert_equal '', described_class.extract_first_key([:slaveof, '127.0.0.1', 6379])
-    assert_equal '', described_class.extract_first_key([:slowlog, 'get', 2])
-    assert_equal '', described_class.extract_first_key([:swapdb, 0, 1])
-    assert_equal '', described_class.extract_first_key([:wait, 1, 0])
-
-    # 2nd argument is not a key
-    assert_equal 'key1', described_class.extract_first_key([:eval, 'script', 2, 'key1', 'key2', 'first', 'second'])
-    assert_equal '', described_class.extract_first_key([:eval, 'return 0', 0])
-    assert_equal 'key1', described_class.extract_first_key([:evalsha, 'sha1', 2, 'key1', 'key2', 'first', 'second'])
-    assert_equal '', described_class.extract_first_key([:evalsha, 'return 0', 0])
-    assert_equal 'key1', described_class.extract_first_key([:migrate, '127.0.0.1', 6379, 'key1', 0, 5000])
-    assert_equal 'key1', described_class.extract_first_key([:memory, :usage, 'key1'])
-    assert_equal 'key1', described_class.extract_first_key([:object, 'refcount', 'key1'])
-    assert_equal 'mystream', described_class.extract_first_key([:xread, 'COUNT', 2, 'STREAMS', 'mystream', 0])
-    assert_equal 'mystream', described_class.extract_first_key([:xreadgroup, 'GROUP', 'mygroup', 'Bob', 'COUNT', 2, 'STREAMS', 'mystream', '>'])
-  end
-
-  def test_whether_the_command_effect_is_readonly_or_not
-    described_class = build_described_class
-
-    assert_equal true,  described_class.should_send_to_master?([:set])
-    assert_equal false, described_class.should_send_to_slave?([:set])
-
-    assert_equal false, described_class.should_send_to_master?([:get])
-    assert_equal true,  described_class.should_send_to_slave?([:get])
-
-    target_version('3.2.0') do
-      assert_equal false, described_class.should_send_to_master?([:info])
-      assert_equal false, described_class.should_send_to_slave?([:info])
-    end
-  end
-end

data/test/cluster_client_options_test.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_client_options_test.rb
-class TestClusterClientOptions < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_option_class
-    option = Redis::Cluster::Option.new(cluster: %w[rediss://127.0.0.1:7000], replica: true)
-    assert_equal({ '127.0.0.1:7000' => { url: 'rediss://127.0.0.1:7000' } }, option.per_node_key)
-    assert_equal true, option.secure?
-    assert_equal true, option.use_replica?
-
-    option = Redis::Cluster::Option.new(cluster: %w[redis://127.0.0.1:7000], replica: false)
-    assert_equal({ '127.0.0.1:7000' => { url: 'redis://127.0.0.1:7000' } }, option.per_node_key)
-    assert_equal false, option.secure?
-    assert_equal false, option.use_replica?
-
-    option = Redis::Cluster::Option.new(cluster: %w[redis://127.0.0.1:7000])
-    assert_equal({ '127.0.0.1:7000' => { url: 'redis://127.0.0.1:7000' } }, option.per_node_key)
-    assert_equal false, option.secure?
-    assert_equal false, option.use_replica?
-  end
-
-  def test_client_accepts_valid_node_configs
-    nodes = ['redis://127.0.0.1:7000',
-             'redis://127.0.0.1:7001',
-             { host: '127.0.0.1', port: '7002' },
-             { 'host' => '127.0.0.1', port: 7003 },
-             'redis://127.0.0.1:7004',
-             'redis://127.0.0.1:7005']
-
-    assert_nothing_raised do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_accepts_valid_options
-    assert_nothing_raised do
-      build_another_client(timeout: 1.0)
-    end
-  end
-
-  def test_client_ignores_invalid_options
-    assert_nothing_raised do
-      build_another_client(invalid_option: true)
-    end
-  end
-
-  def test_client_works_even_if_so_many_unavailable_nodes_specified
-    nodes = (6001..7005).map { |port| "redis://127.0.0.1:#{port}" }
-    redis = build_another_client(cluster: nodes)
-
-    assert_equal 'PONG', redis.ping
-  end
-
-  def test_client_does_not_accept_db_specified_url
-    assert_raise(Redis::CannotConnectError, 'Could not connect to any nodes') do
-      build_another_client(cluster: ['redis://127.0.0.1:7000/1/namespace'])
-    end
-
-    assert_raise(Redis::CannotConnectError, 'Could not connect to any nodes') do
-      build_another_client(cluster: [{ host: '127.0.0.1', port: '7000' }], db: 1)
-    end
-  end
-
-  def test_client_does_not_accept_unconnectable_node_url_only
-    nodes = ['redis://127.0.0.1:7006']
-
-    assert_raise(Redis::CannotConnectError, 'Could not connect to any nodes') do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_accepts_unconnectable_node_url_included
-    nodes = ['redis://127.0.0.1:7000', 'redis://127.0.0.1:7006']
-
-    assert_nothing_raised(Redis::CannotConnectError, 'Could not connect to any nodes') do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_http_scheme_url
-    nodes = ['http://127.0.0.1:80']
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme 'http'") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_blank_included_config
-    nodes = ['']
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme ''") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_bool_included_config
-    nodes = [true]
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme ''") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_nil_included_config
-    nodes = [nil]
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme ''") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_array_included_config
-    nodes = [[]]
-
-    assert_raise(Redis::InvalidClientOptionError, "invalid uri scheme ''") do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_empty_hash_included_config
-    nodes = [{}]
-
-    assert_raise(Redis::InvalidClientOptionError, 'Redis option of `cluster` must includes `:host` and `:port` keys') do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_object_included_config
-    nodes = [Object.new]
-
-    assert_raise(Redis::InvalidClientOptionError, 'Redis Cluster node config must includes String or Hash') do
-      build_another_client(cluster: nodes)
-    end
-  end
-
-  def test_client_does_not_accept_not_array_config
-    nodes = :not_array
-
-    assert_raise(Redis::InvalidClientOptionError, 'Redis Cluster node config must be Array') do
-      build_another_client(cluster: nodes)
-    end
-  end
-end