redis 3.3.5 → 4.0.0

data/test/distributed_sorting_test.rb

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

data/test/distributed_test.rb

@@ -1,13 +1,11 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestDistributed < Test::Unit::TestCase
 
   include Helper::Distributed
 
   def test_handle_multiple_servers
-    @r = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
+    @r = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
 
     100.times do |idx|
       @r.set(idx.to_s, "foo#{idx}")
@@ -26,19 +24,19 @@ class TestDistributed < Test::Unit::TestCase
 
     @r = Redis::Distributed.new NODES, :logger => logger, :timeout => 10
 
-    assert_equal "127.0.0.1", @r.nodes[0].client.host
-    assert_equal PORT, @r.nodes[0].client.port
-    assert_equal 15, @r.nodes[0].client.db
-    assert_equal 10, @r.nodes[0].client.timeout
-    assert_equal logger, @r.nodes[0].client.logger
+    assert_equal "127.0.0.1", @r.nodes[0]._client.host
+    assert_equal PORT, @r.nodes[0]._client.port
+    assert_equal 15, @r.nodes[0]._client.db
+    assert_equal 10, @r.nodes[0]._client.timeout
+    assert_equal logger, @r.nodes[0]._client.logger
 
     @r.add_node("redis://127.0.0.1:6380/14")
 
-    assert_equal "127.0.0.1", @r.nodes[1].client.host
-    assert_equal 6380, @r.nodes[1].client.port
-    assert_equal 14, @r.nodes[1].client.db
-    assert_equal 10, @r.nodes[1].client.timeout
-    assert_equal logger, @r.nodes[1].client.logger
+    assert_equal "127.0.0.1", @r.nodes[1]._client.host
+    assert_equal 6380, @r.nodes[1]._client.port
+    assert_equal 14, @r.nodes[1]._client.db
+    assert_equal 10, @r.nodes[1]._client.timeout
+    assert_equal logger, @r.nodes[1]._client.logger
   end
 
   def test_pipelining_commands_cannot_be_distributed

data/test/distributed_transactions_test.rb

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

data/test/encoding_test.rb

@@ -1,18 +1,14 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestEncoding < Test::Unit::TestCase
 
   include Helper::Client
 
   def test_returns_properly_encoded_strings
-    if defined?(Encoding)
-      with_external_encoding("UTF-8") do
-        r.set "foo", "שלום"
+    with_external_encoding("UTF-8") do
+      r.set "foo", "שלום"
 
-        assert_equal "Shalom שלום", "Shalom " + r.get("foo")
-      end
+      assert_equal "Shalom שלום", "Shalom " + r.get("foo")
     end
   end
 end

data/test/error_replies_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestErrorReplies < Test::Unit::TestCase
 
@@ -47,7 +45,7 @@ class TestErrorReplies < Test::Unit::TestCase
   def test_recover_from_raise_in__call_loop
     with_reconnection_check do
       begin
-        r.client.call_loop([:invalid_monitor]) do
+        r._client.call_loop([:invalid_monitor]) do
           assert false # Should never be executed
         end
       rescue => ex

data/test/fork_safety_test.rb

@@ -1,11 +1,8 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestForkSafety < Test::Unit::TestCase
 
   include Helper::Client
-  include Helper::Skipable
 
   driver(:ruby, :hiredis) do
     def test_fork_safety
@@ -32,7 +29,6 @@ class TestForkSafety < Test::Unit::TestCase
 
     rescue NotImplementedError => error
       raise unless error.message =~ /fork is not available/
-      return skip(error.message)
     end
 
     def test_fork_safety_with_enabled_inherited_socket
@@ -59,7 +55,6 @@ class TestForkSafety < Test::Unit::TestCase
 
     rescue NotImplementedError => error
       raise unless error.message =~ /fork is not available/
-      return skip(error.message)
     end
   end
 end

data/test/helper.rb

@@ -1,27 +1,17 @@
-$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
-$:.unshift File.expand_path(File.dirname(__FILE__))
-
 require "test/unit"
 require "logger"
 require "stringio"
 
-(class Random; def self.rand(*args) super end; end) unless defined?(Random)
-
-begin
-  require "ruby-debug"
-rescue LoadError
-end
-
 $VERBOSE = true
 
-ENV["conn"] ||= "ruby"
+ENV["DRIVER"] ||= "ruby"
 
-require "redis"
-require "redis/distributed"
-require "redis/connection/#{ENV["conn"]}"
+require_relative "../lib/redis"
+require_relative "../lib/redis/distributed"
+require_relative "../lib/redis/connection/#{ENV["DRIVER"]}"
 
