finsync_redis 3.3.5

data/test/commands_on_value_types_test.rb

@@ -0,0 +1,133 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/value_types"
+
+class TestCommandsOnValueTypes < Test::Unit::TestCase
+
+  include Helper::Client
+  include Lint::ValueTypes
+
+  def test_del
+    r.set "foo", "s1"
+    r.set "bar", "s2"
+    r.set "baz", "s3"
+
+    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
+
+    assert_equal 1, r.del("foo")
+
+    assert_equal ["bar", "baz"], r.keys("*").sort
+
+    assert_equal 2, r.del("bar", "baz")
+
+    assert_equal [], r.keys("*").sort
+  end
+
+  def test_del_with_array_argument
+    r.set "foo", "s1"
+    r.set "bar", "s2"
+    r.set "baz", "s3"
+
+    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
+
+    assert_equal 1, r.del(["foo"])
+
+    assert_equal ["bar", "baz"], r.keys("*").sort
+
+    assert_equal 2, r.del(["bar", "baz"])
+
+    assert_equal [], r.keys("*").sort
+  end
+
+  def test_randomkey
+    assert r.randomkey.to_s.empty?
+
+    r.set("foo", "s1")
+
+    assert_equal "foo", r.randomkey
+
+    r.set("bar", "s2")
+
+    4.times do
+      assert ["foo", "bar"].include?(r.randomkey)
+    end
+  end
+
+  def test_rename
+    r.set("foo", "s1")
+    r.rename "foo", "bar"
+
+    assert_equal "s1", r.get("bar")
+    assert_equal nil, r.get("foo")
+  end
+
+  def test_renamenx
+    r.set("foo", "s1")
+    r.set("bar", "s2")
+
+    assert_equal false, r.renamenx("foo", "bar")
+
+    assert_equal "s1", r.get("foo")
+    assert_equal "s2", r.get("bar")
+  end
+
+  def test_dbsize
+    assert_equal 0, r.dbsize
+
+    r.set("foo", "s1")
+
+    assert_equal 1, r.dbsize
+  end
+
+  def test_flushdb
+    r.set("foo", "s1")
+    r.set("bar", "s2")
+
+    assert_equal 2, r.dbsize
+
+    r.flushdb
+
+    assert_equal 0, r.dbsize
+  end
+
+  def test_flushall
+    redis_mock(:flushall => lambda { "+FLUSHALL" }) do |redis|
+      assert_equal "FLUSHALL", redis.flushall
+    end
+  end
+
+  def test_migrate
+    redis_mock(:migrate => lambda { |*args| args }) do |redis|
+      options = { :host => "127.0.0.1", :port => 1234 }
+
+      ex = assert_raise(RuntimeError) do
+        redis.migrate("foo", options.reject { |key, _| key == :host })
+      end
+      assert ex.message =~ /host not specified/
+
+      ex = assert_raise(RuntimeError) do
+        redis.migrate("foo", options.reject { |key, _| key == :port })
+      end
+      assert ex.message =~ /port not specified/
+
+      default_db = redis.client.db.to_i
+      default_timeout = redis.client.timeout.to_i
+
+      # Test defaults
+      actual = redis.migrate("foo", options)
+      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, default_timeout.to_s]
+      assert_equal expected, actual
+
+      # Test db override
+      actual = redis.migrate("foo", options.merge(:db => default_db + 1))
+      expected = ["127.0.0.1", "1234", "foo", (default_db + 1).to_s, default_timeout.to_s]
+      assert_equal expected, actual
+
+      # Test timeout override
+      actual = redis.migrate("foo", options.merge(:timeout => default_timeout + 1))
+      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, (default_timeout + 1).to_s]
+      assert_equal expected, actual
+    end
+  end
+end

data/test/connection_handling_test.rb

