mock_redis 0.19.0 → 0.44.0

data/lib/mock_redis/geospatial_methods.rb

@@ -12,7 +12,7 @@ class MockRedis
     D_R = Math::PI / 180.0
     EARTH_RADIUS_IN_METERS = 6_372_797.560856
 
-    def geoadd(key, *args)
+    ruby2_keywords def geoadd(key, *args)
       points = parse_points(args)
 
       scored_points = points.map do |point|
@@ -23,21 +23,13 @@ class MockRedis
       zadd(key, scored_points)
     end
 
-    def geodist(key, *args)
-      if args.length < 2
-        raise Redis::CommandError,
-          "ERR wrong number of arguments for 'geodist' command"
-      end
-
-      raise Redis::CommandError, 'ERR syntax error' if args.length > 3
-
-      to_meter = 1
-      to_meter = parse_unit(args[2]) if args.length == 3
+    def geodist(key, member1, member2, unit = 'm')
+      to_meter = parse_unit(unit)
 
       return nil if zcard(key).zero?
 
-      score1 = zscore(key, args[0])
-      score2 = zscore(key, args[1])
+      score1 = zscore(key, member1)
+      score2 = zscore(key, member2)
       return nil if score1.nil? || score2.nil?
       hash1 = { bits: score1.to_i, step: STEP }
       hash2 = { bits: score2.to_i, step: STEP }
@@ -46,15 +38,15 @@ class MockRedis
       lng2, lat2 = geohash_decode(hash2)
 
       distance = geohash_distance(lng1, lat1, lng2, lat2) / to_meter
-      format('%.4f', distance)
+      format('%<distance>.4f', distance: distance)
     end
 
-    def geohash(key, *members)
+    def geohash(key, members)
       lng_range = (-180..180)
       lat_range = (-90..90)
       geoalphabet = '0123456789bcdefghjkmnpqrstuvwxyz'
 
-      members.map do |member|
+      Array(members).map do |member|
         score = zscore(key, member)
         next nil unless score
         score = score.to_i
@@ -71,8 +63,8 @@ class MockRedis
       end
     end
 
-    def geopos(key, *members)
-      members.map do |member|
+    def geopos(key, members)
+      Array(members).map do |member|
         score = zscore(key, member)
         next nil unless score
         hash = { bits: score.to_i, step: STEP }
@@ -103,8 +95,8 @@ class MockRedis
       lat = Float(point[1])
 
       unless LNG_RANGE.include?(lng) && LAT_RANGE.include?(lat)
-        lng = format('%.6f', lng)
-        lat = format('%.6f', lat)
+        lng = format('%<long>.6f', long: lng)
+        lat = format('%<lat>.6f', lat: lat)
         raise Redis::CommandError,
           "ERR invalid longitude,latitude pair #{lng},#{lat}"
       end
@@ -209,7 +201,7 @@ class MockRedis
     end
 
     def format_decoded_coord(coord)
-      coord = format('%.17f', coord)
+      coord = format('%<coord>.17f', coord: coord)
       l = 1
       l += 1 while coord[-l] == '0'
       coord = coord[0..-l]

data/lib/mock_redis/hash_methods.rb

@@ -6,16 +6,17 @@ class MockRedis
     include Assertions
     include UtilityMethods
 
-    def hdel(key, field)
+    def hdel(key, *fields)
       with_hash_at(key) do |hash|
-        if field.is_a?(Array)
-          orig_size = hash.size
-          fields    = field.map(&:to_s)
-          hash.delete_if { |k, _v| fields.include?(k) }
-          orig_size - hash.size
-        else
-          hash.delete(field.to_s) ? 1 : 0
+        orig_size = hash.size
+        fields = Array(fields).flatten.map(&:to_s)
+
+        if fields.empty?
+          raise Redis::CommandError, "ERR wrong number of arguments for 'hdel' command"
         end
+
+        hash.delete_if { |k, _v| fields.include?(k) }
+        orig_size - hash.size
       end
     end
 
