redis 4.0.3 → 4.5.0

data/test/sentinel_test.rb

@@ -1,253 +0,0 @@
-require_relative "helper"
-
-class SentinelTest < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_sentinel_connection
-    sentinels = [{:host => "127.0.0.1", :port => 26381},
-                 {:host => "127.0.0.1", :port => 26382}]
-
-    commands = {
-      :s1 => [],
-      :s2 => [],
-    }
-
-    handler = lambda do |id|
-      {
-        :sentinel => lambda do |command, *args|
-          commands[id] << [command, *args]
-          ["127.0.0.1", "6381"]
-        end
-      }
-    end
-
-    RedisMock.start(handler.call(:s1)) do |s1_port|
-      RedisMock.start(handler.call(:s2)) do |s2_port|
-        sentinels[0][:port] = s1_port
-        sentinels[1][:port] = s2_port
-        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
-
-        assert redis.ping
-      end
-    end
-
-    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
-    assert_equal commands[:s2], []
-  end
-
-  def test_sentinel_failover
-    sentinels = [{:host => "127.0.0.1", :port => 26381},
-                 {:host => "127.0.0.1", :port => 26382}]
-
-    commands = {
-      :s1 => [],
-      :s2 => [],
-    }
-
-    s1 = {
-      :sentinel => lambda do |command, *args|
-        commands[:s1] << [command, *args]
-        "$-1" # Nil
-      end
-    }
-
-    s2 = {
-      :sentinel => lambda do |command, *args|
-        commands[:s2] << [command, *args]
-        ["127.0.0.1", "6381"]
-      end
-    }
-
-    RedisMock.start(s1) do |s1_port|
-      RedisMock.start(s2) do |s2_port|
-        sentinels[0][:port] = s1_port
-        sentinels[1][:port] = s2_port
-        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
-
-        assert redis.ping
-      end
-    end
-
-    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
-    assert_equal commands[:s2], [%w[get-master-addr-by-name master1]]
-  end
-
-  def test_sentinel_failover_prioritize_healthy_sentinel
-    sentinels = [{:host => "127.0.0.1", :port => 26381},
-                 {:host => "127.0.0.1", :port => 26382}]
-
-    commands = {
-      :s1 => [],
-      :s2 => [],
-    }
-
-    s1 = {
-      :sentinel => lambda do |command, *args|
-        commands[:s1] << [command, *args]
-        "$-1" # Nil
-      end
-    }
-
-    s2 = {
-      :sentinel => lambda do |command, *args|
-        commands[:s2] << [command, *args]
-        ["127.0.0.1", "6381"]
-      end
-    }
-
-    RedisMock.start(s1) do |s1_port|
-      RedisMock.start(s2) do |s2_port|
-        sentinels[0][:port] = s1_port
-        sentinels[1][:port] = s2_port
-        redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
-
-        assert redis.ping
-
-        redis.quit
-
-        assert redis.ping
-      end
-    end
-
-    assert_equal commands[:s1], [%w[get-master-addr-by-name master1]]
-    assert_equal commands[:s2], [%w[get-master-addr-by-name master1], %w[get-master-addr-by-name master1]]
-  end
-
-  def test_sentinel_with_non_sentinel_options
-    sentinels = [{:host => "127.0.0.1", :port => 26381}]
-
-    commands = {
-      :s1 => [],
-      :m1 => []
-    }
-
-    sentinel = lambda do |port|
-      {
-        :auth => lambda do |pass|
-          commands[:s1] << ["auth", pass]
-          "-ERR unknown command 'auth'"
-        end,
-        :select => lambda do |db|
-          commands[:s1] << ["select", db]
-          "-ERR unknown command 'select'"
-        end,
-        :sentinel => lambda do |command, *args|
-          commands[:s1] << [command, *args]
-          ["127.0.0.1", port.to_s]
-        end
-      }
-    end
-
-    master = {
-      :auth => lambda do |pass|
-        commands[:m1] << ["auth", pass]
-        "+OK"
-      end,
-      :role => lambda do
-        commands[:m1] << ["role"]
-        ["master"]
-      end
-    }
-
-    RedisMock.start(master) do |master_port|
-      RedisMock.start(sentinel.call(master_port)) do |sen_port|
-        sentinels[0][:port] = sen_port
-        redis = Redis.new(:url => "redis://:foo@master1/15", :sentinels => sentinels, :role => :master)
-
-        assert redis.ping
-      end
-    end
-
-    assert_equal [%w[get-master-addr-by-name master1]], commands[:s1]
-    assert_equal [%w[auth foo], %w[role]], commands[:m1]
-  end
-
-  def test_sentinel_role_mismatch
-    sentinels = [{:host => "127.0.0.1", :port => 26381}]
-
-    sentinel = lambda do |port|
-      {
-        :sentinel => lambda do |command, *args|
-          ["127.0.0.1", port.to_s]
-        end
-      }
-    end
-
-    master = {
-      :role => lambda do
-        ["slave"]
-      end
-    }
-
-    ex = assert_raise(Redis::ConnectionError) do
-      RedisMock.start(master) do |master_port|
-        RedisMock.start(sentinel.call(master_port)) do |sen_port|
-          sentinels[0][:port] = sen_port
-          redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master)
-
-          assert redis.ping
-        end
-      end
-    end
-
-    assert_match(/Instance role mismatch/, ex.message)
-  end
-
-  def test_sentinel_retries
-    sentinels = [{:host => "127.0.0.1", :port => 26381},
-                 {:host => "127.0.0.1", :port => 26382}]
-
-    connections = []
-
-    handler = lambda do |id, port|
-      {
-        :sentinel => lambda do |command, *args|
-          connections << id
-
-          if connections.count(id) < 2
-            :close
-          else
-            ["127.0.0.1", port.to_s]
-          end
-        end
-      }
-    end
-
-    master = {
-      :role => lambda do
-        ["master"]
-      end
-    }
-
-    RedisMock.start(master) do |master_port|
-      RedisMock.start(handler.call(:s1, master_port)) do |s1_port|
-        RedisMock.start(handler.call(:s2, master_port)) do |s2_port|
-          sentinels[0][:port] = s1_port
-          sentinels[1][:port] = s2_port
-          redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master, :reconnect_attempts => 1)
-
-          assert redis.ping
-        end
-      end
-    end
-
-    assert_equal [:s1, :s2, :s1], connections
-
-    connections.clear
-
-    ex = assert_raise(Redis::CannotConnectError) do
-      RedisMock.start(master) do |master_port|
-        RedisMock.start(handler.call(:s1, master_port)) do |s1_port|
-          RedisMock.start(handler.call(:s2, master_port)) do |s2_port|
-            redis = Redis.new(:url => "redis://master1", :sentinels => sentinels, :role => :master, :reconnect_attempts => 0)
-
-            assert redis.ping
-          end
-        end
-      end
-    end
-
-    assert_match(/No sentinels available/, ex.message)
-  end
-end

