mock_redis 0.19.0 → 0.44.0

data/lib/mock_redis/stream_methods.rb

@@ -0,0 +1,102 @@
+require 'mock_redis/assertions'
+require 'mock_redis/utility_methods'
+require 'mock_redis/stream'
+
+# TODO: Implement the following commands
+#
+#   * xgroup
+#   * xreadgroup
+#   * xack
+#   * xpending
+#   * xclaim
+#   * xinfo
+#   * xtrim
+#   * xdel
+#
+# TODO: Complete support for
+#
+#   * xtrim
+#       - `approximate: true` argument is currently ignored
+#   * xadd
+#       - `approximate: true` argument (for capped streams) is currently ignored
+#
+# For details of these commands see
+#   * https://redis.io/topics/streams-intro
+#   * https://redis.io/commands#stream
+
+class MockRedis
+  module StreamMethods
+    include Assertions
+    include UtilityMethods
+
+    def xadd(key, entry, opts = {})
+      id = opts[:id] || '*'
+      with_stream_at(key) do |stream|
+        stream.add id, entry
+        stream.trim opts[:maxlen] if opts[:maxlen]
+        return stream.last_id
+      end
+    end
+
+    def xtrim(key, count)
+      with_stream_at(key) do |stream|
+        stream.trim count
+      end
+    end
+
+    def xlen(key)
+      with_stream_at(key) do |stream|
+        return stream.count
+      end
+    end
+
+    def xrange(key, first = '-', last = '+', count: nil)
+      args = [first, last, false]
+      args += ['COUNT', count] if count
+      with_stream_at(key) do |stream|
+        return stream.range(*args)
+      end
+    end
+
+    def xrevrange(key, last = '+', first = '-', count: nil)
+      args = [first, last, true]
+      args += ['COUNT', count] if count
+      with_stream_at(key) do |stream|
+        return stream.range(*args)
+      end
+    end
+
+    def xread(keys, ids, count: nil, block: nil)
+      args = []
+      args += ['COUNT', count] if count
+      args += ['BLOCK', block.to_i] if block
+      result = {}
+      keys = keys.is_a?(Array) ? keys : [keys]
+      ids = ids.is_a?(Array) ? ids : [ids]
+      keys.each_with_index do |key, index|
+        with_stream_at(key) do |stream|
+          data = stream.read(ids[index], *args)
+          result[key] = data unless data.empty?
+        end
+      end
+      result
+    end
+
+    private
+
+    def with_stream_at(key, &blk)
+      with_thing_at(key, :assert_streamy, proc { Stream.new }, &blk)
+    end
+
+    def streamy?(key)
+      data[key].nil? || data[key].is_a?(Stream)
+    end
+
+    def assert_streamy(key)
+      unless streamy?(key)
+        raise Redis::CommandError,
+          'WRONGTYPE Operation against a key holding the wrong kind of value'
+      end
+    end
+  end
+end

data/lib/mock_redis/string_methods.rb

@@ -38,7 +38,7 @@ class MockRedis
         type, offset = args.shift(2)
 
         is_signed = type.slice(0) == 'i'
-        type_size = type[1..-1].to_i
+        type_size = type[1..].to_i
 
         if (type_size > 64 && is_signed) || (type_size >= 64 && !is_signed)
           raise Redis::CommandError,
@@ -47,7 +47,7 @@ class MockRedis
         end
 
         if offset.to_s[0] == '#'
-          offset = offset[1..-1].to_i * type_size
+          offset = offset[1..].to_i * type_size
         end
 
         bits = []
@@ -85,17 +85,15 @@ class MockRedis
     end
 
     def get(key)
+      key = key.to_s
       assert_stringy(key)
       data[key]
     end
 
-    def [](key)
-      get(key)
-    end
-
     def getbit(key, offset)
       assert_stringy(key)
 
+      offset = offset.to_i
       offset_of_byte = offset / 8
       offset_within_byte = offset % 8
 
@@ -109,6 +107,12 @@ class MockRedis
       end
     end
 
+    def getdel(key)
+      value = get(key)
+      del(key)
+      value
+    end
+
     def getrange(key, start, stop)
       assert_stringy(key)
       (data[key] || '')[start..stop]
@@ -156,12 +160,16 @@ class MockRedis
       new_value
     end
 
-    def mget(*keys)
+    def mget(*keys, &blk)
+      keys.flatten!
+
       assert_has_args(keys, 'mget')
 
-      keys.map do |key|
+      data = keys.map do |key|
         get(key) if stringy?(key)
       end