-require "support/redis_mock"
-require "support/connection/#{ENV["conn"]}"
+require_relative "support/redis_mock"
+require_relative "support/connection/#{ENV["DRIVER"]}"
 
 PORT    = 6381
 OPTIONS = {:port => PORT, :db => 15, :timeout => Float(ENV["TIMEOUT"] || 0.1)}
@@ -44,11 +34,11 @@ def init(redis)
 
       Try this once:
 
-        $ rake clean
+        $ make clean
 
       Then run the build again:
 
-        $ rake
+        $ make
 
     EOS
     exit 1
@@ -56,7 +46,7 @@ def init(redis)
 end
 
 def driver(*drivers, &blk)
-  if drivers.map(&:to_s).include?(ENV["conn"])
+  if drivers.map(&:to_s).include?(ENV["DRIVER"])
     class_eval(&blk)
   end
 end
@@ -92,14 +82,6 @@ module Helper
     end
   end
 
-  def try_encoding(encoding, &block)
-    if defined?(Encoding)
-      with_external_encoding(encoding, &block)
-    else
-      yield
-    end
-  end
-
   class Version
 
     include Comparable
@@ -191,7 +173,7 @@ module Helper
     end
 
     def _new_client(options = {})
-      Redis.new(_format_options(options).merge(:driver => ENV["conn"]))
+      Redis.new(_format_options(options).merge(:driver => ENV["DRIVER"]))
     end
   end
 
@@ -216,17 +198,4 @@ module Helper
       Redis::Distributed.new(NODES, _format_options(options).merge(:driver => ENV["conn"]))
     end
   end
-
-  # Basic support for `skip` in 1.8.x
-  # Note: YOU MUST use `return skip(message)` in order to appropriately bail
-  # from a running test.
-  module Skipable
-    Skipped = Class.new(RuntimeError)
-
-    def skip(message = nil, bt = caller)
-      return super if defined?(super)
-
-      $stderr.puts("SKIPPED: #{self} #{message || 'no reason given'}")
-    end
-  end
 end

data/test/helper_test.rb

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

data/test/internals_test.rb

@@ -1,11 +1,8 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestInternals < Test::Unit::TestCase
 
   include Helper::Client
-  include Helper::Skipable
 
   def test_logger
     r.ping
@@ -44,24 +41,28 @@ class TestInternals < Test::Unit::TestCase
     end
   end
 
+  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_redis_current
-    assert_equal "127.0.0.1", Redis.current.client.host
-    assert_equal 6379, Redis.current.client.port
-    assert_equal 0, Redis.current.client.db
+    assert_equal "127.0.0.1", Redis.current._client.host
+    assert_equal 6379, Redis.current._client.port
+    assert_equal 0, Redis.current._client.db
 
     Redis.current = Redis.new(OPTIONS.merge(:port => 6380, :db => 1))
 
     t = Thread.new do
-      assert_equal "127.0.0.1", Redis.current.client.host
-      assert_equal 6380, Redis.current.client.port
-      assert_equal 1, Redis.current.client.db
+      assert_equal "127.0.0.1", Redis.current._client.host
+      assert_equal 6380, Redis.current._client.port
+      assert_equal 1, Redis.current._client.db
     end
 
     t.join
 
-    assert_equal "127.0.0.1", Redis.current.client.host
-    assert_equal 6380, Redis.current.client.port
-    assert_equal 1, Redis.current.client.db
+    assert_equal "127.0.0.1", Redis.current._client.host
+    assert_equal 6380, Redis.current._client.port
+    assert_equal 1, Redis.current._client.db
   end
 
   def test_redis_connected?
@@ -75,12 +76,48 @@ class TestInternals < Test::Unit::TestCase
     assert !fresh_client.connected?
   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._client.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._client.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._client.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._client.id
+  end
+
+  def test_override_id
+    redis = Redis.new(OPTIONS.merge(:id => "test"))
+    assert_equal redis._client.id, "test"
+  end
+
   def test_timeout
     assert_nothing_raised do
       Redis.new(OPTIONS.merge(:timeout => 0))
     end
   end
 
+  def test_id_inside_multi
+    redis = Redis.new(OPTIONS)
+    id = nil
+
+    redis.multi do
+      id = redis.id
+    end
+
+    assert_equal id, "redis://127.0.0.1:6381/15"
+  end
+
   driver(:ruby) do
     def test_tcp_keepalive
       keepalive = {:time => 20, :intvl => 10, :probes => 5}
@@ -88,7 +125,7 @@ class TestInternals < Test::Unit::TestCase
       redis = Redis.new(OPTIONS.merge(:tcp_keepalive => keepalive))
       redis.ping
 
