mock_redis 0.5.4 → 0.31.0

data/lib/mock_redis/list_methods.rb

@@ -32,7 +32,9 @@ class MockRedis
       end
     end
 
-    def brpoplpush(source, destination, timeout)
+    def brpoplpush(source, destination, 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
@@ -45,12 +47,12 @@ class MockRedis
     end
 
     def lindex(key, index)
-      with_list_at(key) {|l| l[index]}
+      with_list_at(key) { |l| l[index.to_i] }
     end
 
     def linsert(key, position, pivot, value)
       unless %w[before after].include?(position.to_s)
-        raise Redis::CommandError, "ERR syntax error"
+        raise Redis::CommandError, 'ERR syntax error'
       end
 
       assert_listy(key)
@@ -82,23 +84,29 @@ class MockRedis
 
     def lpush(key, values)
       values = [values] unless values.is_a?(Array)
-      with_list_at(key) {|l| values.each {|v| l.unshift(v.to_s)}}
+      assert_has_args(values, 'lpush')
+      with_list_at(key) { |l| values.each { |v| l.unshift(v.to_s) } }
       llen(key)
     end
 
     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"
+      end
       assert_listy(key)
       return 0 unless list_at?(key)
       lpush(key, value)
     end
 
     def lrange(key, start, stop)
-      with_list_at(key) {|l| l[start..stop]}
+      start = start.to_i
+      with_list_at(key) { |l| start < l.size ? l[[start, -l.length].max..stop.to_i] : [] }
     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"
+        raise Redis::CommandError, 'ERR value is not an integer or out of range'
       end
       count = count.to_i
       value = value.to_s
@@ -116,7 +124,7 @@ class MockRedis
                               indices_with_value.reverse.take(-count)
                             end
 
-        indices_to_delete.each {|i| list.delete_at(i)}.length
+        indices_to_delete.each { |i| list.delete_at(i) }.length
       end
     end
 
@@ -124,11 +132,12 @@ class MockRedis
       assert_listy(key)
 
       unless list_at?(key)
-        raise Redis::CommandError, "ERR no such key"
+        raise Redis::CommandError, 'ERR no such key'
       end
 
-      unless (0...llen(key)).include?(index)
-        raise Redis::CommandError, "ERR index out of range"
+      index = index.to_i
+      unless (0...llen(key)).cover?(index)
+        raise Redis::CommandError, 'ERR index out of range'
       end
 
       data[key][index] = value.to_s
@@ -137,56 +146,62 @@ class MockRedis
 
     def ltrim(key, start, stop)
       with_list_at(key) do |list|
-        list.replace(list[start..stop] || []) 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)
       value = rpop(source)
-      lpush(destination, value)
+      lpush(destination, value) unless value.nil?
       value
     end
 
     def rpush(key, values)
       values = [values] unless values.is_a?(Array)
-      with_list_at(key) {|l| values.each {|v| l.push(v.to_s)}}
+      assert_has_args(values, 'rpush')
+      with_list_at(key) { |l| values.each { |v| l.push(v.to_s) } }
       llen(key)
     end
 
     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"
+      end
       assert_listy(key)
       return 0 unless list_at?(key)
       rpush(key, value)
     end
 
     private
+
     def list_at?(key)
       data[key] && listy?(key)
     end
 
     def with_list_at(key, &blk)
-      with_thing_at(key, :assert_listy, proc {[]}, &blk)
+      with_thing_at(key, :assert_listy, proc { [] }, &blk)
     end
 
     def listy?(key)
-      data[key].nil? || data[key].kind_of?(Array)
+      data[key].nil? || data[key].is_a?(Array)
     end
 
     def assert_listy(key)
       unless listy?(key)
         # Not the most helpful error, but it's what redis-rb barfs up
-        raise Redis::CommandError, "ERR Operation against a key holding the wrong kind of value"
+        raise Redis::CommandError,
+              'WRONGTYPE Operation against a key holding the wrong kind of value'
       end
     end
 
     def first_nonempty_list(keys)
-      keys.find{|k| llen(k) > 0}
+      keys.find { |k| llen(k) > 0 }
     end
-
   end
 end

data/lib/mock_redis/multi_db_wrapper.rb

@@ -9,22 +9,22 @@ class MockRedis
 
       @prototype_db = db.clone
 
-      @databases = Hash.new {|h,k| h[k] = @prototype_db.clone}
+      @databases = Hash.new { |h, k| h[k] = @prototype_db.clone }
       @databases[@db_index] = db
     end
 
-    def respond_to?(method, include_private=false)
+    def respond_to?(method, include_private = false)
       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
