mock_redis 0.5.4 → 0.31.0

data/lib/mock_redis/utility_methods.rb

@@ -3,23 +3,74 @@ class MockRedis
     private
 
     def with_thing_at(key, assertion, empty_thing_generator)
-      begin
-        send(assertion, key)
-        data[key] ||= empty_thing_generator.call
-        data_key_ref = data[key]
-        ret = yield data[key]
-        data[key] = data_key_ref if data[key].nil?
-        ret
-      ensure
-        clean_up_empties_at(key)
-      end
+      send(assertion, key)
+      data[key] ||= empty_thing_generator.call
+      data_key_ref = data[key]
+      ret = yield data[key]
+      data[key] = data_key_ref if data[key].nil?
+      primitive?(ret) ? ret.dup : ret
+    ensure
+      clean_up_empties_at(key)
+    end
+
+    def primitive?(value)
+      value.is_a?(::Array) || value.is_a?(::Hash) || value.is_a?(::String)
     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
 
+    def common_scan(values, cursor, opts = {})
+      count = (opts[:count] || 10).to_i
+      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
+
+      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]
+    end
+
+    def twos_complement_encode(n, size)
+      if n < 0
+        str = (n + 1).abs.to_s(2)
+
+        binary = left_pad(str, size - 1).chars.map { |c| c == '0' ? 1 : 0 }
+        binary.unshift(1)
+      else
+        binary = left_pad(n.abs.to_s(2), size - 1).chars.map(&:to_i)
+        binary.unshift(0)
+      end
+
+      binary
+    end
+
+    def twos_complement_decode(array)
+      total = 0
+
+      array.each.with_index do |bit, index|
+        total += 2**(array.length - index - 1) if bit == 1
+        total = -total if index == 0
+      end
+
+      total
+    end
+
+    def left_pad(str, size)
+      str = '0' + str while str.length < size
+
+      str
+    end
   end
 end

data/lib/mock_redis/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Defines the gem version.
 class MockRedis
-  VERSION = '0.5.4'
+  VERSION = '0.31.0'
 end

data/lib/mock_redis/zset.rb

@@ -12,7 +12,7 @@ class MockRedis
 
     def initialize
       @members = Set.new
-      @scores  = Hash.new
+      @scores  = {}
     end
 
     def initialize_copy(source)
@@ -23,49 +23,45 @@ class MockRedis
 
     def add(score, member)
       members.add(member)
-      if score.to_f.to_i == score.to_f
-        scores[member] = score.to_f.to_i
-      else
-        scores[member] = score.to_f
-      end
+      scores[member] = score.to_f
       self
     end
 
     def delete?(member)
       scores.delete(member)
-      members.delete?(member) and self
+      members.delete?(member) && self
     end
 
     def each
-      members.each {|m| yield score(m), m}
+      members.each { |m| yield score(m), m }
     end
 
     def in_range(min, max)
       in_from_the_left = case min
