redis 3.0.0 → 4.2.2

data/test/connection_handling_test.rb

@@ -1,189 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-
-class TestConnectionHandling < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_auth
-    commands = {
-      :auth => lambda { |password| $auth = password; "+OK" },
-      :get  => lambda { |key| $auth == "secret" ? "$3\r\nbar" : "$-1" },
-    }
-
-    redis_mock(commands, :password => "secret") do |redis|
-      assert_equal "bar", redis.get("foo")
-    end
-  end
-
-  def test_ping
-    assert_equal "PONG", r.ping
-  end
-
-  def test_select
-    r.set "foo", "bar"
-
-    r.select 14
-    assert_equal nil, r.get("foo")
-
-    r.client.disconnect
-
-    assert_equal nil, r.get("foo")
-  end
-
-  def test_quit
-    r.quit
-
-    assert !r.client.connected?
-  end
-
-  def test_shutdown
-    commands = {
-      :shutdown => lambda { :exit }
-    }
-
-    redis_mock(commands) do |redis|
-      # SHUTDOWN does not reply: test that it does not raise here.
-      assert_equal nil, redis.shutdown
-    end
-  end
-
-  def test_shutdown_with_error
-    connections = 0
-    commands = {
-      :select => lambda { |*_| connections += 1; "+OK\r\n" },
-      :connections => lambda { ":#{connections}\r\n" },
-      :shutdown => lambda { "-ERR could not shutdown\r\n" }
-    }
-
-    redis_mock(commands) do |redis|
-      connections = redis.connections
-
-      # SHUTDOWN replies with an error: test that it gets raised
-      assert_raise Redis::CommandError do
-        redis.shutdown
-      end
-
-      # The connection should remain in tact
-      assert_equal connections, redis.connections
-    end
-  end
-
-  def test_shutdown_from_pipeline
-    commands = {
-      :shutdown => lambda { :exit }
-    }
-
-    redis_mock(commands) do |redis|
-      result = redis.pipelined do
-        redis.shutdown
-      end
-
-      assert_equal nil, result
-      assert !redis.client.connected?
-    end
-  end
-
-  def test_shutdown_with_error_from_pipeline
-    connections = 0
-    commands = {
-      :select => lambda { |*_| connections += 1; "+OK\r\n" },
-      :connections => lambda { ":#{connections}\r\n" },
-      :shutdown => lambda { "-ERR could not shutdown\r\n" }
-    }
-
-    redis_mock(commands) do |redis|
-      connections = redis.connections
-
-      # SHUTDOWN replies with an error: test that it gets raised
-      assert_raise Redis::CommandError do
-        redis.pipelined do
-          redis.shutdown
-        end
-      end
-
-      # The connection should remain in tact
-      assert_equal connections, redis.connections
-    end
-  end
-
-  def test_shutdown_from_multi_exec
-    commands = {
-      :multi => lambda { "+OK\r\n" },
-      :shutdown => lambda { "+QUEUED\r\n" },
-      :exec => lambda { :exit }
-    }
-
-    redis_mock(commands) do |redis|
-      result = redis.multi do
-        redis.shutdown
-      end
-
-      assert_equal nil, result
-      assert !redis.client.connected?
-    end
-  end
-
-  def test_shutdown_with_error_from_multi_exec
-    connections = 0
-    commands = {
-      :select => lambda { |*_| connections += 1; "+OK\r\n" },
-      :connections => lambda { ":#{connections}\r\n" },
-      :multi => lambda { "+OK\r\n" },
-      :shutdown => lambda { "+QUEUED\r\n" },
-      :exec => lambda { "*1\r\n-ERR could not shutdown\r\n" }
-    }
-
-    redis_mock(commands) do |redis|
-      connections = redis.connections
-
-      # SHUTDOWN replies with an error: test that it gets returned
-      # We should test for Redis::CommandError here, but hiredis doesn't yet do
-      # custom error classes.
-      err = nil
-
-      begin
-        redis.multi { redis.shutdown }
-      rescue => err
-      end
-
-      assert err.kind_of?(StandardError)
-
-      # The connection should remain intact
-      assert_equal connections, redis.connections
-    end
-  end
-
-  def test_slaveof
-    redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do |redis|
-      assert_equal "SLAVEOF localhost 6381", redis.slaveof("localhost", 6381)
-    end
-  end
-
-  def test_bgrewriteaof
-    redis_mock(:bgrewriteaof => lambda { "+BGREWRITEAOF" }) do |redis|
-      assert_equal "BGREWRITEAOF", redis.bgrewriteaof
-    end
-  end
-
-  def test_config_get
-    assert r.config(:get, "*")["timeout"] != nil
-
-    config = r.config(:get, "timeout")
-    assert_equal ["timeout"], config.keys
-    assert config.values.compact.size > 0
-  end
-
-  def test_config_set
-    begin
-      assert_equal "OK", r.config(:set, "timeout", 200)
-      assert_equal "200", r.config(:get, "*")["timeout"]
-
-      assert_equal "OK", r.config(:set, "timeout", 100)
-      assert_equal "100", r.config(:get, "*")["timeout"]
-    ensure
-      r.config :set, "timeout", 300
-    end
-  end
-end

data/test/db/.gitignore

@@ -1 +0,0 @@
-redis.pid

data/test/distributed_blocking_commands_test.rb