+
+      blk ? blk.call(data) : data
     end
 
     def mapped_mget(*keys)
@@ -170,6 +178,8 @@ class MockRedis
 
     def mset(*kvpairs)
       assert_has_args(kvpairs, 'mset')
+      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'
       end
@@ -188,7 +198,7 @@ class MockRedis
     def msetnx(*kvpairs)
       assert_has_args(kvpairs, 'msetnx')
 
-      if kvpairs.each_slice(2).any? { |(k, _)| exists(k) }
+      if kvpairs.each_slice(2).any? { |(k, _)| exists?(k) }
         false
       else
         mset(*kvpairs)
@@ -200,18 +210,23 @@ class MockRedis
       msetnx(*hash.to_a.flatten)
     end
 
-    def set(key, value, options = {})
+    # Parameter list required to ensure the ArgumentError is returned correctly
+    # rubocop:disable Metrics/ParameterLists
+    def set(key, value, _hash = nil, ex: nil, px: nil, exat: nil, pxat: nil, nx: nil, xx: nil,
+      keepttl: nil, get: nil)
+      key = key.to_s
+      retval = self.get(key) if get
+
       return_true = false
-      options = options.dup
-      if options.delete(:nx)
-        if exists(key)
+      if nx
+        if exists?(key)
           return false
         else
           return_true = true
         end
       end
-      if options.delete(:xx)
-        if exists(key)
+      if xx
+        if exists?(key)
           return_true = true
         else
           return false
@@ -219,21 +234,42 @@ class MockRedis
       end
       data[key] = value.to_s
 
-      # take latter
-      expire_option = options.to_a.last
-      if expire_option
-        type, duration = expire_option
-        if duration == 0
+      remove_expiration(key) unless keepttl
+      if ex
+        if ex == 0
           raise Redis::CommandError, 'ERR invalid expire time in set'
         end
-        expire(key, type.to_sym == :ex ? duration : duration / 1000.0)
+        expire(key, ex)
+      end
+
+      if px
+        if px == 0
+          raise Redis::CommandError, 'ERR invalid expire time in set'
+        end
+        pexpire(key, px)
+      end
+
+      if exat
+        if exat == 0
+          raise Redis::CommandError, 'ERR invalid expire time in set'
+        end
+        expireat(key, exat)
       end
-      return_true ? true : 'OK'
-    end
 
-    def []=(key, value, options = {})
-      set(key, value, options)
+      if pxat
+        if pxat == 0
+          raise Redis::CommandError, 'ERR invalid expire time in set'
+        end
+        pexpireat(key, pxat)
+      end
+
+      if get
+        retval
+      else
+        return_true ? true : 'OK'
+      end
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def setbit(key, offset, value)
       assert_stringy(key, 'ERR bit is not an integer or out of range')
@@ -241,6 +277,7 @@ class MockRedis
 
       str = data[key] || ''
 
+      offset = offset.to_i
       offset_of_byte = offset / 8
       offset_within_byte = offset % 8
 
@@ -309,13 +346,27 @@ class MockRedis
     end
 
     def setex(key, seconds, value)
-      set(key, value)
-      expire(key, seconds)
-      'OK'
+      if seconds <= 0
+        raise Redis::CommandError, 'ERR invalid expire time in setex'
+      else
+        set(key, value)
+        expire(key, seconds)
+        'OK'
+      end
+    end
+
+    def psetex(key, milliseconds, value)
+      if milliseconds <= 0
+        raise Redis::CommandError, 'ERR invalid expire time in psetex'
+      else
+        set(key, value)
+        pexpire(key, milliseconds)
+        'OK'
+      end
     end
 
     def setnx(key, value)
-      if exists(key)
+      if exists?(key)
         false
       else
         set(key, value)
@@ -329,7 +380,7 @@ class MockRedis
       old_value = (data[key] || '')
 
       prefix = zero_pad(old_value[0...offset], offset)
-      data[key] = prefix + value + (old_value[(offset + value.length)..-1] || '')
+      data[key] = prefix + value + (old_value[(offset + value.length)..] || '')
       data[key].length
     end
 

data/lib/mock_redis/transaction_wrapper.rb

@@ -11,13 +11,13 @@ class MockRedis
     def initialize(db)
       @db = db
       @transaction_futures = []
-      @in_multi = false
+      @multi_stack = []
       @multi_block_given = false
     end
 
-    def method_missing(method, *args, &block)
-      if @in_multi
-        future = MockRedis::Future.new([method, *args])
+    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
@@ -35,45 +35,54 @@ class MockRedis
       super
       @db = @db.clone
       @transaction_futures = @transaction_futures.clone