-                         when "-inf"
-                             lambda {|_| true }
-                         when "+inf"
-                             lambda {|_| false }
+                         when '-inf'
+                           lambda { |_| true }
+                         when '+inf'
+                           lambda { |_| false }
                          when /\((.*)$/
-                             val = $1.to_f
-                           lambda {|x| x.to_f > val }
+                           left_val = $1.to_f
+                           lambda { |x| x.to_f > left_val }
                          else
-                           lambda {|x| x.to_f >= min.to_f }
+                           lambda { |x| x.to_f >= min.to_f }
                          end
 
       in_from_the_right = case max
-                          when "-inf"
-                              lambda {|_| false }
-                          when "+inf"
-                              lambda {|_| true }
+                          when '-inf'
+                            lambda { |_| false }
+                          when '+inf'
+                            lambda { |_| true }
                           when /\((.*)$/
-                              val = $1.to_f
-                            lambda {|x| x.to_f < val }
+                            right_val = $1.to_f
+                            lambda { |x| x.to_f < right_val }
                           else
-                            lambda {|x| x.to_f <= max.to_f }
+                            lambda { |x| x.to_f <= max.to_f }
                           end
 
-      sorted.find_all do |(score, member)|
+      sorted.find_all do |(score, _member)|
         in_from_the_left[score] && in_from_the_right[score]
       end
     end
@@ -74,8 +70,8 @@ class MockRedis
       if !block_given?
         intersection(other, &:+)
       else
-        self.members.intersection(other.members).reduce(self.class.new) do |acc, m|
-          new_score = yield(self.score(m), other.score(m))
+        members.intersection(other.members).reduce(self.class.new) do |acc, m|
+          new_score = yield(score(m), other.score(m))
           acc.add(new_score, m)
         end
       end
@@ -88,7 +84,7 @@ class MockRedis
     def sorted
       members.map do |m|
         [score(m), m]
-      end.sort_by(&:first)
+      end.sort
     end
 
     def sorted_members
@@ -99,12 +95,11 @@ class MockRedis
       if !block_given?
         union(other, &:+)
       else
-        self.members.union(other.members).reduce(self.class.new) do |acc, m|
-          new_score = yield(self.score(m), other.score(m))
+        members.union(other.members).reduce(self.class.new) do |acc, m|
+          new_score = yield(score(m), other.score(m))
           acc.add(new_score, m)
         end
       end
     end
-
   end
 end

data/lib/mock_redis/zset_methods.rb

@@ -8,42 +8,90 @@ class MockRedis
     include UtilityMethods
 
     def zadd(key, *args)
-      if !args.first.is_a?(Array)
-        if args.size < 2
-          raise Redis::CommandError, "ERR wrong number of arguments for 'zadd' command"
-        elsif args.size.odd?
-          raise Redis::CommandError, "ERR syntax error"
-        end
-      else
-        unless args.all? {|pair| pair.size == 2 }
-          raise(Redis::CommandError, "ERR syntax error")
-        end
+      zadd_options = {}
+      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'
       end
 
-      if args.size == 2
+      if args.size == 1 && args[0].is_a?(Array)
+        zadd_multiple_members(key, args.first, zadd_options)
+      elsif args.size == 2
         score, member = args
-        assert_scorey(score)
-        retval = !zscore(key, member)
-        with_zset_at(key) {|z| z.add(score, member.to_s)}
+        zadd_one_member(key, score, member, zadd_options)
       else
-        args = args.first
-        args = args.each_slice(2).to_a unless args.first.is_a?(Array)
-        retval = args.map(&:last).map { |member| !!zscore(key, member.to_s) }.count(false)
-        with_zset_at(key) do |z|
-          args.each { |score, member| z.add(score, member.to_s) }
+        raise Redis::CommandError, 'ERR wrong number of arguments'
+      end
+    end
+
+    def zadd_one_member(key, score, member, zadd_options = {})
+      assert_scorey(score) unless score.to_s =~ /(\+|\-)inf/
+
+      with_zset_at(key) do |zset|
+        if zadd_options[:incr]
+          if zadd_options[:xx]
+            member_present = zset.include?(member)
+            return member_present ? zincrby(key, score, member) : nil
+          end
+
+          if zadd_options[:nx]
+            member_present = zset.include?(member)
+            return member_present ? nil : zincrby(key, score, member)
+          end
+
+          zincrby(key, score, member)
+        elsif zadd_options[:xx]
+          zset.add(score, member.to_s) if zset.include?(member)
+          false
+        elsif zadd_options[:nx]
+          !zset.include?(member) && !!zset.add(score, member.to_s)
+        else
+          retval = !zscore(key, member)
+          zset.add(score, member.to_s)
+          retval
         end
       end
+    end
 
-      retval
+    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'
+        elsif zadd_options[:xx]
+          args.each { |score, member| zset.include?(member) && zset.add(score, member.to_s) }
+          0
+        elsif zadd_options[:nx]
+          args.reduce(0) do |retval, (score, member)|
+            unless zset.include?(member)
+              zset.add(score, member.to_s)
+              retval += 1
+            end
+            retval
+          end
+        else
+          args.reduce(0) do |retval, (score, member)|
+            retval += 1 unless zset.include?(member)
+            zset.add(score, member.to_s)
+            retval
+          end
+        end
+      end
     end
 
+    private :zadd_multiple_members
+
     def zcard(key)
       with_zset_at(key, &:size)
     end
 
     def zcount(key, min, max)
-      assert_scorey(min, 'ERR min or max is not a float') unless min == '-inf'
-      assert_scorey(max, 'ERR min or max is not a float') unless max == '+inf'
+      assert_range_args(min, max)
 
       with_zset_at(key) do |zset|
         zset.in_range(min, max).size
@@ -61,20 +109,24 @@ class MockRedis
       end
     end
 
-    def zinterstore(destination, keys, options={})
+    def zinterstore(destination, keys, options = {})
       assert_has_args(keys, 'zinterstore')
 
       data[destination] = combine_weighted_zsets(keys, options, :intersection)
       zcard(destination)
     end
 
-    def zrange(key, start, stop, options={})
+    def zrange(key, start, stop, options = {})
       with_zset_at(key) do |z|
-        to_response(z.sorted[start.to_i..stop.to_i] || [], options)
+        start = [start.to_i, -z.sorted.size].max
+        stop = stop.to_i
+        to_response(z.sorted[start..stop] || [], options)
       end
     end
 
-    def zrangebyscore(key, min, max, options={})
+    def zrangebyscore(key, min, max, options = {})
+      assert_range_args(min, max)
+
       with_zset_at(key) do |zset|
         all_results = zset.in_range(min, max)
         to_response(apply_limit(all_results, options[:limit]), options)
@@ -82,63 +134,106 @@ class MockRedis
     end
 
     def zrank(key, member)
-      with_zset_at(key) {|z| z.sorted_members.index(member.to_s) }
+      with_zset_at(key) { |z| z.sorted_members.index(member.to_s) }
     end
 
     def zrem(key, *args)
       if !args.first.is_a?(Array)
-        retval = with_zset_at(key) {|z| !!z.delete?(args.first.to_s)}
+        retval = with_zset_at(key) { |z| !!z.delete?(args.first.to_s) }
       else
         args = args.first
-        retval = args.map { |member| !!zscore(key, member.to_s) }.count(true)
-        with_zset_at(key) do |z|
-          args.each { |member| z.delete?(member) }
+        if args.empty?
+          raise Redis::CommandError, "ERR wrong number of arguments for 'zrem' command"
+        else
+          retval = args.map { |member| !!zscore(key, member.to_s) }.count(true)
+          with_zset_at(key) do |z|
+            args.each { |member| z.delete?(member) }
+          end
         end
       end
 
       retval
     end
 
-    def zrevrange(key, start, stop, options={})
+    def zpopmin(key, count = 1)
       with_zset_at(key) do |z|
-        to_response(z.sorted.reverse[start..stop], options)
+        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)
       end
     end
 
     def zremrangebyrank(key, start, stop)
       zrange(key, start, stop).
-        each {|member| zrem(key, member)}.
+        each { |member| zrem(key, member) }.
         size
     end
 
     def zremrangebyscore(key, min, max)
+      assert_range_args(min, max)
+
       zrangebyscore(key, min, max).
-        each {|member| zrem(key, member)}.
+        each { |member| zrem(key, member) }.
         size
     end
 
-    def zrevrangebyscore(key, max, min, options={})
+    def zrevrangebyscore(key, max, min, options = {})
+      assert_range_args(min, max)
+
       with_zset_at(key) do |zset|
         to_response(
           apply_limit(
             zset.in_range(min, max).reverse,
-            options[:limit]),
-          options)
+            options[:limit]
+          ),
+          options
+        )
       end
     end
 
     def zrevrank(key, member)
