redis 3.3.1 → 4.0.1

data/test/ssl_test.rb

@@ -1,66 +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_verified_ssl_connection
-        RedisMock.start({ :ping => proc { "+PONG" } }, 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.ping, "PONG"
+          redis.ping
         end
       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_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
 
-    def ssl_server_opts(prefix)
-      ssl_cert = File.join(cert_path, "#{prefix}-cert.crt")
-      ssl_key  = File.join(cert_path, "#{prefix}-cert.key")
+  private
 
-      {
-        :ssl => true,
-        :ssl_params => {
-          :cert => OpenSSL::X509::Certificate.new(File.read(ssl_cert)),
-          :key  => OpenSSL::PKey::RSA.new(File.read(ssl_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))
       }
-    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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 3.3.1
+  version: 4.0.1
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -16,40 +16,53 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-18 00:00:00.000000000 Z
+date: 2017-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 11.0.0
+        version: 3.1.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 11.0.0
+        version: 3.1.5
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: hiredis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.1.5
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.1.5
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       A Ruby client that tries to match Redis' API one-to-one, while still
-      providing an idiomatic interface. It features thread-safety,
-      client-side sharding, pipelining, and an obsession for performance.
+      providing an idiomatic interface.
 email:
 - redis-db@googlegroups.com
 executables: []
@@ -64,12 +77,12 @@ files:
 - Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - benchmarking/logging.rb
 - benchmarking/pipeline.rb
 - benchmarking/speed.rb
 - benchmarking/suite.rb
 - benchmarking/worker.rb
+- bors.toml
 - examples/basic.rb
 - examples/consistency.rb
 - examples/dist_redis.rb
@@ -96,6 +109,7 @@ files:
 - lib/redis/pipeline.rb
 - lib/redis/subscribe.rb
 - lib/redis/version.rb
+- makefile
 - redis.gemspec
 - test/bitpos_test.rb
 - test/blocking_commands_test.rb
@@ -109,6 +123,7 @@ files:
 - test/commands_on_strings_test.rb
 - test/commands_on_value_types_test.rb
 - test/connection_handling_test.rb
+- test/connection_test.rb
 - test/db/.gitkeep
 - test/distributed_blocking_commands_test.rb
 - test/distributed_commands_on_hashes_test.rb
@@ -186,7 +201,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -211,6 +226,7 @@ test_files:
 - test/commands_on_strings_test.rb
 - test/commands_on_value_types_test.rb
 - test/connection_handling_test.rb
+- test/connection_test.rb
 - test/db/.gitkeep
 - test/distributed_blocking_commands_test.rb
 - test/distributed_commands_on_hashes_test.rb

data/Rakefile

@@ -1,87 +0,0 @@
-require "rake/testtask"
-
-ENV["REDIS_BRANCH"] ||= "unstable"
-
-REDIS_DIR = File.expand_path(File.join("..", "test"), __FILE__)
-REDIS_CNF = File.join(REDIS_DIR, "test.conf")
-REDIS_CNF_TEMPLATE = File.join(REDIS_DIR, "test.conf.erb")
-REDIS_PID = File.join(REDIS_DIR, "db", "redis.pid")
-REDIS_LOG = File.join(REDIS_DIR, "db", "redis.log")
-REDIS_SOCKET = File.join(REDIS_DIR, "db", "redis.sock")
-BINARY = "tmp/redis-#{ENV["REDIS_BRANCH"]}/src/redis-server"
-
-task :default => :run
-
-desc "Run tests and manage server start/stop"
-task :run => [:start, :test, :stop]
-
-desc "Start the Redis server"
-task :start => [BINARY, REDIS_CNF] do
-  sh "#{BINARY} --version"
-
-  redis_running = \
-  begin
-    File.exists?(REDIS_PID) && Process.kill(0, File.read(REDIS_PID).to_i)
-  rescue Errno::ESRCH
-    FileUtils.rm REDIS_PID
-    false
-  end
-
-  unless redis_running
-    unless system("#{BINARY} #{REDIS_CNF}")
-      abort "could not start redis-server"
-    end
-  end
-
-  at_exit do
-    Rake::Task["stop"].invoke
-  end
-end
-
-desc "Stop the Redis server"
-task :stop do
-  if File.exists?(REDIS_PID)
-    Process.kill "INT", File.read(REDIS_PID).to_i
-    FileUtils.rm REDIS_PID
-  end
-end
-
-desc "Clean up testing artifacts"
-task :clean do
-  FileUtils.rm_f(BINARY)
-  FileUtils.rm_f(REDIS_CNF)
-end
-
-file BINARY do
-  branch = ENV.fetch("REDIS_BRANCH")
-
-  sh <<-SH
-  mkdir -p tmp;
-  cd tmp;
-  rm -rf redis-#{branch};
-  wget https://github.com/antirez/redis/archive/#{branch}.tar.gz -O #{branch}.tar.gz;
-  tar xf #{branch}.tar.gz;
-  cd redis-#{branch};
-  make
-  SH
-end
-
-file REDIS_CNF => [REDIS_CNF_TEMPLATE, __FILE__] do |t|
-  require 'erb'
-
-  erb = t.prerequisites[0]
-  template = File.read(erb)
-
-  File.open(REDIS_CNF, 'w') do |file|
-    file.puts "\# This file was auto-generated at #{Time.now}",
-              "\# from (#{erb})",
-              "\#"
-    conf = ERB.new(template).result
-    file << conf
-  end
-end
-
-Rake::TestTask.new do |t|
-  t.options = "-v" if $VERBOSE
-  t.test_files = FileList["test/*_test.rb"]
-end