mock_redis 0.20.0 → 0.25.0

data/lib/mock_redis/hash_methods.rb

@@ -8,14 +8,10 @@ class MockRedis
 
     def hdel(key, *fields)
       with_hash_at(key) do |hash|
-        if fields.is_a?(Array)
-          orig_size = hash.size
-          fields    = fields.map(&:to_s)
-          hash.delete_if { |k, _v| fields.include?(k) }
-          orig_size - hash.size
-        else
-          hash.delete(fields[0].to_s) ? 1 : 0
-        end
+        orig_size = hash.size
+        fields = Array(fields).flatten.map(&:to_s)
+        hash.delete_if { |k, _v| fields.include?(k) }
+        orig_size - hash.size
       end
     end
 
@@ -88,10 +84,17 @@ class MockRedis
     end
 
     def hmset(key, *kvpairs)
+      if key.is_a? Array
+        err_msg = 'ERR wrong number of arguments for \'hmset\' command'
+        kvpairs = key[1..-1]
+        key = key[0]
+      end
+
       kvpairs.flatten!
       assert_has_args(kvpairs, 'hmset')
+
       if kvpairs.length.odd?
-        raise Redis::CommandError, 'ERR wrong number of arguments for HMSET'
+        raise Redis::CommandError, err_msg || 'ERR wrong number of arguments for HMSET'
       end
 
       kvpairs.each_slice(2) do |(k, v)|
@@ -125,10 +128,15 @@ class MockRedis
       end
     end
 
-    def hset(key, field, value)
-      field_exists = hexists(key, field)
-      with_hash_at(key) { |h| h[field.to_s] = value.to_s }
-      !field_exists
+    def hset(key, *args)
+      added = 0
+      with_hash_at(key) do |hash|
+        args.each_slice(2) do |field, value|
+          added += 1 unless hash.key?(field.to_s)
+          hash[field.to_s] = value.to_s
+        end
+      end
+      added
     end
 
     def hsetnx(key, field, value)
@@ -147,7 +155,7 @@ class MockRedis
     private
 
     def with_hash_at(key, &blk)
-      with_thing_at(key, :assert_hashy, proc { {} }, &blk)
+      with_thing_at(key.to_s, :assert_hashy, proc { {} }, &blk)
     end
 
     def hashy?(key)

data/lib/mock_redis/info_method.rb

@@ -83,7 +83,7 @@ class MockRedis
 
     # The Ruby Redis client returns commandstats differently when it's called as
     # "INFO commandstats".
-    # rubocop:disable Metrics/LineLength
+    # rubocop:disable Layout/LineLength
     COMMAND_STATS_SOLO_INFO = {
       'auth' => { 'calls' => '572501', 'usec' => '2353163', 'usec_per_call' => '4.11' },
       'client' => { 'calls' => '1', 'usec' => '80', 'usec_per_call' => '80.00' },
@@ -123,7 +123,7 @@ class MockRedis
       'cmdstat_smembers' => 'calls=58,usec=231,usec_per_call=3.98',
       'cmdstat_sunionstore' => 'calls=4185027,usec=11762454022,usec_per_call=2810.60',
     }.freeze
-    # rubocop:enable Metrics/LineLength
+    # rubocop:enable Layout/LineLength
 
     DEFAULT_INFO = [
       SERVER_INFO,

data/lib/mock_redis/multi_db_wrapper.rb

@@ -24,7 +24,7 @@ class MockRedis
     def initialize_copy(source)
       super
       @databases = @databases.clone
-      @databases.keys.each do |k|
+      @databases.each_key do |k|
         @databases[k] = @databases[k].clone
       end
     end
@@ -39,7 +39,7 @@ class MockRedis
       src = current_db
       dest = db(db_index)
 
-      if !src.exists(key) || dest.exists(key)
+      if !src.exists?(key) || dest.exists?(key)
         false
       else
         case current_db.type(key)

data/lib/mock_redis/set_methods.rb

@@ -117,6 +117,7 @@ class MockRedis
       with_set_at(key) do |s|
         if members.is_a?(Array)
           orig_size = s.size
+          members = members.map(&:to_s)
           s.delete_if { |m| members.include?(m) }
           orig_size - s.size
         else

data/lib/mock_redis/stream.rb

@@ -23,14 +23,29 @@ class MockRedis
 
     def add(id, values)
       @last_id = MockRedis::Stream::Id.new(id, min: @last_id)
+      if @last_id.to_s == '0-0'
+        raise Redis::CommandError,
+              'ERR The ID specified in XADD is equal or smaller than ' \
+              'the target stream top item'
+        # TOOD: Redis version 6.0.4, w redis 4.2.1 generates the following error message:
+        # 'ERR The ID specified in XADD must be greater than 0-0'
+      end
       members.add [@last_id, Hash[values.map { |k, v| [k.to_s, v.to_s] }]]
       @last_id.to_s
     end
 
     def trim(count)
       deleted = @members.size - count
-      @members = @members.to_a[-count..-1].to_set
-      deleted
+      if deleted > 0
+        @members = if count == 0
+                     Set.new
+                   else
+                     @members.to_a[-count..-1].to_set
+                   end
+        deleted
+      else
+        0
+      end
     end
 
     def range(start, finish, reversed, *opts_in)
@@ -45,6 +60,11 @@ class MockRedis
       items
     end
 
+    def read(id)
+      stream_id = MockRedis::Stream::Id.new(id)
+      members.select { |m| (stream_id < m[0]) }.map { |m| [m[0].to_s, m[1]] }
+    end
+
     def each
       members.each { |m| yield m }
     end

data/lib/mock_redis/stream/id.rb

@@ -31,7 +31,7 @@ class MockRedis
             @timestamp = id
           end
           @sequence = @sequence.nil? ? sequence : @sequence.to_i
-          if (@timestamp == 0 && @sequence == 0) || self <= min
+          if self <= min
             raise Redis::CommandError,
                   'ERR The ID specified in XADD is equal or smaller than ' \
                   'the target stream top item'

data/lib/mock_redis/stream_methods.rb

@@ -4,7 +4,6 @@ require 'mock_redis/stream'
 
 # TODO: Implement the following commands
 #
-#   * xread
 #   * xgroup
 #   * xreadgroup
 #   * xack
@@ -67,6 +66,20 @@ class MockRedis
       end
     end
 
+    # TODO: Implement count and block parameters
+    def xread(keys, ids)
+      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])
+          result[key] = data unless data.empty?
+        end
+      end
+      result
+    end
+
     private
 
     def with_stream_at(key, &blk)