data/test/sorting_test.rb

@@ -1,57 +0,0 @@
-require_relative "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
-
-  def test_sort_with_an_array_of_gets_and_with_store
-    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")
-
-    r.sort("bar", :get => ["foo:*:a", "foo:*:b"], :store => 'baz')
-    assert_equal ["s1a", "s1b", "s2a", "s2b"], r.lrange("baz", 0, -1)
-  end
-end

data/test/ssl_test.rb

@@ -1,69 +0,0 @@
-require_relative "helper"
-
-class SslTest < Test::Unit::TestCase
-
-  include Helper::Client
-
-  driver(:ruby) do
-
-    def test_verified_ssl_connection
-      RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port|
-        redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-        assert_equal redis.ping, "PONG"
-      end
-    end
-
-    def test_unverified_ssl_connection
-      assert_raise(OpenSSL::SSL::SSLError) do
-        RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("untrusted")) do |port|
-          redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-          redis.ping
-        end
-      end
-    end
-
-    def test_ssl_blocking
-      RedisMock.start({}, ssl_server_opts("trusted")) do |port|
-        redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-        assert_equal redis.set("boom", "a" * 10_000_000), "OK"
-      end
-    end
-
-  end
-
-  driver(:hiredis, :synchrony) do
-
-    def test_ssl_not_implemented_exception
-      assert_raise(NotImplementedError) do
-        RedisMock.start({ :ping => proc { "+PONG" } }, ssl_server_opts("trusted")) do |port|
-          redis = Redis.new(:port => port, :ssl => true, :ssl_params => { :ca_file => ssl_ca_file })
-          redis.ping
-        end
-      end
-    end
-
-  end
-
-  private
-
-  def ssl_server_opts(prefix)
-    ssl_cert = File.join(cert_path, "#{prefix}-cert.crt")
-    ssl_key  = File.join(cert_path, "#{prefix}-cert.key")
-
-    {
-      :ssl => true,
-      :ssl_params => {
-        :cert => OpenSSL::X509::Certificate.new(File.read(ssl_cert)),
-        :key  => OpenSSL::PKey::RSA.new(File.read(ssl_key))
-      }
-    }
-  end
-
-  def ssl_ca_file
-    File.join(cert_path, "trusted-ca.crt")
-  end
-
-  def cert_path
-    File.expand_path("../support/ssl/", __FILE__)
-  end
-end

