redis 3.3.5 → 4.0.0

data/test/lint/strings.rb

@@ -8,18 +8,6 @@ module Lint
       assert_equal "s1", r.get("foo")
     end
 
-    def test_set_and_get_with_brackets
-      r["foo"] = "s1"
-
-      assert_equal "s1", r["foo"]
-    end
-
-    def test_set_and_get_with_brackets_and_symbol
-      r[:foo] = "s1"
-
-      assert_equal "s1", r[:foo]
-    end
-
     def test_set_and_get_with_newline_characters
       r.set("foo", "1\n")
 
@@ -35,14 +23,12 @@ module Lint
     end
 
     def test_set_and_get_with_ascii_characters
-      if defined?(Encoding)
-        with_external_encoding("ASCII-8BIT") do
-          (0..255).each do |i|
-            str = "#{i.chr}---#{i.chr}"
-            r.set("foo", str)
-
-            assert_equal str, r.get("foo")
-          end
+      with_external_encoding("ASCII-8BIT") do
+        (0..255).each do |i|
+          str = "#{i.chr}---#{i.chr}"
+          r.set("foo", str)
+
+          assert_equal str, r.get("foo")
         end
       end
     end

data/test/lint/value_types.rb

@@ -93,6 +93,14 @@ module Lint
         assert r.restore("bar", 1000, w)
         assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
         assert [0, 1].include? r.ttl("bar")
+
+        r.set("bar", "somethingelse")
+        assert_raises(Redis::CommandError) { r.restore("bar", 1000, w) } # ensure by default replace is false
+        assert_raises(Redis::CommandError) { r.restore("bar", 1000, w, :replace => false) }
+        assert_equal "somethingelse", r.get("bar")
+        assert r.restore("bar", 1000, w, :replace => true)
+        assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
+        assert [0, 1].include? r.ttl("bar")
       end
     end
 

data/test/persistence_control_commands_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestPersistenceControlCommands < Test::Unit::TestCase
 

data/test/pipelining_commands_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestPipeliningCommands < Test::Unit::TestCase
 
@@ -136,9 +134,7 @@ class TestPipeliningCommands < Test::Unit::TestCase
     end
 
     assert_equal true, @result.is_a?(Redis::Future)
-    if defined?(::BasicObject)
-      assert_equal true, @result.is_a?(::BasicObject)
-    end
+    assert_equal true, @result.is_a?(::BasicObject)
     assert_equal Redis::Future, @result.class
   end
 
@@ -225,7 +221,7 @@ class TestPipeliningCommands < Test::Unit::TestCase
       p2.select 2
     end
 
-    assert_equal 2, r.client.db
+    assert_equal 2, r._client.db
   end
 
   def test_nested_pipeline_select_client_db
@@ -237,6 +233,6 @@ class TestPipeliningCommands < Test::Unit::TestCase
       end
     end
 
-    assert_equal 3, r.client.db
+    assert_equal 3, r._client.db
   end
 end

data/test/publish_subscribe_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestPublishSubscribe < Test::Unit::TestCase
 

data/test/remote_server_control_commands_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestRemoteServerControlCommands < Test::Unit::TestCase
 
@@ -115,4 +113,63 @@ class TestRemoteServerControlCommands < Test::Unit::TestCase
     result = r.slowlog(:len)
     assert_equal 0, result
   end
+
+  def test_client
+    assert_equal r.instance_variable_get(:@client), r._client
+  end
+
+  def test_client_list
+    return if version < "2.4.0"
+
+    keys = [
+     "addr",
+     "fd",
+     "name",
+     "age",
+     "idle",
+     "flags",
+     "db",
+     "sub",
+     "psub",
+     "multi",
+     "qbuf",
+     "qbuf-free",
+     "obl",
+     "oll",
+     "omem",
+     "events",
+     "cmd"
+    ]
+
+    clients = r.client(:list)
+    clients.each do |client|
+      keys.each do |k|
+        msg = "expected #client(:list) to include #{k}"
+        assert client.keys.include?(k), msg
+      end
+    end
+  end
+
+  def test_client_kill
+    return if version < "2.6.9"
+
+    r.client(:setname, 'redis-rb')
+    clients = r.client(:list)
+    i = clients.index {|client| client['name'] == 'redis-rb'}
+    assert_equal "OK", r.client(:kill, clients[i]["addr"])
+
+    clients = r.client(:list)
+    i = clients.index {|client| client['name'] == 'redis-rb'}
+    assert_equal nil, i
+  end
+
+  def test_client_getname_and_setname
+    return if version < "2.6.9"
+
+    assert_equal nil, r.client(:getname)
+
+    r.client(:setname, 'redis-rb')
+    name = r.client(:getname)
+    assert_equal 'redis-rb', name
+  end
 end

data/test/scanning_test.rb

@@ -1,10 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-unless defined?(Enumerator)
-  Enumerator = Enumerable::Enumerator
-end
+require_relative "helper"
 
 class TestScanning < Test::Unit::TestCase
 

data/test/scripting_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestScripting < Test::Unit::TestCase
 

data/test/sentinel_command_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class SentinelCommandsTest < Test::Unit::TestCase
 