@@ -74,8 +75,10 @@ class MockRedis
     end
 
     def hmget(key, *fields)
+      fields.flatten!
+
       assert_has_args(fields, 'hmget')
-      fields.flatten.map { |f| hget(key, f) }
+      fields.map { |f| hget(key, f) }
     end
 
     def mapped_hmget(key, *fields)
@@ -88,10 +91,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..]
+        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\' command'
       end
 
       kvpairs.each_slice(2) do |(k, v)|
@@ -125,10 +135,19 @@ 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|
+        if args.length == 1 && args[0].is_a?(Hash)
+          args = args[0].to_a.flatten
+        end
+
+        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 +166,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/indifferent_hash.rb

@@ -1,13 +1,5 @@
 class MockRedis
   class IndifferentHash < Hash
-    def [](key)
-      super(key.to_s)
-    end
-
-    def []=(key, value)
-      super(key.to_s, value)
-    end
-
     def has_key?(key)
       super(key.to_s)
     end

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/list_methods.rb

@@ -6,6 +6,20 @@ class MockRedis
     include Assertions
     include UtilityMethods
 
+    def blmove(source, destination, wherefrom, whereto, options = {})
+      options = { :timeout => options } if options.is_a?(Integer)
+      timeout = options.is_a?(Hash) && options[:timeout] || 0
+      assert_valid_timeout(timeout)
+
+      if llen(source) > 0
+        lmove(source, destination, wherefrom, whereto)
+      elsif timeout > 0
+        nil
+      else
+        raise MockRedis::WouldBlock, "Can't block forever"
+      end
+    end
+
     def blpop(*args)
       lists, timeout = extract_timeout(args)
       nonempty_list = first_nonempty_list(lists)
@@ -78,8 +92,29 @@ class MockRedis
       with_list_at(key, &:length)
     end
 
-    def lpop(key)
-      with_list_at(key, &:shift)
+    def lmove(source, destination, wherefrom, whereto)
+      assert_listy(source)
+      assert_listy(destination)
+
+      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
+
+      value = wherefrom == 'left' ? lpop(source) : rpop(source)
+      (whereto == 'left' ? lpush(destination, value) : rpush(destination, value)) unless value.nil?
+      value
+    end
+
+    def lpop(key, count = nil)
+      return with_list_at(key, &:shift) if count.nil?
+
+      record_count = llen(key)
+      return nil if record_count.zero?
+
+      [record_count, count].min.times.map { with_list_at(key, &:shift) }
     end
 
     def lpush(key, values)
@@ -146,13 +181,13 @@ class MockRedis
 
     def ltrim(key, start, stop)
       with_list_at(key) do |list|
-        list.replace(list[[start.to_i, -list.length].max..stop.to_i] || []) if list
+        list&.replace(list[[start.to_i, -list.length].max..stop.to_i] || [])
         'OK'
       end
     end
 
     def rpop(key)
-      with_list_at(key) { |list| list.pop if list }
+      with_list_at(key) { |list| list&.pop }
     end
 
     def rpoplpush(source, destination)

data/lib/mock_redis/memory_method.rb

@@ -0,0 +1,11 @@
+class MockRedis
+  module MemoryMethod
+    def memory(usage, key = nil, *_options)
+      raise ArgumentError, "unhandled command `memory #{usage}`" if usage != 'usage'
+
+      return nil unless @data.key?(key)
+
+      160
+    end
+  end
+end

data/lib/mock_redis/multi_db_wrapper.rb

@@ -17,21 +17,21 @@ class MockRedis
       super || current_db.respond_to?(method, include_private)
     end
 
-    def method_missing(method, *args, &block)
+    ruby2_keywords def method_missing(method, *args, &block)
       current_db.send(method, *args, &block)
     end
 
     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
 
     # Redis commands
     def flushall
-      @databases.values.each(&:flushdb)
+      @databases.each_value(&:flushdb)
       'OK'
     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/pipelined_wrapper.rb

