redis 3.3.5 → 4.0.0.rc1

data/test/commands_on_value_types_test.rb

@@ -1,12 +1,125 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/value_types"
+require_relative "helper"
 
 class TestCommandsOnValueTypes < Test::Unit::TestCase
 
   include Helper::Client
-  include Lint::ValueTypes
+
+  def test_exists
+    assert_equal false, r.exists("foo")
+
+    r.set("foo", "s1")
+
+    assert_equal true,  r.exists("foo")
+  end
+
+  def test_type
+    assert_equal "none", r.type("foo")
+
+    r.set("foo", "s1")
+
+    assert_equal "string", r.type("foo")
+  end
+
+  def test_keys
+    r.set("f", "s1")
+    r.set("fo", "s2")
+    r.set("foo", "s3")
+
+    assert_equal ["f","fo", "foo"], r.keys("f*").sort
+  end
+
+  def test_expire
+    r.set("foo", "s1")
+    assert r.expire("foo", 2)
+    assert_in_range 0..2, r.ttl("foo")
+  end
+
+  def test_pexpire
+    target_version "2.5.4" do
+      r.set("foo", "s1")
+      assert r.pexpire("foo", 2000)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+  end
+
+  def test_expireat
+    r.set("foo", "s1")
+    assert r.expireat("foo", (Time.now + 2).to_i)
+    assert_in_range 0..2, r.ttl("foo")
+  end
+
+  def test_pexpireat
+    target_version "2.5.4" do
+      r.set("foo", "s1")
+      assert r.pexpireat("foo", (Time.now + 2).to_i * 1_000)
+      assert_in_range 0..2, r.ttl("foo")
+    end
+  end
+
+  def test_persist
+    r.set("foo", "s1")
+    r.expire("foo", 1)
+    r.persist("foo")
+
+    assert(-1 == r.ttl("foo"))
+  end
+
+  def test_ttl
+    r.set("foo", "s1")
+    r.expire("foo", 2)
+    assert_in_range 0..2, r.ttl("foo")
+  end
+
+  def test_pttl
+    target_version "2.5.4" do
+      r.set("foo", "s1")
+      r.expire("foo", 2)
+      assert_in_range 1..2000, r.pttl("foo")
+    end
+  end
+
+  def test_dump_and_restore
+    target_version "2.5.7" do
+      r.set("foo", "a")
+      v = r.dump("foo")
+      r.del("foo")
+
+      assert r.restore("foo", 1000, v)
+      assert_equal "a", r.get("foo")
+      assert [0, 1].include? r.ttl("foo")
+
+      r.rpush("bar", ["b", "c", "d"])
+      w = r.dump("bar")
+      r.del("bar")
+
+      assert r.restore("bar", 1000, w)
+      assert_equal ["b", "c", "d"], r.lrange("bar", 0, -1)
+      assert [0, 1].include? r.ttl("bar")
+    end
+  end
+
+  def test_move
+    r.select 14
+    r.flushdb
+
+    r.set "bar", "s3"
+
+    r.select 15
+
+    r.set "foo", "s1"
+    r.set "bar", "s2"
+
+    assert r.move("foo", 14)
+    assert_equal nil, r.get("foo")
+
+    assert !r.move("bar", 14)
+    assert_equal "s2", r.get("bar")
+
+    r.select 14
+
+    assert_equal "s1", r.get("foo")
+    assert_equal "s3", r.get("bar")
+  end
 
   def test_del
     r.set "foo", "s1"
@@ -111,8 +224,8 @@ class TestCommandsOnValueTypes < Test::Unit::TestCase
       end
       assert ex.message =~ /port not specified/
 
-      default_db = redis.client.db.to_i
-      default_timeout = redis.client.timeout.to_i
+      default_db = redis._client.db.to_i
+      default_timeout = redis._client.timeout.to_i
 
       # Test defaults
       actual = redis.migrate("foo", options)

data/test/connection_handling_test.rb

@@ -1,6 +1,4 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
+require_relative "helper"
 
 class TestConnectionHandling < Test::Unit::TestCase
 
@@ -40,7 +38,7 @@ class TestConnectionHandling < Test::Unit::TestCase
     r.select 14
     assert_equal nil, r.get("foo")
 
-    r.client.disconnect
+    r._client.disconnect
 
     assert_equal nil, r.get("foo")
   end
@@ -48,7 +46,7 @@ class TestConnectionHandling < Test::Unit::TestCase
   def test_quit
     r.quit
 
-    assert !r.client.connected?
+    assert !r._client.connected?
   end
 
   def test_close
@@ -148,7 +146,7 @@ class TestConnectionHandling < Test::Unit::TestCase
       end
 
       assert_equal nil, result
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -188,7 +186,7 @@ class TestConnectionHandling < Test::Unit::TestCase
       end
 
       assert_equal nil, result
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 

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,16 @@
-$:.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/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 +33,11 @@ def init(redis)
 
       Try this once:
 
-        $ rake clean
+        $ make clean
 
       Then run the build again:
 
-        $ rake
+        $ make
 
     EOS
     exit 1
@@ -56,7 +45,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 +81,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,42 +172,8 @@ module Helper
     end
 
     def _new_client(options = {})
-      Redis.new(_format_options(options).merge(:driver => ENV["conn"]))
-    end
-  end
-
-  module Distributed
-
-    include Generic
-
-    def version
-      Version.new(redis.info.first["redis_version"])
-    end
-
-    private
-
-    def _format_options(options)
-      {
-        :timeout => OPTIONS[:timeout],
-        :logger => ::Logger.new(@log),
-      }.merge(options)
-    end
-
-    def _new_client(options = {})
-      Redis::Distributed.new(NODES, _format_options(options).merge(:driver => ENV["conn"]))
+      Redis.new(_format_options(options).merge(:driver => ENV["DRIVER"]))
     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,25 +158,6 @@ 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
-    end
-  end
-
   def close_on_ping(seq, options = {})
     $request = 0
 
@@ -197,7 +215,7 @@ class TestInternals < Test::Unit::TestCase
         redis.ping
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -213,7 +231,7 @@ class TestInternals < Test::Unit::TestCase
         redis.ping
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -226,7 +244,7 @@ class TestInternals < Test::Unit::TestCase
         end
       end
 
-      assert !redis.client.connected?
+      assert !redis._client.connected?
     end
   end
 
@@ -267,14 +285,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 +301,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 +311,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 +319,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 +341,23 @@ 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]
+    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 = 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 1, redis._client.options[:db]
+    assert_equal "foo", redis._client.options[:scheme]
   end
 
   def test_resolves_localhost