data/test/sentinel_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class SentinelTest < Test::Unit::TestCase
 

data/test/sorting_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestSorting < Test::Unit::TestCase
 

data/test/ssl_test.rb

@@ -1,73 +1,69 @@
-# encoding: UTF-8
+require_relative "helper"
 
-if RUBY_VERSION >= "1.9.3"
-  require File.expand_path("helper", File.dirname(__FILE__))
+class SslTest < Test::Unit::TestCase
 
-  class SslTest < Test::Unit::TestCase
+  include Helper::Client
 
-    include Helper::Client
+  driver(:ruby) do
 
-    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
+    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_ssl_blocking
-        RedisMock.start({}, ssl_server_opts("trusted")) do |port|
+    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 })
-          assert_equal redis.set("boom", "a" * 10_000_000), "OK"
+          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
 
-    driver(:hiredis, :synchrony) do
+  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
+    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
 
-    private
+  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")
+  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))
-        }
+    {
+      :ssl => true,
+      :ssl_params => {
+        :cert => OpenSSL::X509::Certificate.new(File.read(ssl_cert)),
+        :key  => OpenSSL::PKey::RSA.new(File.read(ssl_key))
       }
-    end
+    }
+  end
 
-    def ssl_ca_file
-      File.join(cert_path, "trusted-ca.crt")
-    end
+  def ssl_ca_file
+    File.join(cert_path, "trusted-ca.crt")
+  end
 
-    def cert_path
-      File.expand_path("../support/ssl/", __FILE__)
-    end
+  def cert_path
+    File.expand_path("../support/ssl/", __FILE__)
   end
 end

data/test/support/connection/hiredis.rb

@@ -1 +1 @@
-require "support/wire/thread"
+require_relative "../wire/thread"

data/test/support/connection/ruby.rb

@@ -1 +1 @@
-require "support/wire/thread"
+require_relative "../wire/thread"

data/test/support/connection/synchrony.rb

@@ -1,4 +1,4 @@
-require "support/wire/synchrony"
+require_relative "../wire/synchrony"
 
 module Helper
   def around

data/test/synchrony_driver.rb

@@ -1,13 +1,10 @@
-# encoding: UTF-8
+require "em-synchrony"
+require "em-synchrony/connection_pool"
 
-require 'em-synchrony'
-require 'em-synchrony/connection_pool'
+require_relative "../lib/redis"
+require_relative "../lib/redis/connection/synchrony"
 
-require 'redis'
-require 'redis/connection/synchrony'
-
-
-require File.expand_path("./helper", File.dirname(__FILE__))
+require_relative "helper"
 
 PORT    = 6381
 OPTIONS = {:port => PORT, :db => 15}
@@ -55,7 +52,7 @@ EM.synchrony do
   assert_equal "s2", r.lpop("foo")
   assert_equal "s1", r.lpop("foo")
 
-  assert_equal "OK", r.client.call(:quit)
+  assert_equal "OK", r._client.call(:quit)
   assert_equal "PONG", r.ping
 
 

data/test/thread_safety_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestThreadSafety < Test::Unit::TestCase
 

data/test/transactions_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestTransactions < Test::Unit::TestCase
 

data/test/unknown_commands_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestUnknownCommands < Test::Unit::TestCase
 

data/test/url_param_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestUrlParam < Test::Unit::TestCase
 
@@ -9,104 +7,104 @@ class TestUrlParam < Test::Unit::TestCase
   def test_url_defaults_to_______________
     redis = Redis.new
 
-    assert_equal "127.0.0.1", redis.client.host
-    assert_equal 6379, redis.client.port
-    assert_equal 0, redis.client.db
-    assert_equal nil, redis.client.password
+    assert_equal "127.0.0.1", redis._client.host
+    assert_equal 6379, redis._client.port
+    assert_equal 0, redis._client.db
+    assert_equal nil, redis._client.password
   end
 
   def test_allows_to_pass_in_a_url
     redis = Redis.new :url => "redis://:secr3t@foo.com:999/2"
 
-    assert_equal "foo.com", redis.client.host
-    assert_equal 999, redis.client.port
-    assert_equal 2, redis.client.db
-    assert_equal "secr3t", redis.client.password
+    assert_equal "foo.com", redis._client.host
+    assert_equal 999, redis._client.port
+    assert_equal 2, redis._client.db
+    assert_equal "secr3t", redis._client.password
   end
 
   def test_allows_to_pass_in_a_url_with_string_key
     redis = Redis.new "url" => "redis://:secr3t@foo.com:999/2"
 
-    assert_equal "foo.com", redis.client.host
-    assert_equal 999, redis.client.port
-    assert_equal 2, redis.client.db
-    assert_equal "secr3t", redis.client.password
+    assert_equal "foo.com", redis._client.host
+    assert_equal 999, redis._client.port
+    assert_equal 2, redis._client.db
+    assert_equal "secr3t", redis._client.password
   end
 
   def test_unescape_password_from_url
     redis = Redis.new :url => "redis://:secr3t%3A@foo.com:999/2"
 