data/test/support/cluster/orchestrator.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../lib/redis'
-
-class ClusterOrchestrator
-  SLOT_SIZE = 16384
-
-  def initialize(node_addrs)
-    raise 'Redis Cluster requires at least 3 master nodes.' if node_addrs.size < 3
-    @clients = node_addrs.map { |addr| Redis.new(url: addr) }
-  end
-
-  def rebuild
-    flush_all_data(@clients)
-    reset_cluster(@clients)
-    assign_slots(@clients)
-    save_config_epoch(@clients)
-    meet_each_other(@clients)
-    wait_meeting(@clients)
-    replicate(@clients)
-    save_config(@clients)
-    wait_cluster_building(@clients)
-    sleep 3
-  end
-
-  def down
-    flush_all_data(@clients)
-    reset_cluster(@clients)
-  end
-
-  def failover
-    take_slaves(@clients).last.cluster(:failover, :takeover)
-    sleep 3
-  end
-
-  def start_resharding(slot, src_node_key, dest_node_key)
-    node_map = hashify_node_map(@clients.first)
-    src_node_id = node_map.fetch(src_node_key)
-    src_client = find_client(@clients, src_node_key)
-    dest_node_id = node_map.fetch(dest_node_key)
-    dest_client = find_client(@clients, dest_node_key)
-    dest_host, dest_port = dest_node_key.split(':')
-
-    dest_client.cluster(:setslot, slot, 'IMPORTING', src_node_id)
-    src_client.cluster(:setslot, slot, 'MIGRATING', dest_node_id)
-
-    loop do
-      keys = src_client.cluster(:getkeysinslot, slot, 100)
-      break if keys.empty?
-      keys.each { |k| src_client.migrate(k, host: dest_host, port: dest_port) }
-      sleep 0.1
-    end
-  end
-
-  def finish_resharding(slot, dest_node_key)
-    node_map = hashify_node_map(@clients.first)
-    @clients.first.cluster(:setslot, slot, 'NODE', node_map.fetch(dest_node_key))
-  end
-
-  def close
-    @clients.each(&:quit)
-  end
-
-  private
-
-  def flush_all_data(clients)
-    clients.each do |c|
-      begin
-        c.flushall
-      rescue Redis::CommandError
-        # READONLY You can't write against a read only slave.
-        nil
-      end
-    end
-  end
-
-  def reset_cluster(clients)
-    clients.each { |c| c.cluster(:reset) }
-  end
-
-  def assign_slots(clients)
-    masters = take_masters(clients)
-    slot_slice = SLOT_SIZE / masters.size
-    mod = SLOT_SIZE % masters.size
-    slot_sizes = Array.new(masters.size, slot_slice)
-    mod.downto(1) { |i| slot_sizes[i] += 1 }
-
-    slot_idx = 0
-    masters.zip(slot_sizes).each do |c, s|
-      slot_range = slot_idx..slot_idx + s - 1
-      c.cluster(:addslots, *slot_range.to_a)
-      slot_idx += s
-    end
-  end
-
-  def save_config_epoch(clients)
-    clients.each_with_index do |c, i|
-      begin
-        c.cluster('set-config-epoch', i + 1)
-      rescue Redis::CommandError
-        # ERR Node config epoch is already non-zero
-        nil
-      end
-    end
-  end
-
-  def meet_each_other(clients)
-    first_cliient = clients.first
-    target_info = first_cliient.connection
-    target_host = target_info.fetch(:host)
-    target_port = target_info.fetch(:port)
-
-    clients.each do |client|
-      next if first_cliient.id == client.id
-      client.cluster(:meet, target_host, target_port)
-    end
-  end
-
-  def wait_meeting(clients)
-    first_cliient = clients.first
-    size = clients.size
-
-    loop do
-      info = hashify_cluster_info(first_cliient)
-      break if info['cluster_known_nodes'].to_i == size
-      sleep 0.1
-    end
-  end
-
-  def replicate(clients)
-    node_map = hashify_node_map(clients.first)
-    masters = take_masters(clients)
-
-    take_slaves(clients).each_with_index do |slave, i|
-      master_info = masters[i].connection
-      master_host = master_info.fetch(:host)
-      master_port = master_info.fetch(:port)
-
-      loop do
-        begin
-          master_node_id = node_map.fetch("#{master_host}:#{master_port}")
-          slave.cluster(:replicate, master_node_id)
-        rescue Redis::CommandError
-          # ERR Unknown node [key]
-          sleep 0.1
-          node_map = hashify_node_map(clients.first)
-          next
-        end
-
-        break
-      end
-    end
-  end
-
-  def save_config(clients)
-    clients.each { |c| c.cluster(:saveconfig) }
-  end
-
-  def wait_cluster_building(clients)
-    first_cliient = clients.first
-
-    loop do
-      info = hashify_cluster_info(first_cliient)
-      break if info['cluster_state'] == 'ok'
-      sleep 0.1
-    end
-  end
-
-  def hashify_cluster_info(client)
-    client.cluster(:info).split("\r\n").map { |str| str.split(':') }.to_h
-  end
-
-  def hashify_node_map(client)
-    client.cluster(:nodes)
-          .split("\n")
-          .map { |str| str.split(' ') }
-          .map { |arr| [arr[1].split('@').first, arr[0]] }
-          .to_h
-  end
-
-  def take_masters(clients)
-    size = clients.size / 2
-    return clients if size < 3
-    clients.take(size)
-  end
-
-  def take_slaves(clients)
-    size = clients.size / 2
-    return [] if size < 3
-    clients[size..size * 2]
-  end
-
-  def find_client(clients, node_key)
-    clients.find do |cli|
-      con = cli.connection
-      node_key == "#{con.fetch(:host)}:#{con.fetch(:port)}"
-    end
-  end
-end

data/test/support/connection/hiredis.rb

@@ -1 +0,0 @@
-require_relative "../wire/thread"

data/test/support/connection/ruby.rb

@@ -1 +0,0 @@
-require_relative "../wire/thread"

data/test/support/connection/synchrony.rb

@@ -1,17 +0,0 @@
-require_relative "../wire/synchrony"
-
-module Helper
-  def around
-    rv = nil
-
-    EM.synchrony do
-      begin
-        rv = yield
-      ensure
-        EM.stop
-      end
-    end
-
-    rv
-  end
-end