-      with_zset_at(key) {|z| z.sorted_members.reverse.index(member.to_s) }
+      with_zset_at(key) { |z| z.sorted_members.reverse.index(member.to_s) }
+    end
+
+    def zscan(key, cursor, opts = {})
+      opts = opts.merge(key: lambda { |x| x[0] })
+      common_scan(zrange(key, 0, -1, withscores: true), cursor, opts)
+    end
+
+    def zscan_each(key, opts = {}, &block)
+      return to_enum(:zscan_each, key, opts) unless block_given?
+      cursor = 0
+      loop do
+        cursor, values = zscan(key, cursor, opts)
+        values.each(&block)
+        break if cursor == '0'
+      end
     end
 
     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 zunionstore(destination, keys, options={})
+    def zunionstore(destination, keys, options = {})
       assert_has_args(keys, 'zunionstore')
 
       data[destination] = combine_weighted_zsets(keys, options, :union)
@@ -146,13 +241,14 @@ class MockRedis
     end
 
     private
+
     def apply_limit(collection, limit)
       if limit
         if limit.is_a?(Array) && limit.length == 2
           offset, count = limit
           collection.drop(offset).take(count)
         else
-          raise Redis::CommandError, "ERR syntax error"
+          raise Redis::CommandError, 'ERR syntax error'
         end
       else
         collection