@@ -9,7 +9,7 @@ class MockRedis
     def initialize(db)
       @db = db
       @pipelined_futures = []
-      @in_pipeline = false
+      @nesting_level = 0
     end
 
     def initialize_copy(source)
@@ -18,8 +18,8 @@ class MockRedis
       @pipelined_futures = @pipelined_futures.clone
     end
 
-    def method_missing(method, *args, &block)
-      if @in_pipeline
+    ruby2_keywords def method_missing(method, *args, &block)
+      if in_pipeline?
         future = MockRedis::Future.new([method, *args], block)
         @pipelined_futures << future
         future
@@ -29,24 +29,41 @@ class MockRedis
     end
 
     def pipelined(_options = {})
-      @in_pipeline = true
-      yield self
-      @in_pipeline = false
+      begin
+        @nesting_level += 1
+        yield self
+      ensure
+        @nesting_level -= 1
+      end
+
+      if in_pipeline?
+        return
+      end
+
       responses = @pipelined_futures.flat_map do |future|
-        begin
-          result = if future.block
-                     send(*future.command, &future.block)
-                   else
-                     send(*future.command)
-                   end
-          future.store_result(result)
+        result = if future.block
+                   send(*future.command, &future.block)
+                 else
+                   send(*future.command)
+                 end
+        future.store_result(result)
+
+        if future.block
           result
-        rescue StandardError => e
-          e
+        else
+          [result]
         end
+      rescue StandardError => e
+        e
       end
       @pipelined_futures = []
       responses
     end
+
+    private
+
+    def in_pipeline?
+      @nesting_level > 0
+    end
   end
 end

data/lib/mock_redis/set_methods.rb

@@ -8,7 +8,7 @@ class MockRedis
 
     def sadd(key, members)
       members_class = members.class
-      members = [members].flatten.map(&:to_s)
+      members = Array(members).map(&:to_s)
       assert_has_args(members, 'sadd')
 
       with_set_at(key) do |s|
@@ -27,6 +27,11 @@ class MockRedis
       end
     end
 
+    def sadd?(key, members)
+      res = sadd(key, members)
+      res.is_a?(Numeric) ? res > 0 : res
+    end
+
     def scard(key)
       with_set_at(key, &:length)
     end
@@ -64,6 +69,12 @@ class MockRedis
       with_set_at(key) { |s| s.include?(member.to_s) }
     end
 
+    def smismember(key, *members)
+      with_set_at(key) do |set|
+        members.flatten.map { |m| set.include?(m.to_s) }
+      end
+    end
+
     def smembers(key)
       with_set_at(key, &:to_a).map(&:dup).reverse
     end
@@ -81,11 +92,22 @@ class MockRedis
       end
     end
 
-    def spop(key)
+    def spop(key, count = nil)
       with_set_at(key) do |set|
-        member = set.first
-        set.delete(member)
-        member
+        if count.nil?
+          member = set.first
+          set.delete(member)
+          member
+        else
+          members = []
+          count.times do
+            member = set.first
+            break if member.nil?
+            set.delete(member)
+            members << member
+          end
+          members
+        end
       end
     end
 
@@ -106,6 +128,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
@@ -114,6 +137,11 @@ class MockRedis
       end
     end
 
+    def srem?(key, members)
+      res = srem(key, members)
+      res.is_a?(Numeric) ? res > 0 : res
+    end
+
     def sscan(key, cursor, opts = {})
       common_scan(smembers(key), cursor, opts)
     end
@@ -153,7 +181,7 @@ class MockRedis
         with_set_at(keys.first, &blk)
       else
         with_set_at(keys.first) do |set|
-          with_sets_at(*(keys[1..-1])) do |*sets|
+          with_sets_at(*(keys[1..])) do |*sets|
             yield(*([set] + sets))
           end
         end

data/lib/mock_redis/stream/id.rb

