redis 4.0.3 → 4.5.0

data/test/commands_on_geo_test.rb

@@ -1,116 +0,0 @@
-require_relative "helper"
-
-class TestCommandsGeo < Test::Unit::TestCase
-  include Helper::Client
-
-  def setup
-    super
-
-    target_version "3.2.0" do
-      added_items_count = r.geoadd("Sicily", 13.361389, 38.115556, "Palermo", 15.087269, 37.502669, "Catania")
-      assert_equal 2, added_items_count
-    end
-  end
-
-  def test_georadius_with_sort
-    target_version "3.2.0" do
-      nearest_cities = r.georadius("Sicily", 15, 37, 200, 'km', sort: 'asc')
-      assert_equal %w(Catania Palermo), nearest_cities
-
-      farthest_cities = r.georadius("Sicily", 15, 37, 200, 'km', sort: 'desc')
-      assert_equal %w(Palermo Catania), farthest_cities
-    end
-  end
-
-  def test_georadius_with_count
-    target_version "3.2.0" do
-      city = r.georadius("Sicily", 15, 37, 200, 'km', count: 1)
-      assert_equal %w(Catania), city
-    end
-  end
-
-  def test_georadius_with_options_count_sort
-    target_version "3.2.0" do
-      city = r.georadius("Sicily", 15, 37, 200, 'km', sort: :desc, options: :WITHDIST, count: 1)
-      assert_equal [["Palermo", "190.4424"]], city
-    end
-  end
-
-  def test_georadiusbymember_with_sort
-    target_version "3.2.0" do
-      nearest_cities = r.georadiusbymember("Sicily", "Catania", 200, 'km', sort: 'asc')
-      assert_equal %w(Catania Palermo), nearest_cities
-
-      farthest_cities = r.georadiusbymember("Sicily", "Catania", 200, 'km', sort: 'desc')
-      assert_equal %w(Palermo Catania), farthest_cities
-    end
-  end
-
-  def test_georadiusbymember_with_count
-    target_version "3.2.0" do
-      city = r.georadiusbymember("Sicily", "Catania", 200, 'km', count: 1)
-      assert_equal %w(Catania), city
-    end
-  end
-
-  def test_georadiusbymember_with_options_count_sort
-    target_version "3.2.0" do
-      city = r.georadiusbymember("Sicily", "Catania", 200, 'km', sort: :desc, options: :WITHDIST, count: 1)
-      assert_equal [["Palermo", "166.2742"]], city
-    end
-  end
-
-  def test_geopos
-    target_version "3.2.0" do
-      location = r.geopos("Sicily", "Catania")
-      assert_equal [["15.08726745843887329", "37.50266842333162032"]], location
-
-      locations = r.geopos("Sicily", ["Palermo", "Catania"])
-      assert_equal [["13.36138933897018433", "38.11555639549629859"], ["15.08726745843887329", "37.50266842333162032"]], locations
-    end
-  end
-
-  def test_geopos_nonexistant_location
-    target_version "3.2.0" do
-      location = r.geopos("Sicily", "Rome")
-      assert_equal [nil], location
-
-      locations = r.geopos("Sicily", ["Rome", "Catania"])
-      assert_equal [nil, ["15.08726745843887329", "37.50266842333162032"]], locations
-    end
-  end
-
-  def test_geodist
-    target_version "3.2.0" do
-      distination_in_meters = r.geodist("Sicily", "Palermo", "Catania")
-      assert_equal "166274.1516", distination_in_meters
-
-      distination_in_feet = r.geodist("Sicily", "Palermo", "Catania", 'ft')
-      assert_equal "545518.8700", distination_in_feet
-    end
-  end
-
-  def test_geodist_with_nonexistant_location
-    target_version "3.2.0" do
-      distination = r.geodist("Sicily", "Palermo", "Rome")
-      assert_equal nil, distination
-    end
-  end
-
-  def test_geohash
-    target_version "3.2.0" do
-      geohash = r.geohash("Sicily", "Palermo")
-      assert_equal ["sqc8b49rny0"], geohash
-
-      geohashes = r.geohash("Sicily", ["Palermo", "Catania"])
-      assert_equal %w(sqc8b49rny0 sqdtr74hyu0), geohashes
-    end
-  end
-
-  def test_geohash_with_nonexistant_location
-    target_version "3.2.0" do
-      geohashes = r.geohash("Sicily", ["Palermo", "Rome"])
-      assert_equal ["sqc8b49rny0", nil], geohashes
-    end
-  end
-end

data/test/commands_on_hashes_test.rb

@@ -1,7 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/hashes'
-
-class TestCommandsOnHashes < Test::Unit::TestCase
-  include Helper::Client
-  include Lint::Hashes
-end