data/lib/mock_redis/string_methods.rb

@@ -154,9 +154,10 @@ class MockRedis
     end
 
     def mget(*keys)
+      keys.flatten!
+
       assert_has_args(keys, 'mget')
 
-      keys.flatten!
       keys.map do |key|
         get(key) if stringy?(key)
       end
@@ -188,7 +189,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)
@@ -205,14 +206,14 @@ class MockRedis
       return_true = false
       options = options.dup
       if options.delete(:nx)
-        if exists(key)
+        if exists?(key)
           return false
         else
           return_true = true
         end
       end
       if options.delete(:xx)
-        if exists(key)
+        if exists?(key)
           return_true = true
         else
           return false
@@ -220,15 +221,25 @@ class MockRedis
       end
       data[key] = value.to_s
 
-      # take latter
-      expire_option = options.to_a.last
-      if expire_option
-        type, duration = expire_option
+      duration = options.delete(:ex)
+      if duration
+        if duration == 0
+          raise Redis::CommandError, 'ERR invalid expire time in set'
+        end
+        expire(key, duration)
+      end
+
+      duration = options.delete(:px)
+      if duration
         if duration == 0
           raise Redis::CommandError, 'ERR invalid expire time in set'
         end
-        expire(key, type.to_sym == :ex ? duration : duration / 1000.0)
+        pexpire(key, duration)
       end
+      unless options.empty?
+        raise ArgumentError, "unknown keyword: #{options.keys[0]}"
+      end
+
       return_true ? true : 'OK'
     end
 
@@ -306,13 +317,17 @@ 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 setnx(key, value)
-      if exists(key)
+      if exists?(key)
         false
       else
         set(key, value)

data/lib/mock_redis/transaction_wrapper.rb

@@ -17,7 +17,7 @@ class MockRedis
 
     def method_missing(method, *args, &block)
       if in_multi?
-        future = MockRedis::Future.new([method, *args])
+        future = MockRedis::Future.new([method, *args], block)
         @transaction_futures << future
 
         if @multi_block_given
@@ -60,7 +60,7 @@ class MockRedis
         begin
           result = send(*future.command)
           future.store_result(result)
-          result
+          future.value
         rescue StandardError => e
           e
         end

data/lib/mock_redis/utility_methods.rb

@@ -18,7 +18,7 @@ class MockRedis
     end
 
     def clean_up_empties_at(key)
-      if data[key]&.empty? && data[key] != ''
+      if data[key]&.empty? && data[key] != '' && !data[key].is_a?(Stream)
         del(key)
       end
     end
@@ -28,12 +28,15 @@ class MockRedis
       cursor = cursor.to_i
       match = opts[:match] || '*'
       key = opts[:key] || lambda { |x| x }
+      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))
+        end
       end
 
       [next_cursor, filtered_values]

data/lib/mock_redis/version.rb

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

data/lib/mock_redis/zset_methods.rb

@@ -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]
@@ -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)
@@ -264,7 +282,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 +293,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..-1]), coercible: coercible) do |*sets|
             yield(*([set] + sets))
           end
         end
@@ -295,6 +327,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 +338,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)

data/mock_redis.gemspec

@@ -23,8 +23,7 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 2.4'
 
-  s.add_development_dependency 'rake', '>= 10', '< 12'
-  s.add_development_dependency 'redis', '~>4.1.0'
+  s.add_development_dependency 'redis', '~> 4.2.0'
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rspec-its', '~> 1.0'
   s.add_development_dependency 'timecop', '~> 0.9.1'