@@ -0,0 +1,58 @@
+class MockRedis
+  class Stream
+    class Id
+      include Comparable
+
+      attr_accessor :timestamp, :sequence, :exclusive
+
+      def initialize(id, min: nil, sequence: 0)
+        @exclusive = false
+        case id
+        when '*'
+          @timestamp = (Time.now.to_f * 1000).to_i
+          @sequence = 0
+          if self <= min
+            @timestamp = min.timestamp
+            @sequence = min.sequence + 1
+          end
+        when '-'
+          @timestamp = @sequence = 0
+        when '+'
+          @timestamp = @sequence = Float::INFINITY
+        else
+          if id.is_a? String
+            # See https://redis.io/topics/streams-intro
+            # Ids are a unix timestamp in milliseconds followed by an
+            # optional dash sequence number, e.g. -0. They can also optionally
+            # be prefixed with '(' to change the XRANGE to exclusive.
+            (_, @timestamp, @sequence) = id.match(/^\(?(\d+)-?(\d+)?$/).to_a
+            @exclusive = true if id[0] == '('
+            if @timestamp.nil?
+              raise Redis::CommandError,
+                    'ERR Invalid stream ID specified as stream command argument'
+            end
+            @timestamp = @timestamp.to_i
+          else
+            @timestamp = id
+          end
+          @sequence = @sequence.nil? ? sequence : @sequence.to_i
+          if self <= min
+            raise Redis::CommandError,
+                  'ERR The ID specified in XADD is equal or smaller than ' \
+                  'the target stream top item'
+          end
+        end
+      end
+
+      def to_s
+        "#{@timestamp}-#{@sequence}"
+      end
+
+      def <=>(other)
+        return 1 if other.nil?
+        return @sequence <=> other.sequence if @timestamp == other.timestamp
+        @timestamp <=> other.timestamp
+      end
+    end
+  end
+end

data/lib/mock_redis/stream.rb

@@ -0,0 +1,88 @@
+require 'forwardable'
+require 'set'
+require 'date'
+require 'mock_redis/stream/id'
+
+class MockRedis
+  class Stream
+    include Enumerable
+    extend Forwardable
+
+    attr_accessor :members
+
+    def_delegators :members, :empty?
+
+    def initialize
+      @members = Set.new
+      @last_id = nil
+    end
+
+    def last_id
+      @last_id.to_s
+    end
+
+    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 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
+      if deleted > 0
+        @members = if count == 0
+                     Set.new
+                   else
+                     @members.to_a[-count..].to_set
+                   end
+        deleted
+      else
+        0
+      end
+    end
+
+    def range(start, finish, reversed, *opts_in)
+      opts = options opts_in, ['count']
+      start_id = MockRedis::Stream::Id.new(start)
+      finish_id = MockRedis::Stream::Id.new(finish, sequence: Float::INFINITY)
+      items = if start_id.exclusive
+                members
+                  .select { |m| (start_id < m[0]) && (finish_id >= m[0]) }
+                  .map { |m| [m[0].to_s, m[1]] }
+              else
+                members
+                  .select { |m| (start_id <= m[0]) && (finish_id >= m[0]) }
+                  .map { |m| [m[0].to_s, m[1]] }
+              end
+      items.reverse! if reversed
+      return items.first(opts['count'].to_i) if opts.key?('count')
+      items
+    end
+
+    def read(id, *opts_in)
+      opts = options opts_in, %w[count block]
+      stream_id = MockRedis::Stream::Id.new(id)
+      items = members.select { |m| (stream_id < m[0]) }.map { |m| [m[0].to_s, m[1]] }
+      return items.first(opts['count'].to_i) if opts.key?('count')
+      items
+    end
+
+    def each(&block)
+      members.each(&block)
+    end
+
+    private
+
+    def options(opts_in, permitted)
+      opts_out = {}
+      raise Redis::CommandError, 'ERR syntax error' unless (opts_in.length % 2).zero?
+      opts_in.each_slice(2).map { |pair| opts_out[pair[0].downcase] = pair[1] }
+      raise Redis::CommandError, 'ERR syntax error' unless (opts_out.keys - permitted).empty?
+      opts_out
+    end
+  end
+end