redis 4.1.0.beta1 → 4.1.0

data/test/test.conf.erb

@@ -1,9 +0,0 @@
-dir <%=        REDIS_DIR %>
-pidfile <%=    REDIS_PID %>
-port 6381
-unixsocket <%= REDIS_SOCKET %>
-timeout 300
-loglevel debug
-logfile <%=    REDIS_LOG %>
-databases 16
-daemonize yes

data/test/thread_safety_test.rb

@@ -1,60 +0,0 @@
-require_relative "helper"
-
-class TestThreadSafety < Test::Unit::TestCase
-
-  include Helper::Client
-
-  driver(:ruby, :hiredis) do
-    def test_thread_safety
-      redis = Redis.new(OPTIONS)
-      redis.set "foo", 1
-      redis.set "bar", 2
-
-      sample = 100
-
-      t1 = Thread.new do
-        $foos = Array.new(sample) { redis.get "foo" }
-      end
-
-      t2 = Thread.new do
-        $bars = Array.new(sample) { redis.get "bar" }
-      end
-
-      t1.join
-      t2.join
-
-      assert_equal ["1"], $foos.uniq
-      assert_equal ["2"], $bars.uniq
-    end
-
-    def test_thread_safety_queue_commit
-      redis = Redis.new(OPTIONS)
-      redis.set "foo", 1
-      redis.set "bar", 2
-
-      sample = 100
-
-      t1 = Thread.new do
-        sample.times do
-          r.queue("get", "foo")
-        end
-
-        $foos = r.commit
-      end
-
-      t2 = Thread.new do
-        sample.times do
-          r.queue("get", "bar")
-        end
-
-        $bars = r.commit
-      end
-
-      t1.join
-      t2.join
-
-      assert_equal ["1"], $foos.uniq
-      assert_equal ["2"], $bars.uniq
-    end
-  end
-end

data/test/transactions_test.rb

