redis 4.1.0.beta1 → 4.1.0

data/test/cluster_commands_on_sets_test.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require_relative 'lint/sets'
-
-# ruby -w -Itest test/cluster_commands_on_sets_test.rb
-# @see https://redis.io/commands#set
-class TestClusterCommandsOnSets < Test::Unit::TestCase
-  include Helper::Cluster
-  include Lint::Sets
-
-  def test_sdiff
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_sdiffstore
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_sinter
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_sinterstore
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_smove
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_sunion
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_sunionstore
-    assert_raise(Redis::CommandError) { super }
-  end
-end

data/test/cluster_commands_on_sorted_sets_test.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require_relative 'lint/sorted_sets'
-
-# ruby -w -Itest test/cluster_commands_on_sorted_sets_test.rb
-# @see https://redis.io/commands#sorted_set
-class TestClusterCommandsOnSortedSets < Test::Unit::TestCase
-  include Helper::Cluster
-  include Lint::SortedSets
-
-  def test_zinterstore
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_zinterstore_with_aggregate
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_zinterstore_with_weights
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_zunionstore
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_zunionstore_with_aggregate
-    assert_raise(Redis::CommandError) { super }
-  end
-
-  def test_zunionstore_with_weights
-    assert_raise(Redis::CommandError) { super }
-  end
-end