@@ -160,7 +256,7 @@ class MockRedis
     end
 
     def to_response(score_member_pairs, options)
-      score_member_pairs.map do |(score,member)|
+      score_member_pairs.map do |(score, member)|
         if options[:with_scores] || options[:withscores]
           [member, score.to_f]
         else
@@ -172,21 +268,21 @@ 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 Redis::CommandError, 'ERR syntax error'
       end
 
       aggregator = case options.fetch(:aggregate, :sum).to_s.downcase.to_sym
                    when :sum
-                     proc {|a,b| [a,b].compact.reduce(&:+)}
+                     proc { |a, b| [a, b].compact.reduce(&:+) }
                    when :min
-                     proc {|a,b| [a,b].compact.min}
+                     proc { |a, b| [a, b].compact.min }
                    when :max
-                     proc {|a,b| [a,b].compact.max}
+                     proc { |a, b| [a, b].compact.max }
                    else
-                     raise Redis::CommandError, "ERR syntax error"
+                     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)
@@ -195,33 +291,57 @@ class MockRedis
           za.send(how, zb, &aggregator)
         end
       end
+    end
 
+    def coerce_to_zset(set)
+      zset = Zset.new
+      set.each do |member|
+        zset.add(1.0, member)
+      end
+      zset
     end
 
-    def with_zset_at(key, &blk)
-      with_thing_at(key, :assert_zsety, proc {Zset.new}, &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, &blk)
+    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|
-            blk.call(*([set] + 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
       end
     end
 
     def zsety?(key)
-      data[key].nil? || data[key].kind_of?(Zset)
+      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,
-        "ERR Operation against a key holding the wrong kind of value"
+          'WRONGTYPE Operation against a key holding the wrong kind of value'
+      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
 
@@ -230,11 +350,19 @@ class MockRedis
       !!Float(x) rescue false
     end
 
-    def assert_scorey(value, message = "ERR value is not a valid float")
+    def assert_scorey(value, message = 'ERR value is not a valid float')
+      return if value.to_s =~ /\(?(\-|\+)inf/
+
+      value = $1 if value.to_s =~ /\((.*)/
       unless looks_like_float?(value)
         raise Redis::CommandError, message
       end
     end
 
+    def assert_range_args(min, max)
+      [min, max].each do |value|
+        assert_scorey(value, 'ERR min or max is not a float')
+      end
+    end
   end
 end