+      @multi_stack = @multi_stack.clone
     end
 
     def discard
-      unless @in_multi
+      unless in_multi?
         raise Redis::CommandError, 'ERR DISCARD without MULTI'
       end
-      @in_multi = false
-      @multi_block_given = false
+      pop_multi
+
       @transaction_futures = []
       'OK'
     end
 
     def exec
-      unless @in_multi
+      unless in_multi?
         raise Redis::CommandError, 'ERR EXEC without MULTI'
       end
-      @in_multi = false
+      pop_multi
+      return if in_multi?
       @multi_block_given = false
 
       responses = @transaction_futures.map do |future|
-        begin
-          result = send(*future.command)
-          future.store_result(result)
-          result
-        rescue StandardError => e
-          e
-        end
+        result = send(*future.command)
+        future.store_result(result)
+        future.value
+      rescue StandardError => e
+        e
       end
 
       @transaction_futures = []
       responses
     end
 
+    def in_multi?
+      @multi_stack.any?
+    end
+
+    def push_multi
+      @multi_stack.push(@multi_stack.size + 1)
+    end
+
+    def pop_multi
+      @multi_stack.pop
+    end
+
     def multi
-      if @in_multi
-        raise Redis::CommandError, 'ERR MULTI calls can not be nested'
-      end
-      @in_multi = true
       if block_given?
+        push_multi
         @multi_block_given = true
         begin
           yield(self)
@@ -83,6 +92,8 @@ class MockRedis
           raise e
         end
       else
+        raise Redis::CommandError, 'ERR MULTI calls can not be nested' if in_multi?
+        push_multi
         'OK'
       end
     end
@@ -95,7 +106,7 @@ class MockRedis
       'OK'
     end
 
-    def watch(_)
+    def watch(*_)
       if block_given?
         yield self
       else

data/lib/mock_redis/utility_methods.rb

@@ -18,7 +18,7 @@ class MockRedis
     end
 
     def clean_up_empties_at(key)
-      if data[key] && data[key].empty?
+      if data[key]&.empty? && data[key] != '' && !data[key].is_a?(Stream)
         del(key)
       end
     end
@@ -28,12 +28,17 @@ class MockRedis
       cursor = cursor.to_i
       match = opts[:match] || '*'
       key = opts[:key] || lambda { |x| x }
+      type_opt = opts[:type]
+      filtered_values = []
 
       limit = cursor + count
       next_cursor = limit >= values.length ? '0' : limit.to_s
 
-      filtered_values = values[cursor...limit].select do |val|
-        redis_pattern_to_ruby_regex(match).match(key.call(val))
+      unless values[cursor...limit].nil?
+        filtered_values = values[cursor...limit].select do |val|
+          redis_pattern_to_ruby_regex(match).match(key.call(val)) &&
+            (type_opt.nil? || type(val) == type_opt)
+        end
       end
 
       [next_cursor, filtered_values]
@@ -65,7 +70,7 @@ class MockRedis
     end
 
     def left_pad(str, size)
-      str = '0' + str while str.length < size
+      str = "0#{str}" while str.length < size
 
       str
     end

data/lib/mock_redis/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 class MockRedis
-  VERSION = '0.19.0'.freeze
+  VERSION = '0.44.0'
 end

data/lib/mock_redis/zset.rb

@@ -10,9 +10,11 @@ class MockRedis
 
     def_delegators :members, :empty?, :include?, :size
 
-    def initialize
+    def initialize(enum = nil)
       @members = Set.new
-      @scores  = {}
+      @members.merge(enum) if enum
+
+      @scores = {}
     end
 
     def initialize_copy(source)
@@ -23,12 +25,7 @@ class MockRedis
 
     def add(score, member)
       members.add(member)
-      scores[member] =
-        if score.to_f.to_i == score.to_f
-          score.to_f.to_i
-        else
-          score.to_f
-        end
+      scores[member] = score.to_f
       self
     end
 

data/lib/mock_redis/zset_methods.rb

@@ -11,7 +11,7 @@ class MockRedis
       zadd_options = {}
       zadd_options = args.pop if args.last.is_a?(Hash)
 
-      if zadd_options && zadd_options.include?(:nx) && zadd_options.include?(:xx)
+      if zadd_options&.include?(:nx) && zadd_options&.include?(:xx)
         raise Redis::CommandError, 'ERR XX and NX options at the same time are not compatible'
       end
 