data/test/cluster_commands_on_streams_test.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_commands_on_streams_test.rb
-# @see https://redis.io/commands#stream
-class TestClusterCommandsOnStreams < Test::Unit::TestCase
-  include Helper::Cluster
-
-  MIN_REDIS_VERSION = '4.9.0'
-  ENTRY_ID_FORMAT = /\d+-\d+/
-
-  def setup
-    super
-    add_some_entries_to_streams_without_hashtag
-    add_some_entries_to_streams_with_hashtag
-  end
-
-  def add_some_entries_to_streams_without_hashtag
-    target_version(MIN_REDIS_VERSION) do
-      redis.xadd('stream1', '*', 'name', 'John', 'surname', 'Connor')
-      redis.xadd('stream1', '*', 'name', 'Sarah', 'surname', 'Connor')
-      redis.xadd('stream1', '*', 'name', 'Miles', 'surname', 'Dyson')
-      redis.xadd('stream1', '*', 'name', 'Peter', 'surname', 'Silberman')
-    end
-  end
-
-  def add_some_entries_to_streams_with_hashtag
-    target_version(MIN_REDIS_VERSION) do
-      redis.xadd('{stream}1', '*', 'name', 'John', 'surname', 'Connor')
-      redis.xadd('{stream}1', '*', 'name', 'Sarah', 'surname', 'Connor')
-      redis.xadd('{stream}1', '*', 'name', 'Miles', 'surname', 'Dyson')
-      redis.xadd('{stream}1', '*', 'name', 'Peter', 'surname', 'Silberman')
-    end
-  end
-
-  def assert_stream_entry(actual, expected_name, expected_surname)
-    actual_key = actual.keys.first
-    actual_values = actual[actual_key]
-
-    assert_match ENTRY_ID_FORMAT, actual_key
-    assert_equal expected_name, actual_values['name']
-    assert_equal expected_surname, actual_values['surname']
-  end
-
-  def assert_stream_pending(actual, expected_size_of_group, expected_consumer_name, expected_size_of_consumer)
-    assert_equal expected_size_of_group, actual[:size]
-    assert_match ENTRY_ID_FORMAT, actual[:min_entry_id]
-    assert_match ENTRY_ID_FORMAT, actual[:max_entry_id]
-    assert_equal({ expected_consumer_name => expected_size_of_consumer }, actual[:consumers])
-  end
-
-  # TODO: Remove this helper method when we implement streams interfaces
-  def hashify_stream_entries(reply)
-    reply.map do |entry_id, values|
-      [entry_id, Hash[values.each_slice(2).to_a]]
-    end.to_h
-  end
-
-  # TODO: Remove this helper method when we implement streams interfaces
-  def hashify_streams(reply)
-    reply.map do |stream_key, entries|
-      [stream_key, hashify_stream_entries(entries)]
-    end.to_h
-  end
-
-  # TODO: Remove this helper method when we implement streams interfaces
-  def hashify_stream_pendings(reply)
-    {
-      size: reply.first,
-      min_entry_id: reply[1],
-      max_entry_id: reply[2],
-      consumers: Hash[reply[3]]
-    }
-  end
-
-  def test_xadd
-    target_version(MIN_REDIS_VERSION) do
-      assert_match ENTRY_ID_FORMAT, redis.xadd('mystream', '*', 'type', 'T-800', 'model', '101')
-      assert_match ENTRY_ID_FORMAT, redis.xadd('my{stream}', '*', 'type', 'T-1000')
-    end
-  end
-
-  def test_xrange
-    target_version(MIN_REDIS_VERSION) do
-      actual = redis.xrange('stream1', '-', '+', 'COUNT', 1)
-      actual = hashify_stream_entries(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_stream_entry(actual, 'John', 'Connor')
-
-      actual = redis.xrange('{stream}1', '-', '+', 'COUNT', 1)
-      actual = hashify_stream_entries(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_stream_entry(actual, 'John', 'Connor')
-    end
-  end
-
-  def test_xrevrange
-    target_version(MIN_REDIS_VERSION) do
-      actual = redis.xrevrange('stream1', '+', '-', 'COUNT', 1)
-      actual = hashify_stream_entries(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_stream_entry(actual, 'Peter', 'Silberman')
-
-      actual = redis.xrevrange('{stream}1', '+', '-', 'COUNT', 1)
-      actual = hashify_stream_entries(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_stream_entry(actual, 'Peter', 'Silberman')
-    end
-  end
-
-  def test_xlen
-    target_version(MIN_REDIS_VERSION) do
-      assert_equal 4, redis.xlen('stream1')
-      assert_equal 4, redis.xlen('{stream}1')
-    end
-  end
-
-  def test_xread
-    target_version(MIN_REDIS_VERSION) do
-      # non blocking without hashtag
-      actual = redis.xread('COUNT', 1, 'STREAMS', 'stream1', 0)
-      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_equal 'stream1', actual.keys.first
-      assert_stream_entry(actual['stream1'], 'John', 'Connor')
-
-      # blocking without hashtag
-      actual = redis.xread('COUNT', 1, 'BLOCK', 1, 'STREAMS', 'stream1', 0)
-      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_equal 'stream1', actual.keys.first
-      assert_stream_entry(actual['stream1'], 'John', 'Connor')
-
-      # non blocking with hashtag
-      actual = redis.xread('COUNT', 1, 'STREAMS', '{stream}1', 0)
-      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_equal '{stream}1', actual.keys.first
-      assert_stream_entry(actual['{stream}1'], 'John', 'Connor')
-
-      # blocking with hashtag
-      actual = redis.xread('COUNT', 1, 'BLOCK', 1, 'STREAMS', '{stream}1', 0)
-      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_equal '{stream}1', actual.keys.first
-      assert_stream_entry(actual['{stream}1'], 'John', 'Connor')
-    end
-  end
-
-  def test_xreadgroup
-    target_version(MIN_REDIS_VERSION) do
-      # non blocking without hashtag
-      redis.xgroup('create', 'stream1', 'mygroup1', '$')
-      add_some_entries_to_streams_without_hashtag
-      actual = redis.xreadgroup('GROUP', 'mygroup1', 'T-1000', 'COUNT', 1, 'STREAMS', 'stream1', '>')
-      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_equal 'stream1', actual.keys.first
-      assert_stream_entry(actual['stream1'], 'John', 'Connor')
-
-      # blocking without hashtag
-      redis.xgroup('create', 'stream1', 'mygroup2', '$')
-      add_some_entries_to_streams_without_hashtag
-      actual = redis.xreadgroup('GROUP', 'mygroup2', 'T-800', 'COUNT', 1, 'BLOCK', 1, 'STREAMS', 'stream1', '>')
-      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_equal 'stream1', actual.keys.first
-      assert_stream_entry(actual['stream1'], 'John', 'Connor')
-
-      # non blocking with hashtag
-      redis.xgroup('create', '{stream}1', 'mygroup3', '$')
-      add_some_entries_to_streams_with_hashtag
-      actual = redis.xreadgroup('GROUP', 'mygroup3', 'T-1000', 'COUNT', 1, 'STREAMS', '{stream}1', '>')
-      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_equal '{stream}1', actual.keys.first
-      assert_stream_entry(actual['{stream}1'], 'John', 'Connor')
-
-      # blocking with hashtag
-      redis.xgroup('create', '{stream}1', 'mygroup4', '$')
-      add_some_entries_to_streams_with_hashtag
-      actual = redis.xreadgroup('GROUP', 'mygroup4', 'T-800', 'COUNT', 1, 'BLOCK', 1, 'STREAMS', '{stream}1', '>')
-      actual = hashify_streams(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_equal '{stream}1', actual.keys.first
-      assert_stream_entry(actual['{stream}1'], 'John', 'Connor')
-    end
-  end
-
-  def test_xpending
-    target_version(MIN_REDIS_VERSION) do
-      redis.xgroup('create', 'stream1', 'mygroup1', '$')
-      add_some_entries_to_streams_without_hashtag
-      redis.xreadgroup('GROUP', 'mygroup1', 'T-800', 'COUNT', 1, 'STREAMS', 'stream1', '>')
-      actual = redis.xpending('stream1', 'mygroup1')
-      actual = hashify_stream_pendings(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_stream_pending(actual, 1, 'T-800', '1')
-
-      redis.xgroup('create', '{stream}1', 'mygroup2', '$')
-      add_some_entries_to_streams_with_hashtag
-      redis.xreadgroup('GROUP', 'mygroup2', 'T-800', 'COUNT', 1, 'STREAMS', '{stream}1', '>')
-      actual = redis.xpending('{stream}1', 'mygroup2')
-      actual = hashify_stream_pendings(actual) # TODO: Remove this step when we implement streams interfaces
-      assert_stream_pending(actual, 1, 'T-800', '1')
-    end
-  end
-end

data/test/cluster_commands_on_strings_test.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require_relative 'lint/strings'
-
-# ruby -w -Itest test/cluster_commands_on_strings_test.rb
-# @see https://redis.io/commands#string
-class TestClusterCommandsOnStrings < Test::Unit::TestCase
-  include Helper::Cluster
-  include Lint::Strings
-
-  def mock(*args, &block)
-    redis_cluster_mock(*args, &block)
-  end
-end

data/test/cluster_commands_on_transactions_test.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-# ruby -w -Itest test/cluster_commands_on_transactions_test.rb
-# @see https://redis.io/commands#transactions
-class TestClusterCommandsOnTransactions < Test::Unit::TestCase
-  include Helper::Cluster
-
-  def test_discard
-    assert_raise(Redis::Cluster::AmbiguousNodeError) do
-      redis.discard
-    end
-  end
-
-  def test_exec
-    assert_raise(Redis::Cluster::AmbiguousNodeError) do
-      redis.exec
-    end
-  end
-
-  def test_multi
-    assert_raise(Redis::Cluster::AmbiguousNodeError) do
-      redis.multi
-    end
-  end
-
-  def test_unwatch
-    assert_raise(Redis::Cluster::AmbiguousNodeError) do
-      redis.unwatch
-    end
-  end
-
-  def test_watch
-    assert_raise(Redis::CommandError, "CROSSSLOT Keys in request don't hash to the same slot") do
-      redis.watch('key1', 'key2')
-    end
-
-    assert_equal 'OK', redis.watch('{key}1', '{key}2')
-  end
-end

data/test/cluster_commands_on_value_types_test.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-require_relative 'lint/value_types'
-
-# ruby -w -Itest test/cluster_commands_on_value_types_test.rb
-class TestClusterCommandsOnValueTypes < Test::Unit::TestCase
-  include Helper::Cluster
-  include Lint::ValueTypes
-
-  def test_move
-    assert_raise(Redis::CommandError) { super }
-  end
-end

data/test/command_map_test.rb

@@ -1,28 +0,0 @@
-require_relative "helper"
-
-class TestCommandMap < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_override_existing_commands
-    r.set("counter", 1)
-
-    assert_equal 2, r.incr("counter")
-
-    r._client.command_map[:incr] = :decr
-
-    assert_equal 1, r.incr("counter")
-  end
-
-  def test_override_non_existing_commands
-    r.set("key", "value")
-
-    assert_raise Redis::CommandError do
-      r.idontexist("key")
-    end
-
-    r._client.command_map[:idontexist] = :get
-
-    assert_equal "value", r.idontexist("key")
-  end
-end

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