@@ -0,0 +1,277 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+
+class TestConnectionHandling < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_auth
+    commands = {
+      :auth => lambda { |password| $auth = password; "+OK" },
+      :get  => lambda { |key| $auth == "secret" ? "$3\r\nbar" : "$-1" },
+    }
+
+    redis_mock(commands, :password => "secret") do |redis|
+      assert_equal "bar", redis.get("foo")
+    end
+  end
+
+  def test_id
+    commands = {
+      :client => lambda { |cmd, name| $name = [cmd, name]; "+OK" },
+      :ping  => lambda { "+PONG" },
+    }
+
+    redis_mock(commands, :id => "client-name") do |redis|
+      assert_equal "PONG", redis.ping
+    end
+
+    assert_equal ["setname","client-name"], $name
+  end
+
+  def test_ping
+    assert_equal "PONG", r.ping
+  end
+
+  def test_select
+    r.set "foo", "bar"
+
+    r.select 14
+    assert_equal nil, r.get("foo")
+
+    r.client.disconnect
+
+    assert_equal nil, r.get("foo")
+  end
+
+  def test_quit
+    r.quit
+
+    assert !r.client.connected?
+  end
+
+  def test_close
+    quit = 0
+
+    commands = {
+      :quit => lambda do
+        quit += 1
+        "+OK"
+      end
+    }
+
+    redis_mock(commands) do |redis|
+      assert_equal 0, quit
+
+      redis.quit
+
+      assert_equal 1, quit
+
+      redis.ping
+
+      redis.close
+
+      assert_equal 1, quit
+
+      assert !redis.connected?
+    end
+  end
+
+  def test_disconnect
+    quit = 0
+
+    commands = {
+      :quit => lambda do
+        quit += 1
+        "+OK"
+      end
+    }
+
+    redis_mock(commands) do |redis|
+      assert_equal 0, quit
+
+      redis.quit
+
+      assert_equal 1, quit
+
+      redis.ping
+
+      redis.disconnect!
+
+      assert_equal 1, quit
+
+      assert !redis.connected?
+    end
+  end
+
+  def test_shutdown
+    commands = {
+      :shutdown => lambda { :exit }
+    }
+
+    redis_mock(commands) do |redis|
+      # SHUTDOWN does not reply: test that it does not raise here.
+      assert_equal nil, redis.shutdown
+    end
+  end
+
+  def test_shutdown_with_error
+    connections = 0
+    commands = {
+      :select => lambda { |*_| connections += 1; "+OK\r\n" },
+      :connections => lambda { ":#{connections}\r\n" },
+      :shutdown => lambda { "-ERR could not shutdown\r\n" }
+    }
+
+    redis_mock(commands) do |redis|
+      connections = redis.connections
+
+      # SHUTDOWN replies with an error: test that it gets raised
+      assert_raise Redis::CommandError do
+        redis.shutdown
+      end
+
+      # The connection should remain in tact
+      assert_equal connections, redis.connections
+    end
+  end
+
+  def test_shutdown_from_pipeline
+    commands = {
+      :shutdown => lambda { :exit }
+    }
+
+    redis_mock(commands) do |redis|
+      result = redis.pipelined do
+        redis.shutdown
+      end
+
+      assert_equal nil, result
+      assert !redis.client.connected?
+    end
+  end
+
+  def test_shutdown_with_error_from_pipeline
+    connections = 0
+    commands = {
+      :select => lambda { |*_| connections += 1; "+OK\r\n" },
+      :connections => lambda { ":#{connections}\r\n" },
+      :shutdown => lambda { "-ERR could not shutdown\r\n" }
+    }
+
+    redis_mock(commands) do |redis|
+      connections = redis.connections
+
+      # SHUTDOWN replies with an error: test that it gets raised
+      assert_raise Redis::CommandError do
+        redis.pipelined do
+          redis.shutdown
+        end
+      end
+
+      # The connection should remain in tact
+      assert_equal connections, redis.connections
+    end
+  end
+
+  def test_shutdown_from_multi_exec
+    commands = {
+      :multi => lambda { "+OK\r\n" },
+      :shutdown => lambda { "+QUEUED\r\n" },
+      :exec => lambda { :exit }
+    }
+
+    redis_mock(commands) do |redis|
+      result = redis.multi do
+        redis.shutdown
+      end
+
+      assert_equal nil, result
+      assert !redis.client.connected?
+    end
+  end
+
+  def test_shutdown_with_error_from_multi_exec
+    connections = 0
+    commands = {
+      :select => lambda { |*_| connections += 1; "+OK\r\n" },
+      :connections => lambda { ":#{connections}\r\n" },
+      :multi => lambda { "+OK\r\n" },
+      :shutdown => lambda { "+QUEUED\r\n" },
+      :exec => lambda { "*1\r\n-ERR could not shutdown\r\n" }
+    }
+
+    redis_mock(commands) do |redis|
+      connections = redis.connections
+
+      # SHUTDOWN replies with an error: test that it gets returned
+      # We should test for Redis::CommandError here, but hiredis doesn't yet do
+      # custom error classes.
+      err = nil
+
+      begin
+        redis.multi { redis.shutdown }
+      rescue => err
+      end
+
+      assert err.kind_of?(StandardError)
+
+      # The connection should remain intact
+      assert_equal connections, redis.connections
+    end
+  end
+
+  def test_slaveof
+    redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do |redis|
+      assert_equal "SLAVEOF somehost 6381", redis.slaveof("somehost", 6381)
+    end
+  end
+
+  def test_bgrewriteaof
+    redis_mock(:bgrewriteaof => lambda { "+BGREWRITEAOF" }) do |redis|
+      assert_equal "BGREWRITEAOF", redis.bgrewriteaof
+    end
+  end
+
+  def test_config_get
+    assert r.config(:get, "*")["timeout"] != nil
+
+    config = r.config(:get, "timeout")
+    assert_equal ["timeout"], config.keys
+    assert config.values.compact.size > 0
+  end
+
+  def test_config_set
+    begin
+      assert_equal "OK", r.config(:set, "timeout", 200)
+      assert_equal "200", r.config(:get, "*")["timeout"]
+
+      assert_equal "OK", r.config(:set, "timeout", 100)
+      assert_equal "100", r.config(:get, "*")["timeout"]
+    ensure
+      r.config :set, "timeout", 300
+    end
+  end
+
+  driver(:ruby, :hiredis) do
+    def test_consistency_on_multithreaded_env
+      t = nil
+
+      commands = {
+        :set => lambda { |key, value| t.kill; "+OK\r\n" },
+        :incr => lambda { |key| ":1\r\n" },
+      }
+
+      redis_mock(commands) do |redis|
+        t = Thread.new do
+          redis.set("foo", "bar")
+        end
+
+        t.join
+
+        assert_equal 1, redis.incr("baz")
+      end
+    end
+  end
+end