data/test/commands_on_hyper_log_log_test.rb

@@ -1,7 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/hyper_log_log'
-
-class TestCommandsOnHyperLogLog < Test::Unit::TestCase
-  include Helper::Client
-  include Lint::HyperLogLog
-end

data/test/commands_on_lists_test.rb

@@ -1,7 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/lists'
-
-class TestCommandsOnLists < Test::Unit::TestCase
-  include Helper::Client
-  include Lint::Lists
-end

data/test/commands_on_sets_test.rb

@@ -1,7 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/sets'
-
-class TestCommandsOnSets < Test::Unit::TestCase
-  include Helper::Client
-  include Lint::Sets
-end

data/test/commands_on_sorted_sets_test.rb

@@ -1,7 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/sorted_sets'
-
-class TestCommandsOnSortedSets < Test::Unit::TestCase
-  include Helper::Client
-  include Lint::SortedSets
-end

data/test/commands_on_strings_test.rb

@@ -1,7 +0,0 @@
-require_relative 'helper'
-require_relative 'lint/strings'
-
-class TestCommandsOnStrings < Test::Unit::TestCase
-  include Helper::Client
-  include Lint::Strings
-end

data/test/commands_on_value_types_test.rb

@@ -1,207 +0,0 @@
-require_relative "helper"
-require_relative "lint/value_types"
-
-class TestCommandsOnValueTypes < Test::Unit::TestCase
-
-  include Helper::Client
-  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_unlink
-    target_version "4.0.0" do
-      r.set "foo", "s1"
-      r.set "bar", "s2"
-      r.set "baz", "s3"
-
-      assert_equal ["bar", "baz", "foo"], r.keys("*").sort
-
-      assert_equal 1, r.unlink("foo")
-
-      assert_equal ["bar", "baz"], r.keys("*").sort
-
-      assert_equal 2, r.unlink("bar", "baz")
-
-      assert_equal [], r.keys("*").sort
-    end
-  end
-
-  def test_unlink_with_array_argument
-    target_version "4.0.0" do
-      r.set "foo", "s1"
-      r.set "bar", "s2"
-      r.set "baz", "s3"
-
-      assert_equal ["bar", "baz", "foo"], r.keys("*").sort
-
-      assert_equal 1, r.unlink(["foo"])
-
-      assert_equal ["bar", "baz"], r.keys("*").sort
-
-      assert_equal 2, r.unlink(["bar", "baz"])
-
-      assert_equal [], r.keys("*").sort
-    end
-  end
-
-  def test_randomkey
-    assert r.randomkey.to_s.empty?
-
-    r.set("foo", "s1")
-
-    assert_equal "foo", r.randomkey
-
-    r.set("bar", "s2")
-
-    4.times do
-      assert ["foo", "bar"].include?(r.randomkey)
-    end
-  end
-
-  def test_rename
-    r.set("foo", "s1")
-    r.rename "foo", "bar"
-
-    assert_equal "s1", r.get("bar")
-    assert_equal nil, r.get("foo")
-  end
-
-  def test_renamenx
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    assert_equal false, r.renamenx("foo", "bar")
-
-    assert_equal "s1", r.get("foo")
-    assert_equal "s2", 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
-    # Test defaults
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    assert_equal 2, r.dbsize
-
-    r.flushdb
-
-    assert_equal 0, r.dbsize
-
-    # Test sync
-    r.set("foo", "s1")
-    r.set("bar", "s2")
-
-    assert_equal 2, r.dbsize
-
-    r.flushdb(:async => false)
-
-    assert_equal 0, r.dbsize
-
-    # Test async
-    target_version "3.9.101" do
-      r.set("foo", "s1")
-      r.set("bar", "s2")
-
-      assert_equal 2, r.dbsize
-
-      r.flushdb(:async => true)
-
-      assert_equal 0, r.dbsize
-
-      redis_mock(:flushdb => lambda { |args| "+FLUSHDB #{args.upcase}" }) do |redis|
-        assert_equal "FLUSHDB ASYNC", redis.flushdb(:async => true)
-      end
-    end
-  end
-
-  def test_flushall
-    # Test defaults
-    redis_mock(:flushall => lambda { "+FLUSHALL" }) do |redis|
-      assert_equal "FLUSHALL", redis.flushall
-    end
-
-    # Test sync
-    redis_mock(:flushall => lambda { "+FLUSHALL" }) do |redis|
-      assert_equal "FLUSHALL", redis.flushall(:async => false)
-    end
-
-    # Test async
-    target_version "3.9.101" do
-      redis_mock(:flushall => lambda { |args| "+FLUSHALL #{args.upcase}" }) do |redis|
-        assert_equal "FLUSHALL ASYNC", redis.flushall(:async => true)
-      end
-    end
-  end
-
-  def test_migrate
-    redis_mock(:migrate => lambda { |*args| args }) do |redis|
-      options = { :host => "127.0.0.1", :port => 1234 }
-
-      ex = assert_raise(RuntimeError) do
-        redis.migrate("foo", options.reject { |key, _| key == :host })
-      end
-      assert ex.message =~ /host not specified/
-
-      ex = assert_raise(RuntimeError) do
-        redis.migrate("foo", options.reject { |key, _| key == :port })
-      end
-      assert ex.message =~ /port not specified/
-
-      default_db = redis._client.db.to_i
-      default_timeout = redis._client.timeout.to_i
-
-      # Test defaults
-      actual = redis.migrate("foo", options)
-      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, default_timeout.to_s]
-      assert_equal expected, actual
-
-      # Test db override
-      actual = redis.migrate("foo", options.merge(:db => default_db + 1))
-      expected = ["127.0.0.1", "1234", "foo", (default_db + 1).to_s, default_timeout.to_s]
-      assert_equal expected, actual
-
-      # Test timeout override
-      actual = redis.migrate("foo", options.merge(:timeout => default_timeout + 1))
-      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, (default_timeout + 1).to_s]
-      assert_equal expected, actual
-    end
-  end
-end