@@ -39,12 +39,12 @@ 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)
         when 'hash'
-          dest.hmset(key, *(src.hgetall(key).map{|k,v| [k,v]}.flatten))
+          dest.hmset(key, *src.hgetall(key).map { |k, v| [k, v] }.flatten)
         when 'list'
           while value = src.rpop(key)
             dest.lpush(key, value)
@@ -56,7 +56,7 @@ class MockRedis
         when 'string'
           dest.set(key, src.get(key))
         when 'zset'
-          src.zrange(key, 0, -1, :with_scores => true).each do |(m,s)|
+          src.zrange(key, 0, -1, :with_scores => true).each do |(m, s)|
             dest.zadd(key, s, m)
           end
         else
@@ -75,6 +75,7 @@ class MockRedis
     end
 
     private
+
     def current_db
       @databases[@db_index]
     end

data/lib/mock_redis/pipelined_wrapper.rb

@@ -2,44 +2,70 @@ class MockRedis
   class PipelinedWrapper
     include UndefRedisMethods
 
-    def respond_to?(method, include_private=false)
+    def respond_to?(method, include_private = false)
       super || @db.respond_to?(method)
     end
 
     def initialize(db)
       @db = db
-      @pipelined_commands = []
-      @in_pipeline = false
+      @pipelined_futures = []
+      @nesting_level = 0
     end
 
     def initialize_copy(source)
       super
       @db = @db.clone
-      @pipelined_commands = @pipelined_commands.clone
+      @pipelined_futures = @pipelined_futures.clone
     end
 
-    def method_missing(method, *args, &block)
-      if @in_pipeline
-        @pipelined_commands << [method, *args]
-        nil
+    ruby2_keywords def method_missing(method, *args, &block)
+      if in_pipeline?
+        future = MockRedis::Future.new([method, *args], block)
+        @pipelined_futures << future
+        future
       else
         @db.send(method, *args, &block)
       end
     end
 
-    def pipelined(options = {})
-      @in_pipeline = true
-      yield
-      @in_pipeline = false
-      responses = @pipelined_commands.map do |cmd|
+    def pipelined(_options = {})
+      begin
+        @nesting_level += 1
+        yield self
+      ensure
+        @nesting_level -= 1
+      end
+
+      if in_pipeline?
+        return
+      end
+
+      responses = @pipelined_futures.flat_map do |future|
         begin
-          send(*cmd)
-        rescue => e
+          result = if future.block
+                     send(*future.command, &future.block)
+                   else
+                     send(*future.command)
+                   end
+          future.store_result(result)
+
+          if future.block
+            result
+          else
+            [result]
+          end
+        rescue StandardError => e
           e
         end
       end
-      @pipelined_commands = []
+      @pipelined_futures = []
       responses
     end
+
+    private
+
+    def in_pipeline?
+      @nesting_level > 0
+    end
   end
 end

data/lib/mock_redis/set_methods.rb

@@ -7,26 +7,33 @@ class MockRedis
     include UtilityMethods
 
     def sadd(key, members)
+      members_class = members.class
       members = [members].flatten.map(&:to_s)
+      assert_has_args(members, 'sadd')
 
       with_set_at(key) do |s|
+        size_before = s.size
         if members.size > 1
-          size_before = s.size
-          members.reverse.each {|m| s << m}
+          members.reverse_each { |m| s << m }
           s.size - size_before
         else
-          !!s.add?(members.first)
+          added = !!s.add?(members.first)
+          if members_class == Array
+            s.size - size_before
+          else
+            added
+          end
         end
       end
     end
 
     def scard(key)
-      with_set_at(key) {|s| s.length}
+      with_set_at(key, &:length)
     end
 
     def sdiff(*keys)
       assert_has_args(keys, 'sdiff')
-      with_sets_at(*keys) {|*sets| sets.reduce(&:-)}.to_a
+      with_sets_at(*keys) { |*sets| sets.reduce(&:-) }.to_a
     end
 
     def sdiffstore(destination, *keys)
@@ -54,11 +61,11 @@ class MockRedis
     end
 
     def sismember(key, member)
-      with_set_at(key) {|s| s.include?(member.to_s)}
+      with_set_at(key) { |s| s.include?(member.to_s) }
     end
 
     def smembers(key)
-      with_set_at(key, &:to_a).reverse
+      with_set_at(key, &:to_a).map(&:dup).reverse
     end
 
     def smove(src, dest, member)
@@ -74,23 +81,43 @@ 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
 