@@ -1,272 +0,0 @@
-require_relative "helper"
-
-class TestTransactions < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_multi_discard
-    r.multi
-
-    assert_equal "QUEUED", r.set("foo", "1")
-    assert_equal "QUEUED", r.get("foo")
-
-    r.discard
-
-    assert_equal nil, r.get("foo")
-  end
-
-  def test_multi_exec_with_a_block
-    r.multi do |multi|
-      multi.set "foo", "s1"
-    end
-
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_multi_exec_with_a_block_doesn_t_return_replies_for_multi_and_exec
-    r1, r2, nothing_else = r.multi do |multi|
-      multi.set "foo", "s1"
-      multi.get "foo"
-    end
-
-    assert_equal "OK", r1
-    assert_equal "s1", r2
-    assert_equal nil, nothing_else
-  end
-
-  def test_assignment_inside_multi_exec_block
-    r.multi do |m|
-      @first = m.sadd("foo", 1)
-      @second = m.sadd("foo", 1)
-    end
-
-    assert_equal true, @first.value
-    assert_equal false, @second.value
-  end
-
-  # Although we could support accessing the values in these futures,
-  # it doesn't make a lot of sense.
-  def test_assignment_inside_multi_exec_block_with_delayed_command_errors
-    assert_raise(Redis::CommandError) do
-      r.multi do |m|
-        @first = m.set("foo", "s1")
-        @second = m.incr("foo") # not an integer
-        @third = m.lpush("foo", "value") # wrong kind of value
-      end
-    end
-
-    assert_equal "OK", @first.value
-    assert_raise(Redis::CommandError) { @second.value }
-    assert_raise(Redis::FutureNotReady) { @third.value }
-  end
-
-  def test_assignment_inside_multi_exec_block_with_immediate_command_errors
-    assert_raise(Redis::CommandError) do
-      r.multi do |m|
-        m.doesnt_exist
-        @first = m.sadd("foo", 1)
-        @second = m.sadd("foo", 1)
-      end
-    end
-
-    assert_raise(Redis::FutureNotReady) { @first.value }
-    assert_raise(Redis::FutureNotReady) { @second.value }
-  end
-
-  def test_raise_immediate_errors_in_multi_exec
-    assert_raise(RuntimeError) do
-      r.multi do |multi|
-        multi.set "bar", "s2"
-        raise "Some error"
-        multi.set "baz", "s3"
-      end
-    end
-
-    assert_equal nil, r.get("bar")
-    assert_equal nil, r.get("baz")
-  end
-
-  def test_transformed_replies_as_return_values_for_multi_exec_block
-    info, _ = r.multi do |m|
-      r.info
-    end
-
-    assert info.kind_of?(Hash)
-  end
-
-  def test_transformed_replies_inside_multi_exec_block
-    r.multi do |m|
-      @info = r.info
-    end
-
-    assert @info.value.kind_of?(Hash)
-  end
-
-  def test_raise_command_errors_in_multi_exec
-    assert_raise(Redis::CommandError) do
-      r.multi do |m|
-        m.set("foo", "s1")
-        m.incr("foo") # not an integer
-        m.lpush("foo", "value") # wrong kind of value
-      end
-    end
-
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_empty_multi_exec
-    result = nil
-
-    redis_mock(:exec => lambda { |*_| "-ERROR" }) do |redis|
-      result = redis.multi {}
-    end
-
-    assert_equal [], result
-  end
-
-  def test_raise_command_errors_when_accessing_futures_after_multi_exec
-    begin
-      r.multi do |m|
-        m.set("foo", "s1")
-        @counter = m.incr("foo") # not an integer
-      end
-    rescue Exception
-      # Not gonna deal with it
-    end
-
-    # We should test for Redis::Error here, but hiredis doesn't yet do
-    # custom error classes.
-    err = nil
-    begin
-      @counter.value
-    rescue => err
-    end
-
-    assert err.kind_of?(RuntimeError)
-  end
-
-  def test_multi_with_a_block_yielding_the_client
-    r.multi do |multi|
-      multi.set "foo", "s1"
-    end
-
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_raise_command_error_when_exec_fails
-    redis_mock(:exec => lambda { |*_| "-ERROR" }) do |redis|
-      assert_raise(Redis::CommandError) do
-        redis.multi do |m|
-          m.set "foo", "s1"
-        end
-      end
-    end
-  end
-
-  def test_watch
-    res = r.watch "foo"
-
-    assert_equal "OK", res
-  end
-
-  def test_watch_with_an_unmodified_key
-    r.watch "foo"
-    r.multi do |multi|
-      multi.set "foo", "s1"
-    end
-
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_watch_with_an_unmodified_key_passed_as_array
-    r.watch ["foo", "bar"]
-    r.multi do |multi|
-      multi.set "foo", "s1"
-    end
-
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_watch_with_a_modified_key
-    r.watch "foo"
-    r.set "foo", "s1"
-    res = r.multi do |multi|
-      multi.set "foo", "s2"
-    end
-
-    assert_equal nil, res
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_watch_with_a_modified_key_passed_as_array
-    r.watch ["foo", "bar"]
-    r.set "foo", "s1"
-    res = r.multi do |multi|
-      multi.set "foo", "s2"
-    end
-
-    assert_equal nil, res
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_watch_with_a_block_and_an_unmodified_key
-    result = r.watch "foo" do |rd|
-
-      assert_same r, rd
-
-      rd.multi do |multi|
-        multi.set "foo", "s1"
-      end
-    end
-
-    assert_equal ["OK"], result
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_watch_with_a_block_and_a_modified_key
-    result = r.watch "foo" do |rd|
-
-      assert_same r, rd
-
-      rd.set "foo", "s1"
-      rd.multi do |multi|
-        multi.set "foo", "s2"
-      end
-    end
-
-    assert_equal nil, result
-    assert_equal "s1", r.get("foo")
-  end
-
-  def test_watch_with_a_block_that_raises_an_exception
-    r.set("foo", "s1")
-
-    begin
-      r.watch "foo" do
-        raise "test"
-      end
-    rescue RuntimeError
-    end
-
-    r.set("foo", "s2")
-
-    # If the watch was still set from within the block above, this multi/exec
-    # would fail. This proves that raising an exception above unwatches.
-    r.multi do |multi|
-      multi.set "foo", "s3"
-    end
-
-    assert_equal "s3", r.get("foo")
-  end
-
-  def test_unwatch_with_a_modified_key
-    r.watch "foo"
-    r.set "foo", "s1"
-    r.unwatch
-    r.multi do |multi|
-      multi.set "foo", "s2"
-    end
-
-    assert_equal "s2", r.get("foo")
-  end
-end

data/test/unknown_commands_test.rb

@@ -1,12 +0,0 @@
-require_relative "helper"
-
-class TestUnknownCommands < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_should_try_to_work
-    assert_raise Redis::CommandError do
-      r.not_yet_implemented_command
-    end
-  end
-end

data/test/url_param_test.rb

@@ -1,136 +0,0 @@
-require_relative "helper"
-
-class TestUrlParam < Test::Unit::TestCase
-
-  include Helper::Client
-
-  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
-  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
-  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
-  end
-
-  def test_unescape_password_from_url
-    redis = Redis.new :url => "redis://:secr3t%3A@foo.com:999/2"
-
-    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
-  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
-  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
-  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
-  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
-  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
-  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
-  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
-  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
-  end
-
-  def test_does_not_modify_the_passed_options
-    options = { :url => "redis://:secr3t@foo.com:999/2" }
-
-    Redis.new(options)
-
-    assert({ :url => "redis://:secr3t@foo.com:999/2" } == options)
-  end
-
-  def test_uses_redis_url_over_default_if_available
-    ENV["REDIS_URL"] = "redis://:secr3t@foo.com:999/2"
-
-    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
-
-    ENV.delete("REDIS_URL")
-  end
-
-  def test_defaults_to_localhost
-    redis = Redis.new(:url => "redis:///")
-
-    assert_equal "127.0.0.1", redis._client.host
-  end
-end