mock_redis 0.46.0 → 0.48.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ced935cd314aee4b33828b9e04c890b4bf4cf36b6e09b93cf6b3b3a3a0bd619a
-  data.tar.gz: def8f4648486a13f063a906df2fade9e33f703e9e5c019516f227049217c64b2
+  metadata.gz: 9b443f014758e0bcf36ab97b1b52c8835e445b6d08c3934f00171a9d0c2ab8b8
+  data.tar.gz: 401f2c621a340ae75c59409943718a6fdcfbb76c816d38651f93d9548e086d71
 SHA512:
-  metadata.gz: c73c851717ac57510e528adad4f5a6f4277abef68338d49be40871bc366937270f90d977c777e18eb0b2d0d0b1e787f3a8e3cd59a51886a57c045f655211cebe
-  data.tar.gz: b47fbb5cffd0d47270915cb786ac50fa30dd00fc1b064d82b1e3d754ad746b2da2a1cbdbc53e5210cd098174b7e1bac2ecbc880ee32576fe24eeea4b7e0376ed
+  metadata.gz: 52ea483bccaab28544bfa90773463085afea971730b8ccb715127cb1815d6de4e007f6d4fac9b055aa2e659720a24618e392a96992875cc77d36d151e9389c32
+  data.tar.gz: 141763ba4434ed736d5f28f50e9ec5b012d040fdf0aaa00c8a11a736165a02db7912624841fb319109bec1465aaeb05a49b48adb6c74b08dbfb1976d715bb031

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # MockRedis Changelog
 
+### 0.48.1
+
+* Fix load issue with `redis-client` gem
+
+### 0.48.0
+
+* Add support for `lmpop` on Redis 7+
+
+### 0.47.0
+
+* Add support for `redis-rb` gem versions 5.x
+* Drop support for `redis-rb` gem versions < 5.x
+
 ### 0.46.0
 
 * Fix `hset` for array of key-value pairs

data/README.md

@@ -10,9 +10,10 @@ for use in tests.
 
 ## Requirements
 
-Ruby 3.0+
+Ruby 3.x
+redis-rb 5.x
 
-The current implementation is tested against Redis 6.2. Older versions may work, but can also return different results or not support some commands.
+The current implementation is **tested against Redis 6.2 and 7.0**. Older versions may work, but can also return different results or not support some commands.
 
 ## Getting Started
 

data/lib/mock_redis/assertions.rb

@@ -1,11 +1,28 @@
+require 'redis-client'
+require 'mock_redis/error'
+
 class MockRedis
+  DUMP_TYPES = RedisClient::RESP3::DUMP_TYPES
+
   module Assertions
     private
 
     def assert_has_args(args, command)
-      unless args.any?
-        raise Redis::CommandError,
-        "ERR wrong number of arguments for '#{command}' command"
+      if args.empty?
+        raise Error.command_error(
+          "ERR wrong number of arguments for '#{command}' command",
+          self
+        )
+      end
+    end
+
+    def assert_type(*args)
+      args.each do |arg|
+        DUMP_TYPES.fetch(arg.class) do |unexpected_class|
+          unless DUMP_TYPES.keys.find { |t| t > unexpected_class }
+            raise TypeError, "Unsupported command argument type: #{unexpected_class}"
+          end
+        end
       end
     end
   end

data/lib/mock_redis/database.rb