data/test/connection_test.rb

@@ -0,0 +1,57 @@
+require_relative "helper"
+
+class TestConnection < Test::Unit::TestCase
+
+  include Helper::Client
+
+  def test_provides_a_meaningful_inspect
+    assert_equal "#<Redis client v#{Redis::VERSION} for redis://127.0.0.1:#{PORT}/15>", r.inspect
+  end
+
+  def test_connection_information
+    assert_equal "127.0.0.1",                 r.connection.fetch(:host)
+    assert_equal 6381,                        r.connection.fetch(:port)
+    assert_equal 15,                          r.connection.fetch(:db)
+    assert_equal "127.0.0.1:6381",            r.connection.fetch(:location)
+    assert_equal "redis://127.0.0.1:6381/15", r.connection.fetch(:id)
+  end
+
+  def test_default_id_with_host_and_port
+    redis = Redis.new(OPTIONS.merge(:host => "host", :port => "1234", :db => 0))
+    assert_equal "redis://host:1234/0", redis.connection.fetch(:id)
+  end
+
+  def test_default_id_with_host_and_port_and_explicit_scheme
+    redis = Redis.new(OPTIONS.merge(:host => "host", :port => "1234", :db => 0, :scheme => "foo"))
+    assert_equal "redis://host:1234/0", redis.connection.fetch(:id)
+  end
+
+  def test_default_id_with_path
+    redis = Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock", :db => 0))
+    assert_equal "redis:///tmp/redis.sock/0", redis.connection.fetch(:id)
+  end
+
+  def test_default_id_with_path_and_explicit_scheme
+    redis = Redis.new(OPTIONS.merge(:path => "/tmp/redis.sock", :db => 0, :scheme => "foo"))
+    assert_equal "redis:///tmp/redis.sock/0", redis.connection.fetch(:id)
+  end
+
+  def test_override_id
+    redis = Redis.new(OPTIONS.merge(:id => "test"))
+    assert_equal "test", redis.connection.fetch(:id)
+  end
+
+  def test_id_inside_multi
+    redis         = Redis.new(OPTIONS)
+    id            = nil
+    connection_id = nil
+
+    redis.multi do
+      id            = redis.id
+      connection_id = redis.connection.fetch(:id)
+    end
+
+    assert_equal "redis://127.0.0.1:6381/15", id
+    assert_equal "redis://127.0.0.1:6381/15", connection_id
+  end
+end

