redis 3.0.0 → 4.5.0

data/test/support/wire/synchrony.rb

@@ -1,24 +0,0 @@
-class Wire < Fiber
-  # We cannot run this fiber explicitly because EM schedules it. Resuming the
-  # current fiber on the next tick to let the reactor do work.
-  def self.pass
-    f = Fiber.current
-    EM.next_tick { f.resume }
-    Fiber.yield
-  end
-
-  def self.sleep(sec)
-    EM::Synchrony.sleep(sec)
-  end
-
-  def initialize(&blk)
-    super
-
-    # Schedule run in next tick
-    EM.next_tick { resume }
-  end
-
-  def join
-    self.class.pass while alive?
-  end
-end

data/test/support/wire/thread.rb

@@ -1,5 +0,0 @@
-class Wire < Thread
-  def self.sleep(sec)
-    Kernel.sleep(sec)
-  end
-end

data/test/synchrony_driver.rb

@@ -1,57 +0,0 @@
-# encoding: UTF-8
-
-require 'em-synchrony'
-
-require 'redis'
-require 'redis/connection/synchrony'
-
-require File.expand_path("./helper", File.dirname(__FILE__))
-
-#
-# if running under Eventmachine + Synchrony (Ruby 1.9+), then
-# we can simulate the blocking API while performing the network
-# IO via the EM reactor.
-#
-
-EM.synchrony do
-  r = Redis.new
-  r.flushdb
-
-  r.rpush "foo", "s1"
-  r.rpush "foo", "s2"
-
-  assert_equal 2, r.llen("foo")
-  assert_equal "s2", r.rpop("foo")
-
-  r.set("foo", "bar")
-
-  assert_equal "bar", r.getset("foo", "baz")
-  assert_equal "baz", r.get("foo")
-
-  r.set("foo", "a")
-
-  assert_equal 1, r.getbit("foo", 1)
-  assert_equal 1, r.getbit("foo", 2)
-  assert_equal 0, r.getbit("foo", 3)
-  assert_equal 0, r.getbit("foo", 4)
-  assert_equal 0, r.getbit("foo", 5)
-  assert_equal 0, r.getbit("foo", 6)
-  assert_equal 1, r.getbit("foo", 7)
-
-  r.flushdb
-
-  # command pipelining
-  r.pipelined do
-    r.lpush "foo", "s1"
-    r.lpush "foo", "s2"
-  end
-
-  assert_equal 2, r.llen("foo")
-  assert_equal "s2", r.lpop("foo")
-  assert_equal "s1", r.lpop("foo")
-
-  assert_equal "OK", r.client.call(:quit)
-  assert_equal "PONG", r.ping
-
-  EM.stop
-end

data/test/test.conf

@@ -1,9 +0,0 @@
-dir ./test/db
-pidfile ./redis.pid
-port 6381
-unixsocket /tmp/redis.sock
-timeout 300
-loglevel debug
-logfile stdout
-databases 16
-daemonize yes

data/test/thread_safety_test.rb

@@ -1,32 +0,0 @@
-# encoding: UTF-8
-
-require "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
-  end
-end

data/test/transactions_test.rb

@@ -1,244 +0,0 @@
-# encoding: UTF-8
-
-require "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)
-        m.doesnt_exist
-        @second = m.sadd("foo", 1)
-        m.doesnt_exist
-      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_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_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
-      r.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
-      r.set "foo", "s1"
-      r.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,14 +0,0 @@
-# encoding: UTF-8
-
-require "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,64 +0,0 @@
-# encoding: UTF-8
-
-require "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_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_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_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
-end