@@ -26,7 +26,7 @@ class MockRedis
     end
 
     def zadd_one_member(key, score, member, zadd_options = {})
-      assert_scorey(score) unless score =~ /(\+|\-)inf/
+      assert_scorey(score) unless score.to_s =~ /(\+|-)inf/
 
       with_zset_at(key) do |zset|
         if zadd_options[:incr]
@@ -147,7 +147,7 @@ class MockRedis
         else
           retval = args.map { |member| !!zscore(key, member.to_s) }.count(true)
           with_zset_at(key) do |z|
-            args.each { |member| z.delete?(member) }
+            args.each { |member| z.delete?(member.to_s) }
           end
         end
       end
@@ -155,6 +155,24 @@ class MockRedis
       retval
     end
 
+    def zpopmin(key, count = 1)
+      with_zset_at(key) do |z|
+        pairs = z.sorted.first(count)
+        pairs.each { |pair| z.delete?(pair.last) }
+        retval = to_response(pairs, with_scores: true)
+        count == 1 ? retval.first : retval
+      end
+    end
+
+    def zpopmax(key, count = 1)
+      with_zset_at(key) do |z|
+        pairs = z.sorted.reverse.first(count)
+        pairs.each { |pair| z.delete?(pair.last) }
+        retval = to_response(pairs, with_scores: true)
+        count == 1 ? retval.first : retval
+      end
+    end
+
     def zrevrange(key, start, stop, options = {})
       with_zset_at(key) do |z|
         to_response(z.sorted.reverse[start..stop] || [], options)
@@ -211,7 +229,16 @@ class MockRedis
     def zscore(key, member)
       with_zset_at(key) do |z|
         score = z.score(member.to_s)
-        score.to_f if score
+        score&.to_f
+      end
+    end
+
+    def zmscore(key, *members)
+      with_zset_at(key) do |z|
+        members.map do |member|
+          score = z.score(member.to_s)
+          score&.to_f
+        end
       end
     end
 
@@ -264,7 +291,7 @@ class MockRedis
                      raise Redis::CommandError, 'ERR syntax error'
                    end
 
-      with_zsets_at(*keys) do |*zsets|
+      with_zsets_at(*keys, coercible: true) do |*zsets|
         zsets.zip(weights).map do |(zset, weight)|
           zset.reduce(Zset.new) do |acc, (score, member)|
             acc.add(score * weight, member)
@@ -275,16 +302,30 @@ class MockRedis
       end
     end
 
-    def with_zset_at(key, &blk)
-      with_thing_at(key, :assert_zsety, proc { Zset.new }, &blk)
+    def coerce_to_zset(set)
+      zset = Zset.new
+      set.each do |member|
+        zset.add(1.0, member)
+      end
+      zset
     end
 
-    def with_zsets_at(*keys, &blk)
+    def with_zset_at(key, coercible: false, &blk)
+      if coercible
+        with_thing_at(key, :assert_coercible_zsety, proc { Zset.new }) do |value|
+          blk.call value.is_a?(Set) ? coerce_to_zset(value) : value
+        end
+      else
+        with_thing_at(key, :assert_zsety, proc { Zset.new }, &blk)
+      end
+    end
+
+    def with_zsets_at(*keys, coercible: false, &blk)
       if keys.length == 1
-        with_zset_at(keys.first, &blk)
+        with_zset_at(keys.first, coercible: coercible, &blk)
       else
-        with_zset_at(keys.first) do |set|
-          with_zsets_at(*(keys[1..-1])) do |*sets|
+        with_zset_at(keys.first, coercible: coercible) do |set|
+          with_zsets_at(*(keys[1..]), coercible: coercible) do |*sets|
             yield(*([set] + sets))
           end
         end
@@ -295,6 +336,10 @@ class MockRedis
       data[key].nil? || data[key].is_a?(Zset)
     end
 
+    def coercible_zsety?(key)
+      zsety?(key) || data[key].is_a?(Set)
+    end
+
     def assert_zsety(key)
       unless zsety?(key)
         raise Redis::CommandError,
@@ -302,13 +347,20 @@ class MockRedis
       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'
+      end
+    end
+
     def looks_like_float?(x)
       # ugh, exceptions for flow control.
       !!Float(x) rescue false
     end
 
     def assert_scorey(value, message = 'ERR value is not a valid float')
-      return if value =~ /\(?(\-|\+)inf/
+      return if value.to_s =~ /\(?(-|\+)inf/
 
       value = $1 if value.to_s =~ /\((.*)/
       unless looks_like_float?(value)