data/test/connection_handling_test.rb

@@ -1,275 +0,0 @@
-require_relative "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_id
-    commands = {
-      :client => lambda { |cmd, name| $name = [cmd, name]; "+OK" },
-      :ping  => lambda { "+PONG" },
-    }
-
-    redis_mock(commands, :id => "client-name") do |redis|
-      assert_equal "PONG", redis.ping
-    end
-
-    assert_equal ["setname","client-name"], $name
-  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_close
-    quit = 0
-
-    commands = {
-      :quit => lambda do
-        quit += 1
-        "+OK"
-      end
-    }
-
-    redis_mock(commands) do |redis|
-      assert_equal 0, quit
-
-      redis.quit
-
-      assert_equal 1, quit
-
-      redis.ping
-
-      redis.close
-
-      assert_equal 1, quit
-
-      assert !redis.connected?
-    end
-  end
-
-  def test_disconnect
-    quit = 0
-
-    commands = {
-      :quit => lambda do
-        quit += 1
-        "+OK"
-      end
-    }
-
-    redis_mock(commands) do |redis|
-      assert_equal 0, quit
-
-      redis.quit
-
-      assert_equal 1, quit
-
-      redis.ping
-
-      redis.disconnect!
-
-      assert_equal 1, quit
-
-      assert !redis.connected?
-    end
-  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 somehost 6381", redis.slaveof("somehost", 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
-
-  driver(:ruby, :hiredis) do
-    def test_consistency_on_multithreaded_env
-      t = nil
-
-      commands = {
-        :set => lambda { |key, value| t.kill; "+OK\r\n" },
-        :incr => lambda { |key| ":1\r\n" },
-      }
-
-      redis_mock(commands) do |redis|
-        t = Thread.new do
-          redis.set("foo", "bar")
-        end
-
-        t.join
-
-        assert_equal 1, redis.incr("baz")
-      end
-    end
-  end
-end

data/test/connection_test.rb

@@ -1,57 +0,0 @@
-require_relative "helper"
-
-class TestConnection < Test::Unit::TestCase
-
-  include Helper::Client
-
-  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_connection_information
-    assert_equal "127.0.0.1",                 r.connection.fetch(:host)
-    assert_equal 6381,                        r.connection.fetch(:port)
-    assert_equal 15,                          r.connection.fetch(:db)
-    assert_equal "127.0.0.1:6381",            r.connection.fetch(:location)
-    assert_equal "redis://127.0.0.1:6381/15", r.connection.fetch(:id)
-  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.connection.fetch(: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.connection.fetch(: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.connection.fetch(: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.connection.fetch(:id)
-  end
-
-  def test_override_id
-    redis = Redis.new(OPTIONS.merge(:id => "test"))
-    assert_equal "test", redis.connection.fetch(:id)
-  end
-
-  def test_id_inside_multi
-    redis         = Redis.new(OPTIONS)
-    id            = nil
-    connection_id = nil
-
-    redis.multi do
-      id            = redis.id
-      connection_id = redis.connection.fetch(:id)
-    end
-
-    assert_equal "redis://127.0.0.1:6381/15", id
-    assert_equal "redis://127.0.0.1:6381/15", connection_id
-  end
-end