mock_redis 0.5.4 → 0.31.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

@@ -3,14 +3,79 @@ require 'mock_redis/assertions'
 class MockRedis
   module StringMethods
     include Assertions
+    include UtilityMethods
 
     def append(key, value)
       assert_stringy(key)
-      data[key] ||= ""
+      data[key] ||= ''
       data[key] << value
       data[key].length
     end
 
+    def bitfield(*args)
+      if args.length < 4
+        raise Redis::CommandError, 'ERR wrong number of arguments for BITFIELD'
+      end
+
+      key = args.shift
+      output = []
+      overflow_method = 'wrap'
+
+      until args.empty?
+        command = args.shift.to_s
+
+        if command == 'overflow'
+          new_overflow_method = args.shift.to_s.downcase
+
+          unless %w[wrap sat fail].include? new_overflow_method
+            raise Redis::CommandError, 'ERR Invalid OVERFLOW type specified'
+          end
+
+          overflow_method = new_overflow_method
+          next
+        end
+
+        type, offset = args.shift(2)
+
+        is_signed = type.slice(0) == 'i'
+        type_size = type[1..-1].to_i
+
+        if (type_size > 64 && is_signed) || (type_size >= 64 && !is_signed)
+          raise Redis::CommandError,
+            'ERR Invalid bitfield type. Use something like i16 u8. ' \
+            'Note that u64 is not supported but i64 is.'
+        end
+
+        if offset.to_s[0] == '#'
+          offset = offset[1..-1].to_i * type_size
+        end
+
+        bits = []
+
+        type_size.times do |i|
+          bits.push(getbit(key, offset + i))
+        end
+
+        val = is_signed ? twos_complement_decode(bits) : bits.join('').to_i(2)
+
+        case command
+        when 'get'
+          output.push(val)
+        when 'set'
+          output.push(val)
+
+          set_bitfield(key, args.shift.to_i, is_signed, type_size, offset)
+        when 'incrby'
+          new_val = incr_bitfield(val, args.shift.to_i, is_signed, type_size, overflow_method)
+
+          set_bitfield(key, new_val, is_signed, type_size, offset) if new_val
+          output.push(new_val)
+        end
+      end
+
+      output
+    end
+
     def decr(key)
       decrby(key, 1)
     end
@@ -20,22 +85,20 @@ 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
 
       # String#getbyte would be lovely, but it's not in 1.8.7.
-      byte = (data[key] || "").each_byte.drop(offset_of_byte).first
+      byte = (data[key] || '').each_byte.drop(offset_of_byte).first
 
       if byte
         (byte & (2**7 >> offset_within_byte)) > 0 ? 1 : 0
@@ -46,7 +109,7 @@ class MockRedis
 
     def getrange(key, start, stop)
       assert_stringy(key)
-      (data[key] || "")[start..stop]
+      (data[key] || '')[start..stop]
     end
 
     def getset(key, value)
@@ -62,11 +125,11 @@ class MockRedis
     def incrby(key, n)
       assert_stringy(key)
       unless can_incr?(data[key])
-        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
 
       unless looks_like_integer?(n.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
 
       new_value = data[key].to_i + n.to_i
@@ -78,11 +141,11 @@ class MockRedis
     def incrbyfloat(key, n)
       assert_stringy(key)
       unless can_incr_float?(data[key])
-        raise Redis::CommandError, "ERR value is not a valid float"
+        raise Redis::CommandError, 'ERR value is not a valid float'
       end
 
       unless looks_like_float?(n.to_s)
-        raise Redis::CommandError, "ERR value is not a valid float"
+        raise Redis::CommandError, 'ERR value is not a valid float'
       end
 
       new_value = data[key].to_f + n.to_f
@@ -91,31 +154,45 @@ 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)
+      Hash[keys.zip(mget(*keys))]
     end
 
     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"
+        raise Redis::CommandError, 'ERR wrong number of arguments for MSET'
       end
 
-      kvpairs.each_slice(2) do |(k,v)|
-        set(k,v)
+      kvpairs.each_slice(2) do |(k, v)|
+        set(k, v)
       end
 
-      "OK"
+      'OK'
+    end
+
+    def mapped_mset(hash)
+      mset(*hash.to_a.flatten)
     end
 
     def msetnx(*kvpairs)
       assert_has_args(kvpairs, 'msetnx')
 