@@ -1,46 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-require "lint/blocking_commands"
-
-class TestDistributedBlockingCommands < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::BlockingCommands
-
-  def test_blpop_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.blpop(["foo", "bar"])
-    end
-  end
-
-  def test_blpop_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.blpop("foo", "bar", 0)
-    end
-  end
-
-  def test_brpop_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpop(["foo", "bar"])
-    end
-  end
-
-  def test_brpop_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpop("foo", "bar", 0)
-    end
-  end
-
-  def test_brpoplpush_raises
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpoplpush("foo", "bar")
-    end
-  end
-
-  def test_brpoplpush_raises_with_old_prototype
-    assert_raises(Redis::Distributed::CannotDistribute) do
-      r.brpoplpush("foo", "bar", 0)
-    end
-  end
-end

data/test/distributed_commands_on_hashes_test.rb

@@ -1,10 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-require "lint/hashes"
-
-class TestDistributedCommandsOnHashes < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::Hashes
-end

data/test/distributed_commands_on_lists_test.rb

@@ -1,22 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-require "lint/lists"
-
-class TestDistributedCommandsOnLists < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::Lists
-
-  def test_rpoplpush
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.rpoplpush("foo", "bar")
-    end
-  end
-
-  def test_brpoplpush
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.brpoplpush("foo", "bar", :timeout => 1)
-    end
-  end
-end

data/test/distributed_commands_on_sets_test.rb

@@ -1,83 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-require "lint/sets"
-
-class TestDistributedCommandsOnSets < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::Sets
-
-  def test_smove
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "bar", "s2"
-
-      r.smove("foo", "bar", "s1")
-    end
-  end
-
-  def test_sinter
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-
-      r.sinter("foo", "bar")
-    end
-  end
-
-  def test_sinterstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-
-      r.sinterstore("baz", "foo", "bar")
-    end
-  end
-
-  def test_sunion
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
-
-      r.sunion("foo", "bar")
-    end
-  end
-
-  def test_sunionstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
-
-      r.sunionstore("baz", "foo", "bar")
-    end
-  end
-
-  def test_sdiff
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
-
-      r.sdiff("foo", "bar")
-    end
-  end
-
-  def test_sdiffstore
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.sadd "foo", "s1"
-      r.sadd "foo", "s2"
-      r.sadd "bar", "s2"
-      r.sadd "bar", "s3"
-
-      r.sdiffstore("baz", "foo", "bar")
-    end
-  end
-end

data/test/distributed_commands_on_sorted_sets_test.rb

@@ -1,18 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-require "lint/sorted_sets"
-
-class TestDistributedCommandsOnSortedSets < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::SortedSets
-
-  def test_zcount
-    r.zadd "foo", 1, "s1"
-    r.zadd "foo", 2, "s2"
-    r.zadd "foo", 3, "s3"
-
-    assert_equal 2, r.zcount("foo", 2, 3)
-  end
-end

data/test/distributed_commands_on_strings_test.rb

@@ -1,48 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-require "lint/strings"
-
-class TestDistributedCommandsOnStrings < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::Strings
-
-  def test_mget
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mget("foo", "bar")
-    end
-  end
-
-  def test_mget_mapped
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mapped_mget("foo", "bar")
-    end
-  end
-
-  def test_mset
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mset(:foo, "s1", :bar, "s2")
-    end
-  end
-
-  def test_mset_mapped
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.mapped_mset(:foo => "s1", :bar => "s2")
-    end
-  end
-
-  def test_msetnx
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.msetnx(:foo, "s2", :bar, "s3")
-    end
-  end
-
-  def test_msetnx_mapped
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.mapped_msetnx(:foo => "s2", :bar => "s3")
-    end
-  end
-end

data/test/distributed_commands_on_value_types_test.rb

@@ -1,87 +0,0 @@
-# encoding: UTF-8
-
-require "helper"
-require "lint/value_types"
-
-class TestDistributedCommandsOnValueTypes < Test::Unit::TestCase
-
-  include Helper::Distributed
-  include Lint::ValueTypes
-
-  def test_del
-    r.set "foo", "s1"
-    r.set "bar", "s2"
-    r.set "baz", "s3"
-
-    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
-
-    assert_equal 1, r.del("foo")
-
-    assert_equal ["bar", "baz"], r.keys("*").sort
-
-    assert_equal 2, r.del("bar", "baz")
-
-    assert_equal [], r.keys("*").sort
-  end
-
-  def test_del_with_array_argument
-    r.set "foo", "s1"
-    r.set "bar", "s2"
-    r.set "baz", "s3"
-
-    assert_equal ["bar", "baz", "foo"], r.keys("*").sort
-
-    assert_equal 1, r.del(["foo"])
-
-    assert_equal ["bar", "baz"], r.keys("*").sort
-
-    assert_equal 2, r.del(["bar", "baz"])
-
-    assert_equal [], r.keys("*").sort
-  end
-
-  def test_randomkey
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.randomkey
-    end
-  end
-
-  def test_rename
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.rename "foo", "bar"
-    end
-
-    assert_equal "s1", r.get("foo")
-    assert_equal nil, r.get("bar")
-  end
-
-  def test_renamenx
-    assert_raise Redis::Distributed::CannotDistribute do
-      r.set("foo", "s1")
-      r.rename "foo", "bar"
-    end
-
-    assert_equal "s1", r.get("foo")
-    assert_equal nil , r.get("bar")
-  end
-
-  def test_dbsize
-    assert_equal [0], r.dbsize
-
-    r.set("foo", "s1")
-
-    assert_equal [1], r.dbsize
-  end
-
-  def test_flushdb
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    assert_equal [2], r.dbsize
-
-    r.flushdb
-
-    assert_equal [0], r.dbsize
-  end
-end