discourse-redis 3.2.2

data/test/scripting_test.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+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

@@ -0,0 +1,80 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class SentinalCommandsTest < 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

@@ -0,0 +1,255 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class SentinalTest < 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

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+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