-    def srandmember(key)
+    def srandmember(key, count = nil)
       members = with_set_at(key, &:to_a)
-      members[rand(members.length)]
+      if count
+        if count > 0
+          members.sample(count)
+        else
+          Array.new(count.abs) { members[rand(members.length)] }
+        end
+      else
+        members[rand(members.length)]
+      end
     end
 
     def srem(key, members)
       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
@@ -99,9 +126,23 @@ class MockRedis
       end
     end
 
+    def sscan(key, cursor, opts = {})
+      common_scan(smembers(key), cursor, opts)
+    end
+
+    def sscan_each(key, opts = {}, &block)
+      return to_enum(:sscan_each, key, opts) unless block_given?
+      cursor = 0
+      loop do
+        cursor, keys = sscan(key, cursor, opts)
+        keys.each(&block)
+        break if cursor == '0'
+      end
+    end
+
     def sunion(*keys)
       assert_has_args(keys, 'sunion')
-      with_sets_at(*keys) {|*sets| sets.reduce(&:+).to_a}
+      with_sets_at(*keys) { |*sets| sets.reduce(&:+).to_a }
     end
 
     def sunionstore(destination, *keys)
@@ -113,32 +154,34 @@ class MockRedis
     end
 
     private
+
     def with_set_at(key, &blk)
-      with_thing_at(key, :assert_sety, proc {Set.new}, &blk)
+      with_thing_at(key, :assert_sety, proc { Set.new }, &blk)
     end
 
     def with_sets_at(*keys, &blk)
+      keys = keys.flatten
       if keys.length == 1
         with_set_at(keys.first, &blk)
       else
         with_set_at(keys.first) do |set|
           with_sets_at(*(keys[1..-1])) do |*sets|
-            blk.call(*([set] + sets))
+            yield(*([set] + sets))
           end
         end
       end
     end
 
     def sety?(key)
-      data[key].nil? || data[key].kind_of?(Set)
+      data[key].nil? || data[key].is_a?(Set)
     end
 
     def assert_sety(key)
       unless sety?(key)
         # Not the most helpful error, but it's what redis-rb barfs up
-        raise Redis::CommandError, "ERR Operation against a key holding the wrong kind of value"
+        raise Redis::CommandError,
+              'WRONGTYPE Operation against a key holding the wrong kind of value'
       end
     end
-
   end
 end

data/lib/mock_redis/sort_method.rb

@@ -0,0 +1,81 @@
+require 'mock_redis/assertions'
+
+class MockRedis
+  module SortMethod
+    include Assertions
+
+    def sort(key, options = {})
+      return [] if key.nil?
+
+      enumerable = data[key]
+
+      return [] if enumerable.nil?
+
+      by           = options[:by]
+      limit        = options[:limit] || []
+      store        = options[:store]
+      get_patterns = Array(options[:get])
+      order        = options[:order] || 'ASC'
+      direction    = order.split.first
+
+      projected = project(enumerable, by, get_patterns)
+      sorted    = sort_by(projected, direction)
+      sliced    = slice(sorted, limit)
+
+      store ? rpush(store, sliced) : sliced
+    end
+
+    private
+
+    ASCENDING_SORT  = proc { |a, b| a.first <=> b.first }
+    DESCENDING_SORT = proc { |a, b| b.first <=> a.first }
+
+    def project(enumerable, by, get_patterns)
+      enumerable.map do |*elements|
+        element = elements.last
+        weight  = by ? lookup_from_pattern(by, element) : element
+        value   = element
+
+        unless get_patterns.empty?
+          value = get_patterns.map do |pattern|
+            pattern == '#' ? element : lookup_from_pattern(pattern, element)
+          end
+          value = value.first if value.length == 1
+        end
+
+        [weight, value]
+      end
+    end
+
+    def sort_by(projected, direction)
+      sorter =
+        case direction.upcase
+        when 'DESC'
+          DESCENDING_SORT
+        when 'ASC', 'ALPHA'
+          ASCENDING_SORT
+        else
+          raise "Invalid direction '#{direction}'"
+        end
+
+      projected.sort(&sorter).map(&:last)
+    end
+
+    def slice(sorted, limit)
+      skip = limit.first || 0
+      take = limit.last || sorted.length
+
+      sorted[skip...(skip + take)] || sorted
+    end
+
+    def lookup_from_pattern(pattern, element)
+      key = pattern.sub('*', element)
+
+      if (hash_parts = key.split('->')).length > 1
+        hget hash_parts.first, hash_parts.last
+      else
+        get key
+      end
+    end
+  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..-1].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
+      members.each { |m| yield m }
+    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