@@ -95,13 +95,13 @@ class MockRedis
     end
 
     def expire(key, seconds, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
-      assert_valid_integer(seconds)
+      seconds = Integer(seconds)
 
       pexpire(key, seconds.to_i * 1000, nx: nx, xx: xx, lt: lt, gt: gt)
     end
 
     def pexpire(key, ms, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
-      assert_valid_integer(ms)
+      ms = Integer(ms)
 
       now, miliseconds = @base.now
       now_ms = (now * 1000) + miliseconds
@@ -109,18 +109,19 @@ class MockRedis
     end
 
     def expireat(key, timestamp, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
-      assert_valid_integer(timestamp)
+      timestamp = Integer(timestamp)
 
       pexpireat(key, timestamp.to_i * 1000, nx: nx, xx: xx, lt: lt, gt: gt)
     end
 
     def pexpireat(key, timestamp_ms, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
-      assert_valid_integer(timestamp_ms)
+      timestamp_ms = Integer(timestamp_ms)
 
       if nx && gt || gt && lt || lt && nx || nx && xx
-        raise Redis::CommandError, <<~TXT.chomp
-          ERR NX and XX, GT or LT options at the same time are not compatible
-        TXT
+        raise Error.command_error(
+          'ERR NX and XX, GT or LT options at the same time are not compatible',
+          self
+        )
       end
 
       return false unless exists?(key)
@@ -157,7 +158,7 @@ class MockRedis
 
     def restore(key, ttl, value, replace: false)
       if !replace && exists?(key)
-        raise Redis::CommandError, 'BUSYKEY Target key name already exists.'
+        raise Error.command_error('BUSYKEY Target key name already exists.', self)
       end
       data[key] = Marshal.load(value) # rubocop:disable Security/MarshalLoad
       if ttl > 0
@@ -211,7 +212,7 @@ class MockRedis
 
     def rename(key, newkey)
       unless data.include?(key)
-        raise Redis::CommandError, 'ERR no such key'
+        raise Error.command_error('ERR no such key', self)
       end
 
       if key != newkey
@@ -227,7 +228,7 @@ class MockRedis
 
     def renamenx(key, newkey)
       unless data.include?(key)
-        raise Redis::CommandError, 'ERR no such key'
+        raise Error.command_error('ERR no such key', self)
       end
 
       if exists?(newkey)
@@ -301,19 +302,13 @@ class MockRedis
 
     private
 
-    def assert_valid_integer(integer)
-      unless looks_like_integer?(integer.to_s)
-        raise Redis::CommandError, 'ERR value is not an integer or out of range'
-      end
-      integer
-    end
-
     def assert_valid_timeout(timeout)
-      if !looks_like_integer?(timeout.to_s)
-        raise Redis::CommandError, 'ERR timeout is not an integer or out of range'
-      elsif timeout < 0
-        raise Redis::CommandError, 'ERR timeout is negative'
+      timeout = Integer(timeout)
+
+      if timeout < 0
+        raise ArgumentError, 'time interval must not be negative'
       end
+
       timeout
     end
 
@@ -347,7 +342,7 @@ class MockRedis
     end
 
     def looks_like_integer?(str)
-      str =~ /^-?\d+$/
+      !!Integer(str) rescue false
     end
 
     def looks_like_float?(str)

data/lib/mock_redis/error.rb

@@ -0,0 +1,27 @@
+class MockRedis
+  module Error
+    module_function
+
+    def build(error_class, message, database)
+      connection = database.connection
+      url = "redis://#{connection[:host]}:#{connection[:port]}"
+      error_class.new("#{message} (#{url})")
+    end
+
+    def wrong_type_error(database)
+      build(
+        Redis::WrongTypeError,
+        'WRONGTYPE Operation against a key holding the wrong kind of value',
+        database
+      )
+    end
+
+    def syntax_error(database)
+      command_error('ERR syntax error', database)
+    end
+
+    def command_error(message, database)
+      build(Redis::CommandError, message, database)
+    end
+  end
+end

data/lib/mock_redis/geospatial_methods.rb

@@ -1,3 +1,5 @@
+require 'mock_redis/error'
+
 class MockRedis
   module GeospatialMethods
     LNG_RANGE = (-180..180)
@@ -81,8 +83,7 @@ class MockRedis
       points = args.each_slice(3).to_a
 
       if points.last.size != 3
-        raise Redis::CommandError,
-          "ERR wrong number of arguments for 'geoadd' command"
+        raise Error.command_error("ERR wrong number of arguments for 'geoadd' command", self)
       end
 
       points.map do |point|
@@ -97,13 +98,15 @@ class MockRedis
       unless LNG_RANGE.include?(lng) && LAT_RANGE.include?(lat)
         lng = format('%<long>.6f', long: lng)
         lat = format('%<lat>.6f', lat: lat)
-        raise Redis::CommandError,
-          "ERR invalid longitude,latitude pair #{lng},#{lat}"
+        raise Error.command_error(
+          "ERR invalid longitude,latitude pair #{lng},#{lat}",
+          self
+        )
       end
 
       { key: point[2], lng: lng, lat: lat }
     rescue ArgumentError
-      raise Redis::CommandError, 'ERR value is not a valid float'
+      raise Error.command_error('ERR value is not a valid float', self)
     end
 
     # Returns ZSET score for passed coordinates
@@ -212,8 +215,7 @@ class MockRedis
       unit = unit.to_sym
       return UNITS[unit] if UNITS[unit]
 
-      raise Redis::CommandError,
-        'ERR unsupported unit provided. please use m, km, ft, mi'
+      raise Error.command_error('ERR unsupported unit provided. please use m, km, ft, mi', self)
     end
 
     def geohash_distance(lng1d, lat1d, lng2d, lat2d)

data/lib/mock_redis/hash_methods.rb

@@ -1,5 +1,6 @@
 require 'mock_redis/assertions'
 require 'mock_redis/utility_methods'
+require 'mock_redis/error'
 
 class MockRedis
   module HashMethods
@@ -7,12 +8,16 @@ class MockRedis
     include UtilityMethods
 
     def hdel(key, *fields)
+      assert_type(key)
+
       with_hash_at(key) do |hash|
         orig_size = hash.size
         fields = Array(fields).flatten.map(&:to_s)
 
+        assert_type(*fields)
+
         if fields.empty?
-          raise Redis::CommandError, "ERR wrong number of arguments for 'hdel' command"
+          raise Error.command_error("ERR wrong number of arguments for 'hdel' command", self)
         end
 
         hash.delete_if { |k, _v| fields.include?(k) }
@@ -21,25 +26,31 @@ class MockRedis
     end
 
     def hexists(key, field)
+      assert_type(key, field)
+
       with_hash_at(key) { |h| h.key?(field.to_s) }
     end
 
     def hget(key, field)
+      assert_type(key, field)
+
       with_hash_at(key) { |h| h[field.to_s] }
     end
 
     def hgetall(key)
+      assert_type(key)
+
       with_hash_at(key) { |h| h }
     end
 
     def hincrby(key, field, increment)
+      assert_type(key, field)
+
       with_hash_at(key) do |hash|
         field = field.to_s
+        increment = Integer(increment)
         unless can_incr?(data[key][field])
-          raise Redis::CommandError, 'ERR hash value is not an integer'
-        end
-        unless looks_like_integer?(increment.to_s)
-          raise Redis::CommandError, 'ERR value is not an integer or out of range'
+          raise Error.command_error('ERR hash value is not an integer', self)
         end
 
         new_value = (hash[field] || '0').to_i + increment.to_i
@@ -49,14 +60,13 @@ class MockRedis
     end
 
     def hincrbyfloat(key, field, increment)
+      assert_type(key, field)
+
       with_hash_at(key) do |hash|
         field = field.to_s
+        increment = Float(increment)
         unless can_incr_float?(data[key][field])
-          raise Redis::CommandError, 'ERR hash value is not a float'
-        end
-
-        unless looks_like_float?(increment.to_s)
-          raise Redis::CommandError, 'ERR value is not a valid float'
+          raise Error.command_error('ERR hash value is not a float', self)
         end
 
         new_value = (hash[field] || '0').to_f + increment.to_f
@@ -67,21 +77,28 @@ class MockRedis
     end
 
     def hkeys(key)
+      assert_type(key)
+
       with_hash_at(key, &:keys)
     end
 
     def hlen(key)
+      assert_type(key)
+
       hkeys(key).length
     end
 
     def hmget(key, *fields)
       fields.flatten!
 
+      assert_type(key, *fields)
       assert_has_args(fields, 'hmget')
       fields.map { |f| hget(key, f) }
     end
 
     def mapped_hmget(key, *fields)
+      fields.flatten!
+
       reply = hmget(key, *fields)
       if reply.is_a?(Array)
         Hash[fields.zip(reply)]
@@ -98,10 +115,15 @@ class MockRedis
       end
 
       kvpairs.flatten!
+
+      assert_type(key, *kvpairs)
       assert_has_args(kvpairs, 'hmset')
 
       if kvpairs.length.odd?
-        raise Redis::CommandError, err_msg || 'ERR wrong number of arguments for \'hmset\' command'
+        raise Error.command_error(
+          err_msg || "ERR wrong number of arguments for 'hmset' command",
+          self
+        )
       end
 
       kvpairs.each_slice(2) do |(k, v)|
@@ -111,21 +133,27 @@ class MockRedis
     end
 
     def mapped_hmset(key, hash)
-      kvpairs = hash.to_a.flatten
+      kvpairs = hash.flatten
+
+      assert_type(key, *kvpairs)
       assert_has_args(kvpairs, 'hmset')
       if kvpairs.length.odd?
-        raise Redis::CommandError, "ERR wrong number of arguments for 'hmset' command"
+        raise Error.command_error("ERR wrong number of arguments for 'hmset' command", self)
       end
 
       hmset(key, *kvpairs)
     end
 
     def hscan(key, cursor, opts = {})
+      assert_type(key, cursor)
+
       opts = opts.merge(key: lambda { |x| x[0] })
       common_scan(hgetall(key).to_a, cursor, opts)
     end
 
     def hscan_each(key, opts = {}, &block)
+      assert_type(key)
+
       return to_enum(:hscan_each, key, opts) unless block_given?
       cursor = 0
       loop do
@@ -138,11 +166,15 @@ class MockRedis
     def hset(key, *args)
       added = 0
       args.flatten!(1)
+      assert_type(key)
+
       with_hash_at(key) do |hash|
         if args.length == 1 && args[0].is_a?(Hash)
           args = args[0].to_a.flatten
         end
 
+        assert_type(*args)
+
         args.each_slice(2) do |field, value|
           added += 1 unless hash.key?(field.to_s)
           hash[field.to_s] = value.to_s
@@ -152,6 +184,7 @@ class MockRedis
     end
 
     def hsetnx(key, field, value)
+      assert_type(key, field, value)
       if hget(key, field)
         false
       else
@@ -161,6 +194,8 @@ class MockRedis
     end
 
     def hvals(key)
+      assert_type(key)
+
       with_hash_at(key, &:values)
     end
 
@@ -176,8 +211,7 @@ class MockRedis
 
     def assert_hashy(key)
       unless hashy?(key)
-        raise Redis::CommandError,
-              'WRONGTYPE Operation against a key holding the wrong kind of value'
+        raise Error.wrong_type_error(self)
       end
     end
   end

data/lib/mock_redis/list_methods.rb

@@ -46,9 +46,7 @@ class MockRedis
       end
     end
 
-    def brpoplpush(source, destination, options = {})
-      options = { :timeout => options } if options.is_a?(Integer)
-      timeout = options.is_a?(Hash) && options[:timeout] || 0
+    def brpoplpush(source, destination, timeout: 0)
       assert_valid_timeout(timeout)
 
       if llen(source) > 0
@@ -66,7 +64,7 @@ class MockRedis
 
     def linsert(key, position, pivot, value)
       unless %w[before after].include?(position.to_s)
-        raise Redis::CommandError, 'ERR syntax error'
+        raise Error.command_error('ERR syntax error', self)
       end
 
       assert_listy(key)
@@ -92,6 +90,32 @@ class MockRedis
       with_list_at(key, &:length)
     end
 
+    def lmpop(*keys, **options)
+      keys.each do |key|
+        assert_listy(key)
+      end
+
+      modifier = options.is_a?(Hash) && options[:modifier]&.to_s&.downcase || 'left'
+      count = (options.is_a?(Hash) && options[:count]) || 1
+
+      unless %w[left right].include?(modifier)
+        raise Redis::CommandError, 'ERR syntax error'
+      end
+
+      keys.each do |key|
+        record_count = llen(key)
+        next if record_count.zero?
+
+        values = [count, record_count].min.times.map do
+          modifier == 'left' ? with_list_at(key, &:shift) : with_list_at(key, &:pop)
+        end
+
+        return [key, values]
+      end
+
+      nil
+    end
+
     def lmove(source, destination, wherefrom, whereto)
       assert_listy(source)
       assert_listy(destination)
@@ -99,9 +123,8 @@ class MockRedis
       wherefrom = wherefrom.to_s.downcase
       whereto = whereto.to_s.downcase
 
-      unless %w[left right].include?(wherefrom) && %w[left right].include?(whereto)
-        raise Redis::CommandError, 'ERR syntax error'
-      end
+      assert_where_field(wherefrom, 'where_source')
+      assert_where_field(whereto, 'where_destination')
 
       value = wherefrom == 'left' ? lpop(source) : rpop(source)
       (whereto == 'left' ? lpush(destination, value) : rpush(destination, value)) unless value.nil?
@@ -127,7 +150,7 @@ class MockRedis
     def lpushx(key, value)
       value = [value] unless value.is_a?(Array)
       if value.empty?
-        raise Redis::CommandError, "ERR wrong number of arguments for 'lpushx' command"
+        raise Error.command_error("ERR wrong number of arguments for 'lpushx' command", self)
       end
       assert_listy(key)
       return 0 unless list_at?(key)
@@ -140,10 +163,7 @@ class MockRedis
     end
 
     def lrem(key, count, value)
-      unless looks_like_integer?(count.to_s)
-        raise Redis::CommandError, 'ERR value is not an integer or out of range'
-      end
-      count = count.to_i
+      count = Integer(count)
       value = value.to_s
 
       with_list_at(key) do |list|
@@ -167,12 +187,12 @@ class MockRedis
       assert_listy(key)
 
       unless list_at?(key)
-        raise Redis::CommandError, 'ERR no such key'
+        raise Error.command_error('ERR no such key', self)
       end
 
       index = index.to_i
       unless (0...llen(key)).cover?(index)
-        raise Redis::CommandError, 'ERR index out of range'
+        raise Error.command_error('ERR index out of range', self)
       end
 
       data[key][index] = value.to_s
@@ -211,7 +231,7 @@ class MockRedis
     def rpushx(key, value)
       value = [value] unless value.is_a?(Array)
       if value.empty?
-        raise Redis::CommandError, "ERR wrong number of arguments for 'rpushx' command"
+        raise Error.command_error("ERR wrong number of arguments for 'rpushx' command", self)
       end
       assert_listy(key)
       return 0 unless list_at?(key)
@@ -235,8 +255,13 @@ class MockRedis
     def assert_listy(key)
       unless listy?(key)
         # Not the most helpful error, but it's what redis-rb barfs up
-        raise Redis::CommandError,
-              'WRONGTYPE Operation against a key holding the wrong kind of value'
+        raise Error.wrong_type_error(self)
+      end
+    end
+
+    def assert_where_field(where, argument_name)
+      unless %w[left right].include?(where)
+        raise ArgumentError, "#{argument_name} must be 'LEFT' or 'RIGHT'"
       end
     end
 

data/lib/mock_redis/set_methods.rb

@@ -6,9 +6,10 @@ class MockRedis
     include Assertions
     include UtilityMethods
 
-    def sadd(key, members)
+    def sadd(key, *members)
       members_class = members.class
-      members = Array(members).map(&:to_s)
+      members = Array(members).flatten.map(&:to_s)
+      assert_type(key, *members)
       assert_has_args(members, 'sadd')
 
       with_set_at(key) do |s|
@@ -21,7 +22,7 @@ class MockRedis
           if members_class == Array
             s.size - size_before
           else
-            added
+            added ? 1 : 0
           end
         end
       end
@@ -33,6 +34,7 @@ class MockRedis
     end
 
     def scard(key)
+      assert_type(key)
       with_set_at(key, &:length)
     end
 
@@ -42,6 +44,7 @@ class MockRedis
     end
 
     def sdiffstore(destination, *keys)
+      assert_type(destination, *keys)
       assert_has_args(keys, 'sdiffstore')
       with_set_at(destination) do |set|
         set.replace(sdiff(*keys))
@@ -58,6 +61,7 @@ class MockRedis
     end
 
     def sinterstore(destination, *keys)
+      assert_type(destination, *keys)
       assert_has_args(keys, 'sinterstore')
       with_set_at(destination) do |set|
         set.replace(sinter(*keys))
@@ -66,16 +70,21 @@ class MockRedis
     end
 
     def sismember(key, member)
+      assert_type(key, member)
       with_set_at(key) { |s| s.include?(member.to_s) }
     end
 
     def smismember(key, *members)
+      members.flatten!
+
+      assert_type(key, *members)
       with_set_at(key) do |set|
-        members.flatten.map { |m| set.include?(m.to_s) }
+        members.map { |m| set.include?(m.to_s) }
       end
     end
 
     def smembers(key)
+      assert_type(key)
       with_set_at(key, &:to_a).map(&:dup).reverse
     end
 
@@ -93,6 +102,7 @@ class MockRedis
     end
 
     def spop(key, count = nil)
+      assert_type(key)
       with_set_at(key) do |set|
         if count.nil?
           member = set.first
@@ -112,6 +122,7 @@ class MockRedis
     end
 
     def srandmember(key, count = nil)
+      assert_type(key)
       members = with_set_at(key, &:to_a)
       if count
         if count > 0
@@ -124,7 +135,10 @@ class MockRedis
       end
     end
 
-    def srem(key, members)
+    def srem(key, *members)
+      members = members.flatten.uniq
+      assert_type(key, *members)
+
       with_set_at(key) do |s|
         if members.is_a?(Array)
           orig_size = s.size
@@ -177,6 +191,9 @@ class MockRedis
 
     def with_sets_at(*keys, &blk)
       keys = keys.flatten
+
+      assert_type(*keys)
+
       if keys.length == 1
         with_set_at(keys.first, &blk)
       else
@@ -195,8 +212,7 @@ class MockRedis
     def assert_sety(key)
       unless sety?(key)
         # Not the most helpful error, but it's what redis-rb barfs up
-        raise Redis::CommandError,
-              'WRONGTYPE Operation against a key holding the wrong kind of value'
+        raise Error.wrong_type_error(self)
       end
     end
   end

data/lib/mock_redis/sort_method.rb

@@ -5,7 +5,7 @@ class MockRedis
     include Assertions
 
     def sort(key, options = {})
-      return [] if key.nil?
+      assert_type(key)
 
       enumerable = data[key]
 

data/lib/mock_redis/stream_methods.rb

@@ -35,6 +35,8 @@ class MockRedis
         stream.add id, entry
         stream.trim opts[:maxlen] if opts[:maxlen]
         return stream.last_id
+      rescue Redis::CommandError => e
+        raise Error.command_error(e.message, self)
       end
     end
 
@@ -55,6 +57,8 @@ class MockRedis
       args += ['COUNT', count] if count
       with_stream_at(key) do |stream|
         return stream.range(*args)
+      rescue Redis::CommandError => e
+        raise Error.command_error(e.message, self)
       end
     end
 
@@ -63,6 +67,8 @@ class MockRedis
       args += ['COUNT', count] if count
       with_stream_at(key) do |stream|
         return stream.range(*args)
+      rescue Redis::CommandError => e
+        raise Error.command_error(e.message, self)
       end
     end
 
@@ -94,8 +100,7 @@ class MockRedis
 
     def assert_streamy(key)
       unless streamy?(key)
-        raise Redis::CommandError,
-          'WRONGTYPE Operation against a key holding the wrong kind of value'
+        raise Error.wrong_type_error(self)
       end
     end
   end

data/lib/mock_redis/string_methods.rb

@@ -14,7 +14,7 @@ class MockRedis
 
     def bitfield(*args)
       if args.length < 4
-        raise Redis::CommandError, 'ERR wrong number of arguments for BITFIELD'
+        raise Error.command_error('ERR wrong number of arguments for BITFIELD', self)
       end
 
       key = args.shift
@@ -28,7 +28,7 @@ class MockRedis
           new_overflow_method = args.shift.to_s.downcase
 
           unless %w[wrap sat fail].include? new_overflow_method
-            raise Redis::CommandError, 'ERR Invalid OVERFLOW type specified'
+            raise Error.command_error('ERR Invalid OVERFLOW type specified', self)
           end
 
           overflow_method = new_overflow_method
@@ -41,9 +41,11 @@ class MockRedis
         type_size = type[1..].to_i
 
         if (type_size > 64 && is_signed) || (type_size >= 64 && !is_signed)
-          raise Redis::CommandError,
+          raise Error.command_error(
             'ERR Invalid bitfield type. Use something like i16 u8. ' \
-            'Note that u64 is not supported but i64 is.'
+            'Note that u64 is not supported but i64 is.',
+            self
+          )
         end
 
         if offset.to_s[0] == '#'
@@ -130,12 +132,10 @@ class MockRedis
 
     def incrby(key, n)
       assert_stringy(key)
-      unless can_incr?(data[key])
-        raise Redis::CommandError, 'ERR value is not an integer or out of range'
-      end
+      n = Integer(n)
 
-      unless looks_like_integer?(n.to_s)
-        raise Redis::CommandError, 'ERR value is not an integer or out of range'
+      unless can_incr?(data[key])
+        raise Error.command_error('ERR value is not an integer or out of range', self)
       end
 
       new_value = data[key].to_i + n.to_i
@@ -146,12 +146,9 @@ class MockRedis
 
     def incrbyfloat(key, n)
       assert_stringy(key)
+      n = Float(n)
       unless can_incr_float?(data[key])
-        raise Redis::CommandError, 'ERR value is not a valid float'
-      end
-
-      unless looks_like_float?(n.to_s)
-        raise Redis::CommandError, 'ERR value is not a valid float'
+        raise Error.command_error('ERR value is not a valid float', self)
       end
 
       new_value = data[key].to_f + n.to_f
@@ -181,7 +178,7 @@ class MockRedis
       kvpairs = kvpairs.first if kvpairs.size == 1 && kvpairs.first.is_a?(Enumerable)
 
       if kvpairs.length.odd?
-        raise Redis::CommandError, 'ERR wrong number of arguments for MSET'
+        raise Error.command_error('ERR wrong number of arguments for MSET', self)
       end
 
       kvpairs.each_slice(2) do |(k, v)|
@@ -237,28 +234,28 @@ class MockRedis
       remove_expiration(key) unless keepttl
       if ex
         if ex == 0
-          raise Redis::CommandError, 'ERR invalid expire time in set'
+          raise Error.command_error('ERR invalid expire time in set', self)
         end
         expire(key, ex)
       end
 
       if px
         if px == 0
-          raise Redis::CommandError, 'ERR invalid expire time in set'
+          raise Error.command_error('ERR invalid expire time in set', self)
         end
         pexpire(key, px)
       end
 
       if exat
         if exat == 0
-          raise Redis::CommandError, 'ERR invalid expire time in set'
+          raise Error.command_error('ERR invalid expire time in set', self)
         end
         expireat(key, exat)
       end
 
       if pxat
         if pxat == 0
-          raise Redis::CommandError, 'ERR invalid expire time in set'
+          raise Error.command_error('ERR invalid expire time in set', self)
         end
         pexpireat(key, pxat)
       end
@@ -347,7 +344,7 @@ class MockRedis
 
     def setex(key, seconds, value)
       if seconds <= 0
-        raise Redis::CommandError, 'ERR invalid expire time in setex'
+        raise Error.command_error('ERR invalid expire time in setex', self)
       else
         set(key, value)
         expire(key, seconds)
@@ -357,7 +354,7 @@ class MockRedis
 
     def psetex(key, milliseconds, value)
       if milliseconds <= 0
-        raise Redis::CommandError, 'ERR invalid expire time in psetex'
+        raise Error.command_error('ERR invalid expire time in psetex', self)
       else
         set(key, value)
         pexpire(key, milliseconds)
@@ -377,7 +374,7 @@ class MockRedis
     def setrange(key, offset, value)
       assert_stringy(key)
       value = value.to_s
-      old_value = (data[key] || '')
+      old_value = data[key] || ''
 
       prefix = zero_pad(old_value[0...offset], offset)
       data[key] = prefix + value + (old_value[(offset + value.length)..] || '')
@@ -395,10 +392,13 @@ class MockRedis
       data[key].nil? || data[key].is_a?(String)
     end
 
-    def assert_stringy(key,
-        message = 'WRONGTYPE Operation against a key holding the wrong kind of value')
+    def assert_stringy(key, message = nil)
       unless stringy?(key)
-        raise Redis::CommandError, message
+        if message
+          raise Error.command_error(message, self)
+        else
+          raise Error.wrong_type_error(self)
+        end
       end
     end
 

data/lib/mock_redis/transaction_wrapper.rb

@@ -1,4 +1,5 @@
 require 'mock_redis/undef_redis_methods'
+require 'mock_redis/error'
 
 class MockRedis
   class TransactionWrapper
@@ -12,18 +13,12 @@ class MockRedis
       @db = db
       @transaction_futures = []
       @multi_stack = []
-      @multi_block_given = false
     end
 
     ruby2_keywords def method_missing(method, *args, &block)
       if in_multi?
-        future = MockRedis::Future.new([method, *args], block)
-        @transaction_futures << future
-
-        if @multi_block_given
-          future
-        else
-          'QUEUED'
+        MockRedis::Future.new([method, *args], block).tap do |future|
+          @transaction_futures << future
         end
       else
         @db.expire_keys
@@ -40,7 +35,7 @@ class MockRedis
 
     def discard
       unless in_multi?
-        raise Redis::CommandError, 'ERR DISCARD without MULTI'
+        raise Error.command_error('ERR DISCARD without MULTI', self)
       end
       pop_multi
 
@@ -50,22 +45,23 @@ class MockRedis
 
     def exec
       unless in_multi?
-        raise Redis::CommandError, 'ERR EXEC without MULTI'
+        raise Error.command_error('ERR EXEC without MULTI', self)
       end
+
       pop_multi
       return if in_multi?
-      @multi_block_given = false
 
       responses = @transaction_futures.map do |future|
         result = send(*future.command)
         future.store_result(result)
         future.value
-      rescue StandardError => e
-        e
       end
 
-      @transaction_futures = []
       responses
+    ensure
+      # At this point, multi is done, so we can't call discard anymore.
+      # Therefore, we need to clear the transaction futures manually.
+      @transaction_futures = []
     end
 
     def in_multi?
@@ -81,20 +77,16 @@ class MockRedis
     end
 
     def multi
-      if block_given?
-        push_multi
-        @multi_block_given = true
-        begin
-          yield(self)
-          exec
-        rescue StandardError => e
-          discard
-          raise e
-        end
-      else
-        raise Redis::CommandError, 'ERR MULTI calls can not be nested' if in_multi?
-        push_multi
-        'OK'
+      raise Redis::BaseError, "Can't nest multi transaction" if in_multi?
+
+      push_multi
+
+      begin
+        yield(self)
+        exec
+      rescue StandardError => e
+        discard if in_multi?
+        raise e
       end
     end
 

data/lib/mock_redis/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 class MockRedis
-  VERSION = '0.46.0'
+  VERSION = '0.48.1'
 end

data/lib/mock_redis/zset_methods.rb

@@ -12,7 +12,10 @@ class MockRedis
       zadd_options = args.pop if args.last.is_a?(Hash)
 
       if zadd_options&.include?(:nx) && zadd_options&.include?(:xx)
-        raise Redis::CommandError, 'ERR XX and NX options at the same time are not compatible'
+        raise Error.command_error(
+          'ERR XX and NX options at the same time are not compatible',
+          self
+        )
       end
 
       if args.size == 1 && args[0].is_a?(Array)
@@ -21,7 +24,7 @@ class MockRedis
         score, member = args
         zadd_one_member(key, score, member, zadd_options)
       else
-        raise Redis::CommandError, 'ERR wrong number of arguments'
+        raise ArgumentError, 'wrong number of arguments'
       end
     end
 
@@ -57,12 +60,13 @@ class MockRedis
     private :zadd_one_member
 
     def zadd_multiple_members(key, args, zadd_options = {})
-      assert_has_args(args, 'zadd')
-
       args = args.each_slice(2).to_a unless args.first.is_a?(Array)
       with_zset_at(key) do |zset|
         if zadd_options[:incr]
-          raise Redis::CommandError, 'ERR INCR option supports a single increment-element pair'
+          raise Error.command_error(
+            'ERR INCR option supports a single increment-element pair',
+            self
+          )
         elsif zadd_options[:xx]
           args.each { |score, member| zset.include?(member) && zset.add(score, member.to_s) }
           0
@@ -143,7 +147,7 @@ class MockRedis
       else
         args = args.first
         if args.empty?
-          raise Redis::CommandError, "ERR wrong number of arguments for 'zrem' command"
+          retval = 0
         else
           retval = args.map { |member| !!zscore(key, member.to_s) }.count(true)
           with_zset_at(key) do |z|
@@ -257,7 +261,7 @@ class MockRedis
           offset, count = limit
           collection.drop(offset).take(count)
         else
-          raise Redis::CommandError, 'ERR syntax error'
+          raise Error.syntax_error(self)
         end
       else
         collection
@@ -277,7 +281,7 @@ class MockRedis
     def combine_weighted_zsets(keys, options, how)
       weights = options.fetch(:weights, keys.map { 1 })
       if weights.length != keys.length
-        raise Redis::CommandError, 'ERR syntax error'
+        raise Error.syntax_error(self)
       end
 
       aggregator = case options.fetch(:aggregate, :sum).to_s.downcase.to_sym
@@ -288,7 +292,7 @@ class MockRedis
                    when :max
                      proc { |a, b| [a, b].compact.max }
                    else
-                     raise Redis::CommandError, 'ERR syntax error'
+                     raise Error.syntax_error(self)
                    end
 
       with_zsets_at(*keys, coercible: true) do |*zsets|
@@ -342,15 +346,13 @@ class MockRedis
 
     def assert_zsety(key)
       unless zsety?(key)
-        raise Redis::CommandError,
-          'WRONGTYPE Operation against a key holding the wrong kind of value'
+        raise Error.wrong_type_error(self)
       end
     end
 
     def assert_coercible_zsety(key)
       unless coercible_zsety?(key)
-        raise Redis::CommandError,
-          'WRONGTYPE Operation against a key holding the wrong kind of value'
+        raise Error.wrong_type_error(self)
       end
     end
 
@@ -363,9 +365,10 @@ class MockRedis
       return if value.to_s =~ /\(?(-|\+)inf/
 
       value = $1 if value.to_s =~ /\((.*)/
-      unless looks_like_float?(value)
-        raise Redis::CommandError, message
-      end
+
+      assert_type(value)
+
+      raise Error.command_error(message, self) unless looks_like_float?(value)
     end
 
     def assert_range_args(min, max)

data/lib/mock_redis.rb

@@ -1,6 +1,7 @@
 require 'set'
 
 require 'mock_redis/assertions'
+require 'mock_redis/error'
 require 'mock_redis/database'
 require 'mock_redis/expire_wrapper'
 require 'mock_redis/future'

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mock_redis
 version: !ruby/object:Gem::Version
-  version: 0.46.0
+  version: 0.48.1
 platform: ruby
 authors:
 - Shane da Silva
 - Samuel Merritt
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-11-14 00:00:00.000000000 Z
+date: 2024-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.8.0
+        version: '5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.8.0
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -96,6 +96,7 @@ files:
 - lib/mock_redis/assertions.rb
 - lib/mock_redis/connection_method.rb
 - lib/mock_redis/database.rb
+- lib/mock_redis/error.rb
 - lib/mock_redis/exceptions.rb
 - lib/mock_redis/expire_wrapper.rb
 - lib/mock_redis/future.rb
@@ -124,11 +125,11 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/sds/mock_redis/issues
-  changelog_uri: https://github.com/sds/mock_redis/blob/v0.46.0/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/mock_redis/0.46.0
+  changelog_uri: https://github.com/sds/mock_redis/blob/v0.48.1/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/mock_redis/0.48.1
   homepage_uri: https://github.com/sds/mock_redis
-  source_code_uri: https://github.com/sds/mock_redis/tree/v0.46.0
-post_install_message:
+  source_code_uri: https://github.com/sds/mock_redis/tree/v0.48.1
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -143,8 +144,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Redis mock that just lives in memory; useful for testing.
 test_files: []