-      if kvpairs.each_slice(2).any? {|(k,v)| exists(k)}
+      if kvpairs.each_slice(2).any? { |(k, _)| exists?(k) }
         false
       else
         mset(*kvpairs)
@@ -123,26 +200,62 @@ class MockRedis
       end
     end
 
-    def set(key, value)
-      data[key] = value.to_s
-      'OK'
+    def mapped_msetnx(hash)
+      msetnx(*hash.to_a.flatten)
     end
 
-    def []=(key, value)
-      set(key, value)
+    # Parameer list required to ensure the ArgumentError is returned correctly
+    # rubocop:disable Metrics/ParameterLists
+    def set(key, value, ex: nil, px: nil, nx: nil, xx: nil, keepttl: nil)
+      key = key.to_s
+      return_true = false
+      if nx
+        if exists?(key)
+          return false
+        else
+          return_true = true
+        end
+      end
+      if xx
+        if exists?(key)
+          return_true = true
+        else
+          return false
+        end
+      end
+      data[key] = value.to_s
+
+      remove_expiration(key) unless keepttl
+      if ex
+        if ex == 0
+          raise Redis::CommandError, 'ERR invalid expire time in set'
+        end
+        expire(key, ex)
+      end
+
+      if px
+        if px == 0
+          raise Redis::CommandError, 'ERR invalid expire time in set'
+        end
+        pexpire(key, px)
+      end
+
+      return_true ? true : 'OK'
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def setbit(key, offset, value)
-      assert_stringy(key, "ERR bit is not an integer or out of range")
+      assert_stringy(key, 'ERR bit is not an integer or out of range')
       retval = getbit(key, offset)
 
-      str = data[key] || ""
+      str = data[key] || ''
 
+      offset = offset.to_i
       offset_of_byte = offset / 8
       offset_within_byte = offset % 8
 
       if offset_of_byte >= str.bytesize
-        str = zero_pad(str, offset_of_byte+1)
+        str = zero_pad(str, offset_of_byte + 1)
       end
 
       char_index = byte_index = offset_within_char = 0
@@ -157,27 +270,66 @@ class MockRedis
       end
 
       char = str[char_index]
-      char = char.chr if char.respond_to?(:chr)  # ruby 1.8 vs 1.9
+      char = char.chr if char.respond_to?(:chr) # ruby 1.8 vs 1.9
       char_as_number = char.each_byte.reduce(0) do |a, byte|
         (a << 8) + byte
       end
-      char_as_number |=
-        (2**((char.bytesize * 8)-1) >>
-        (offset_within_char * 8 + offset_within_byte))
+
+      bitmask_length = (char.bytesize * 8 - offset_within_char * 8 - offset_within_byte - 1)
+      bitmask = 1 << bitmask_length
+
+      if value.zero?
+        bitmask ^= 2**(char.bytesize * 8) - 1
+        char_as_number &= bitmask
+      else
+        char_as_number |= bitmask
+      end
+
       str[char_index] = char_as_number.chr
 
       data[key] = str
       retval
     end
 
+    def bitcount(key, start = 0, stop = -1)
+      assert_stringy(key)
+
+      str   = data[key] || ''
+      count = 0
+      m1    = 0x5555555555555555
+      m2    = 0x3333333333333333
+      m4    = 0x0f0f0f0f0f0f0f0f
+      m8    = 0x00ff00ff00ff00ff
+      m16   = 0x0000ffff0000ffff
+      m32   = 0x00000000ffffffff
+
+      str.bytes.to_a[start..stop].each do |byte|
+        # Naive Hamming weight
+        c = byte
+        c = (c & m1) + ((c >> 1) & m1)
+        c = (c & m2) + ((c >> 2) & m2)
+        c = (c & m4) + ((c >> 4) & m4)
+        c = (c & m8) + ((c >> 8) & m8)
+        c = (c & m16) + ((c >> 16) & m16)
+        c = (c & m32) + ((c >> 32) & m32)
+        count += c
+      end
+
+      count
+    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)
@@ -188,32 +340,73 @@ class MockRedis
     def setrange(key, offset, value)
       assert_stringy(key)
       value = value.to_s
-      old_value = (data[key] || "")
+      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)..-1] || '')
       data[key].length
     end
 
     def strlen(key)
       assert_stringy(key)