-      connection = redis.client.connection
+      connection = redis._client.connection
       actual_keepalive = connection.get_tcp_keepalive
 
       [:time, :intvl, :probes].each do |key|
@@ -121,22 +158,10 @@ class TestInternals < Test::Unit::TestCase
     assert (Time.now - start_time) <= opts[:timeout]
   end
 
-  driver(:ruby) do
-    def test_write_timeout
-      return skip("Relies on buffer sizes, might be unreliable")
-
-      server = TCPServer.new("127.0.0.1", 0)
-      port   = server.addr[1]
-
-      # Hacky, but we need the buffer size
-      val = TCPSocket.new("127.0.0.1", port).getsockopt(Socket::SOL_SOCKET, Socket::SO_SNDBUF).unpack("i")[0]
-
-      assert_raise(Redis::TimeoutError) do
-        Timeout.timeout(1) do
-          redis = Redis.new(:port => port, :timeout => 5, :write_timeout => 0.1)
-          redis.set("foo", "1" * val*2)
-        end
-      end
+  def test_missing_socket
+    opts = { :path => '/missing.sock' }
+    assert_raise Redis::CannotConnectError do
+      Redis.new(opts).ping
     end
   end
 
@@ -197,7 +222,7 @@ class TestInternals < Test::Unit::TestCase
         redis.ping
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -213,7 +238,7 @@ class TestInternals < Test::Unit::TestCase
         redis.ping
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -226,7 +251,7 @@ class TestInternals < Test::Unit::TestCase
         end
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -267,14 +292,14 @@ class TestInternals < Test::Unit::TestCase
 
   def test_retry_on_write_error_by_default
     close_on_connection([0]) do |redis|
-      assert_equal "1", redis.client.call(["x" * 128 * 1024])
+      assert_equal "1", redis._client.call(["x" * 128 * 1024])
     end
   end
 
   def test_retry_on_write_error_when_wrapped_in_with_reconnect_true
     close_on_connection([0]) do |redis|
       redis.with_reconnect(true) do
-        assert_equal "1", redis.client.call(["x" * 128 * 1024])
+        assert_equal "1", redis._client.call(["x" * 128 * 1024])
       end
     end
   end
@@ -283,7 +308,7 @@ class TestInternals < Test::Unit::TestCase
     close_on_connection([0]) do |redis|
       assert_raise Redis::ConnectionError do
         redis.with_reconnect(false) do
-          redis.client.call(["x" * 128 * 1024])
+          redis._client.call(["x" * 128 * 1024])
         end
       end
     end
@@ -293,7 +318,7 @@ class TestInternals < Test::Unit::TestCase
     close_on_connection([0]) do |redis|
       assert_raise Redis::ConnectionError do
         redis.without_reconnect do
-          redis.client.call(["x" * 128 * 1024])
+          redis._client.call(["x" * 128 * 1024])
         end
       end
     end
@@ -301,7 +326,7 @@ class TestInternals < Test::Unit::TestCase
 
   def test_connecting_to_unix_domain_socket
     assert_nothing_raised do
-      Redis.new(OPTIONS.merge(:path => "./test/db/redis.sock")).ping
+      Redis.new(OPTIONS.merge(:path => ENV.fetch("SOCKET_PATH"))).ping
     end
   end
 
@@ -323,23 +348,10 @@ class TestInternals < Test::Unit::TestCase
   def test_client_options
     redis = Redis.new(OPTIONS.merge(:host => "host", :port => 1234, :db => 1, :scheme => "foo"))
 
-    assert_equal "host", redis.client.options[:host]
-    assert_equal 1234, redis.client.options[:port]
-    assert_equal 1, redis.client.options[:db]
-    assert_equal "foo", redis.client.options[:scheme]
-  end
-
-  def test_does_not_change_self_client_options
-    redis = Redis.new(OPTIONS.merge(:host => "host", :port => 1234, :db => 1, :scheme => "foo"))
-    options = redis.client.options
-
-    options[:host] << "new_host"
-    options[:scheme] << "bar"
-    options.merge!(:db => 0)
-
-    assert_equal "host", redis.client.options[:host]
-    assert_equal 1, redis.client.options[:db]
-    assert_equal "foo", redis.client.options[:scheme]
+    assert_equal "host", redis._client.options[:host]
+    assert_equal 1234, redis._client.options[:port]
+    assert_equal 1, redis._client.options[:db]
+    assert_equal "foo", redis._client.options[:scheme]
   end
 
   def test_resolves_localhost