-    assert_equal "secr3t:", redis.client.password
+    assert_equal "secr3t:", redis._client.password
   end
 
   def test_unescape_password_from_url_with_string_key
     redis = Redis.new "url" => "redis://:secr3t%3A@foo.com:999/2"
 
-    assert_equal "secr3t:", redis.client.password
+    assert_equal "secr3t:", redis._client.password
   end
 
   def test_does_not_unescape_password_when_explicitly_passed
     redis = Redis.new :url => "redis://:secr3t%3A@foo.com:999/2", :password => "secr3t%3A"
 
-    assert_equal "secr3t%3A", redis.client.password
+    assert_equal "secr3t%3A", redis._client.password
   end
 
   def test_does_not_unescape_password_when_explicitly_passed_with_string_key
     redis = Redis.new :url => "redis://:secr3t%3A@foo.com:999/2", "password" => "secr3t%3A"
 
-    assert_equal "secr3t%3A", redis.client.password
+    assert_equal "secr3t%3A", redis._client.password
   end
 
   def test_override_url_if_path_option_is_passed
     redis = Redis.new :url => "redis://:secr3t@foo.com/foo:999/2", :path => "/tmp/redis.sock"
 
-    assert_equal "/tmp/redis.sock", redis.client.path
-    assert_equal nil, redis.client.host
-    assert_equal nil, redis.client.port
+    assert_equal "/tmp/redis.sock", redis._client.path
+    assert_equal nil, redis._client.host
+    assert_equal nil, redis._client.port
   end
 
   def test_override_url_if_path_option_is_passed_with_string_key
     redis = Redis.new :url => "redis://:secr3t@foo.com/foo:999/2", "path" => "/tmp/redis.sock"
 
-    assert_equal "/tmp/redis.sock", redis.client.path
-    assert_equal nil, redis.client.host
-    assert_equal nil, redis.client.port
+    assert_equal "/tmp/redis.sock", redis._client.path
+    assert_equal nil, redis._client.host
+    assert_equal nil, redis._client.port
   end
 
   def test_overrides_url_if_another_connection_option_is_passed
     redis = Redis.new :url => "redis://:secr3t@foo.com:999/2", :port => 1000
 
-    assert_equal "foo.com", redis.client.host
-    assert_equal 1000, redis.client.port
-    assert_equal 2, redis.client.db
-    assert_equal "secr3t", redis.client.password
+    assert_equal "foo.com", redis._client.host
+    assert_equal 1000, redis._client.port
+    assert_equal 2, redis._client.db
+    assert_equal "secr3t", redis._client.password
   end
 
   def test_overrides_url_if_another_connection_option_is_passed_with_string_key
     redis = Redis.new :url => "redis://:secr3t@foo.com:999/2", "port" => 1000
 
-    assert_equal "foo.com", redis.client.host
-    assert_equal 1000, redis.client.port
-    assert_equal 2, redis.client.db
-    assert_equal "secr3t", redis.client.password
+    assert_equal "foo.com", redis._client.host
+    assert_equal 1000, redis._client.port
+    assert_equal 2, redis._client.db
+    assert_equal "secr3t", redis._client.password
   end
 
   def test_does_not_overrides_url_if_a_nil_option_is_passed
     redis = Redis.new :url => "redis://:secr3t@foo.com:999/2", :port => nil
 
-    assert_equal "foo.com", redis.client.host
-    assert_equal 999, redis.client.port
-    assert_equal 2, redis.client.db
-    assert_equal "secr3t", redis.client.password
+    assert_equal "foo.com", redis._client.host
+    assert_equal 999, redis._client.port
+    assert_equal 2, redis._client.db
+    assert_equal "secr3t", redis._client.password
   end
 
   def test_does_not_overrides_url_if_a_nil_option_is_passed_with_string_key
     redis = Redis.new :url => "redis://:secr3t@foo.com:999/2", "port" => nil
 
-    assert_equal "foo.com", redis.client.host
-    assert_equal 999, redis.client.port
-    assert_equal 2, redis.client.db
-    assert_equal "secr3t", redis.client.password
+    assert_equal "foo.com", redis._client.host
+    assert_equal 999, redis._client.port
+    assert_equal 2, redis._client.db
+    assert_equal "secr3t", redis._client.password
   end
 
   def test_does_not_modify_the_passed_options
@@ -122,10 +120,10 @@ class TestUrlParam < Test::Unit::TestCase
 
     redis = Redis.new
 
-    assert_equal "foo.com", redis.client.host
-    assert_equal 999, redis.client.port
-    assert_equal 2, redis.client.db
-    assert_equal "secr3t", redis.client.password
+    assert_equal "foo.com", redis._client.host
+    assert_equal 999, redis._client.port
+    assert_equal 2, redis._client.db
+    assert_equal "secr3t", redis._client.password
 
     ENV.delete("REDIS_URL")
   end
@@ -133,6 +131,6 @@ class TestUrlParam < Test::Unit::TestCase
   def test_defaults_to_localhost
     redis = Redis.new(:url => "redis:///")
 
-    assert_equal "127.0.0.1", redis.client.host
+    assert_equal "127.0.0.1", redis._client.host
   end
 end