data/test/distributed_blocking_commands_test.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/blocking_commands"
+
+class TestDistributedBlockingCommands < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::BlockingCommands
+
+  def test_blpop_raises
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.blpop(["foo", "bar"])
+    end
+  end
+
+  def test_blpop_raises_with_old_prototype
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.blpop("foo", "bar", 0)
+    end
+  end
+
+  def test_brpop_raises
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.brpop(["foo", "bar"])
+    end
+  end
+
+  def test_brpop_raises_with_old_prototype
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.brpop("foo", "bar", 0)
+    end
+  end
+
+  def test_brpoplpush_raises
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.brpoplpush("foo", "bar")
+    end
+  end
+
+  def test_brpoplpush_raises_with_old_prototype
+    assert_raises(Redis::Distributed::CannotDistribute) do
+      r.brpoplpush("foo", "bar", 0)
+    end
+  end
+end

data/test/distributed_commands_on_hashes_test.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/hashes"
+
+class TestDistributedCommandsOnHashes < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::Hashes
+end

data/test/distributed_commands_on_hyper_log_log_test.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/hyper_log_log"
+
+class TestDistributedCommandsOnHyperLogLog < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::HyperLogLog
+
+  def test_pfmerge
+    target_version "2.8.9" do
+      assert_raise Redis::Distributed::CannotDistribute do
+        r.pfadd "foo", "s1"
+        r.pfadd "bar", "s2"
+
+        assert r.pfmerge("res", "foo", "bar")
+      end
+    end
+  end
+
+  def test_pfcount_multiple_keys_diff_nodes
+    target_version "2.8.9" do
+      assert_raise Redis::Distributed::CannotDistribute do
+        r.pfadd "foo", "s1"
+        r.pfadd "bar", "s2"
+
+        assert r.pfcount("res", "foo", "bar")
+      end
+    end
+  end
+
+end

data/test/distributed_commands_on_lists_test.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/lists"
+
+class TestDistributedCommandsOnLists < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::Lists
+
+  def test_rpoplpush
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.rpoplpush("foo", "bar")
+    end
+  end
+
+  def test_brpoplpush
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.brpoplpush("foo", "bar", :timeout => 1)
+    end
+  end
+end

data/test/distributed_commands_on_sets_test.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/sets"
+
+class TestDistributedCommandsOnSets < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::Sets
+
+  def test_smove
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "bar", "s2"
+
+      r.smove("foo", "bar", "s1")
+    end
+  end
+
+  def test_sinter
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+
+      r.sinter("foo", "bar")
+    end
+  end
+
+  def test_sinterstore
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+
+      r.sinterstore("baz", "foo", "bar")
+    end
+  end
+
+  def test_sunion
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+      r.sadd "bar", "s3"
+
+      r.sunion("foo", "bar")
+    end
+  end
+
+  def test_sunionstore
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+      r.sadd "bar", "s3"
+
+      r.sunionstore("baz", "foo", "bar")
+    end
+  end
+
+  def test_sdiff
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+      r.sadd "bar", "s3"
+
+      r.sdiff("foo", "bar")
+    end
+  end
+
+  def test_sdiffstore
+    assert_raise Redis::Distributed::CannotDistribute do
+      r.sadd "foo", "s1"
+      r.sadd "foo", "s2"
+      r.sadd "bar", "s2"
+      r.sadd "bar", "s3"
+
+      r.sdiffstore("baz", "foo", "bar")
+    end
+  end
+end

data/test/distributed_commands_on_sorted_sets_test.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require File.expand_path("helper", File.dirname(__FILE__))
+require "lint/sorted_sets"
+
+class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase
+
+  include Helper::Distributed
+  include Lint::SortedSets
+
+  def test_zcount
+    r.zadd "foo", 1, "s1"
+    r.zadd "foo", 2, "s2"
+    r.zadd "foo", 3, "s3"
+
+    assert_equal 2, r.zcount("foo", 2, 3)
+  end
+end