redis 4.1.0.beta1 → 4.1.0

data/test/scripting_test.rb

@@ -1,76 +0,0 @@
-require_relative "helper"
-
-class TestScripting < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def to_sha(script)
-    r.script(:load, script)
-  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)
-      assert_equal "OK", r.script(:flush)
-      assert !r.script(:exists, sha)
-    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_equal 0, r.eval("return #KEYS")
-      assert_equal 0, r.eval("return #ARGV")
-      assert_equal ["k1", "k2"], r.eval("return KEYS", ["k1", "k2"])
-      assert_equal ["a1", "a2"], r.eval("return ARGV", [], ["a1", "a2"])
-    end
-  end
-
-  def test_eval_with_options_hash
-    target_version "2.5.9" do # 2.6-rc1
-      assert_equal 0, r.eval("return #KEYS", {})
-      assert_equal 0, r.eval("return #ARGV", {})
-      assert_equal ["k1", "k2"], r.eval("return KEYS", { :keys => ["k1", "k2"] })
-      assert_equal ["a1", "a2"], r.eval("return ARGV", { :argv => ["a1", "a2"] })
-    end
-  end
-
-  def test_evalsha
-    target_version "2.5.9" do # 2.6-rc1
-      assert_equal 0, r.evalsha(to_sha("return #KEYS"))
-      assert_equal 0, r.evalsha(to_sha("return #ARGV"))
-      assert_equal ["k1", "k2"], r.evalsha(to_sha("return KEYS"), ["k1", "k2"])
-      assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), [], ["a1", "a2"])
-    end
-  end
-
-  def test_evalsha_with_options_hash
-    target_version "2.5.9" do # 2.6-rc1
-      assert_equal 0, r.evalsha(to_sha("return #KEYS"), {})
-      assert_equal 0, r.evalsha(to_sha("return #ARGV"), {})
-      assert_equal ["k1", "k2"], r.evalsha(to_sha("return KEYS"), { :keys => ["k1", "k2"] })
-      assert_equal ["a1", "a2"], r.evalsha(to_sha("return ARGV"), { :argv => ["a1", "a2"] })
-    end
-  end
-end

data/test/sentinel_command_test.rb

@@ -1,78 +0,0 @@
-require_relative "helper"
-
-class SentinelCommandsTest < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_sentinel_command_master
-
-    handler = lambda do |id|
-      {
-        :sentinel => lambda do |command, *args|
-          ["name", "master1", "ip", "127.0.0.1"]
-        end
-      }
-    end
-
-    RedisMock.start(handler.call(:s1)) do |port|
-      redis = Redis.new(:host => "127.0.0.1", :port => port)
-
-      result = redis.sentinel('master', 'master1')
-      assert_equal result, { "name" => "master1", "ip" => "127.0.0.1" }
-    end
-  end
-
-  def test_sentinel_command_masters
-
-    handler = lambda do |id|
-      {
-        :sentinel => lambda do |command, *args|
-          [%w[name master1 ip 127.0.0.1 port 6381], %w[name master1 ip 127.0.0.1 port 6382]]
-        end
-      }
-    end
-
-    RedisMock.start(handler.call(:s1)) do |port|
-      redis = Redis.new(:host => "127.0.0.1", :port => port)
-
-      result = redis.sentinel('masters')
-      assert_equal result[0], { "name" => "master1", "ip" => "127.0.0.1", "port" => "6381" }
-      assert_equal result[1], { "name" => "master1", "ip" => "127.0.0.1", "port" => "6382" }
-    end
-  end
-
-  def test_sentinel_command_get_master_by_name
-
-    handler = lambda do |id|
-      {
-        :sentinel => lambda do |command, *args|
-          ["127.0.0.1", "6381"]
-        end
-      }
-    end
-
-    RedisMock.start(handler.call(:s1)) do |port|
-      redis = Redis.new(:host => "127.0.0.1", :port => port)
-
-      result = redis.sentinel('get-master-addr-by-name', 'master1')
-      assert_equal result, ["127.0.0.1", "6381"]
-    end
-  end
-
-  def test_sentinel_command_ckquorum
-    handler = lambda do |id|
-      {
-        :sentinel => lambda do |command, *args|
-          "+OK 2 usable Sentinels. Quorum and failover authorization can be reached"
-        end
-      }
-    end
-
-    RedisMock.start(handler.call(:s1)) do |port|
-      redis = Redis.new(:host => "127.0.0.1", :port => port)
-
-      result = redis.sentinel('ckquorum', 'master1')
-      assert_equal result, "OK 2 usable Sentinels. Quorum and failover authorization can be reached"
-    end
-  end
-end

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