-      (data[key] || "").bytesize
+      (data[key] || '').bytesize
     end
 
-
-
-
     private
+
     def stringy?(key)
-      data[key].nil? || data[key].kind_of?(String)
+      data[key].nil? || data[key].is_a?(String)
     end
 
     def assert_stringy(key,
-        message="ERR Operation against a key holding the wrong kind of value")
+        message = 'WRONGTYPE Operation against a key holding the wrong kind of value')
       unless stringy?(key)
         raise Redis::CommandError, message
       end
     end
 
+    def set_bitfield(key, value, is_signed, type_size, offset)
+      if is_signed
+        val_array = twos_complement_encode(value, type_size)
+      else
+        str = left_pad(value.to_i.abs.to_s(2), type_size)
+        val_array = str.split('').map(&:to_i)
+      end
+
+      val_array.each_with_index do |bit, i|
+        setbit(key, offset + i, bit)
+      end
+    end
+
+    def incr_bitfield(val, incrby, is_signed, type_size, overflow_method)
+      new_val = val + incrby
+
+      max = is_signed ? (2**(type_size - 1)) - 1 : (2**type_size) - 1
+      min = is_signed ? (-2**(type_size - 1)) : 0
+      size = 2**type_size
+
+      return new_val if (min..max).cover?(new_val)
+
+      case overflow_method
+      when 'fail'
+        new_val = nil
+      when 'sat'
+        new_val = new_val > max ? max : min
+      when 'wrap'
+        if is_signed
+          if new_val > max
+            remainder = new_val - (max + 1)
+            new_val = min + remainder.abs
+          else
+            remainder = new_val - (min - 1)
+            new_val = max - remainder.abs
+          end
+        else
+          new_val = new_val > max ? new_val % size : size - new_val.abs
+        end
+      end
+
+      new_val
+    end
   end
 end

data/lib/mock_redis/transaction_wrapper.rb

@@ -4,20 +4,27 @@ class MockRedis
   class TransactionWrapper
     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
-      @queued_commands = []
-      @in_multi = false
+      @transaction_futures = []
+      @multi_stack = []
+      @multi_block_given = false
     end
 
-    def method_missing(method, *args, &block)
-      if @in_multi
-        @queued_commands << [method, *args]
-        'QUEUED'
+    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
+          future
+        else
+          'QUEUED'
+        end
       else
         @db.expire_keys
         @db.send(method, *args, &block)
@@ -27,59 +34,86 @@ class MockRedis
     def initialize_copy(source)
       super
       @db = @db.clone
-      @queued_commands = @queued_commands.clone
+      @transaction_futures = @transaction_futures.clone
+      @multi_stack = @multi_stack.clone
     end
 
     def discard
-      unless @in_multi
-        raise Redis::CommandError, "ERR DISCARD without MULTI"
+      unless in_multi?
+        raise Redis::CommandError, 'ERR DISCARD without MULTI'
       end
-      @in_multi = false
-      @queued_commands = []
+      pop_multi
+
+      @transaction_futures = []
       'OK'
     end
 
     def exec
-      unless @in_multi
-        raise Redis::CommandError, "ERR EXEC without MULTI"
+      unless in_multi?
+        raise Redis::CommandError, 'ERR EXEC without MULTI'
       end
-      @in_multi = false
-      responses = @queued_commands.map do |cmd|
+      pop_multi
+      return if in_multi?
+      @multi_block_given = false
+
+      responses = @transaction_futures.map do |future|
         begin
-          send(*cmd)
-        rescue => e
+          result = send(*future.command)
+          future.store_result(result)
+          future.value
+        rescue StandardError => e
           e
         end
       end
-      @queued_commands = []
+
+      @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)
-          self.exec
+          exec
         rescue StandardError => e
-          self.discard
+          discard
           raise e
         end
       else
+        raise Redis::CommandError, 'ERR MULTI calls can not be nested' if in_multi?
+        push_multi
         'OK'
       end
     end
 
+    def pipelined
+      yield(self) if block_given?
+    end
+
     def unwatch
       'OK'
     end
 
-    def watch(_)
-      yield self if block_given?
+    def watch(*_)
+      if block_given?
+        yield self
+      else
+        'OK'
+      end
     end
-
   end
 end