mock_redis 0.32.0 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9f945150c69e6ff81838d4e029f1620ade56e9da6c3cb2ed0550cd61060335a
-  data.tar.gz: fbd58f70dbf78b770a6d3e04351771a1d94a7cac87afbff95213c92bceb16eaa
+  metadata.gz: 7e495091d84ea1fec4bf5206d2a02e32c446ef0bd89b0feaed38f31d95b142b2
+  data.tar.gz: 696f65058fe29cd5fa849363b6cfa60454a432c0d392f530ac1494cba31ff062
 SHA512:
-  metadata.gz: 9320958fc6e3360f26317dfcb47747bf8d39d626d54c0297cece31b9521fc4ad991acdccf885428d05f8b82765cfec12a37af4de33473f4106c7e3eb4e9c2b69
-  data.tar.gz: 05c04acff0f82500f114a868ed40aef95fc115e367ed94008075ddd90de5550dd939ca12215ffb3c88021a6aeff18cd3f9ff51dfabcc3f14244b40465d6184f0
+  metadata.gz: 78b558108b350dc35df4d1f202e96326096394f9e23d89398d07cdbb33c6b088e0089467b14624a9e2c73210406457e291ab0cb09495a8d12a854df5ab8da1c3
+  data.tar.gz: f7e6d3021a4f2f5dd78e53d126ecea26fa7d3f8903bbcf96b0cf2a03b74049acbb169a18ff571c2aab18a0678cf57b90908d06b8c0e10039e00fce5b6050ad26

data/CHANGELOG.md

@@ -1,5 +1,64 @@
 # MockRedis Changelog
 
+### 0.44.0
+
+* Add suppore for `memory usage` command
+
+### 0.43.0
+
+* Fix issue when using with `redis-store` gem
+
+### 0.42.0
+
+* Drop support for Ruby 2.x
+* Add support for `srem?`
+
+### 0.41.0
+
+* Add support for `expire`-related command options `nx`/`xx`/`lt`/`gt`
+
+### 0.40.0
+
+* Add support for `call` method name to be case insensitive
+* Add support for `zmscore`
+
+### 0.39.0
+
+* Add support for calling `call` in `pipelined` block
+* Fix `sadd` to stringify array
+
+### 0.38.0
+
+* Fix detection of stream key types
+* Add support for `EXAT` AND `PXAT` arguments to `SET` command
+
+### 0.37.0
+
+* Require Ruby 2.7 or newer, since Ruby 2.6 and older are EOL
+* Remove unnecessary files from gem contents
+* Add support for popping multiple items with `lpop`
+* Add support for `scan` with type option
+* Add support for `sadd?`
+* Add support for scanning on keys containing hash tags (`{...}`)
+
+### 0.36.0
+
+* Add support for `smismember`
+* Add support for `lmove` and `blmove`
+* Fix `zrem` to support passing array of integers
+
+### 0.35.0
+
+* Add support for `getdel`
+
+### 0.34.0
+
+* Add support for `with`
+
+### 0.33.0
+
+* Add support for `GET` argument to `SET` command
+
 ### 0.32.0
 
 * Add support for `psetex`

data/README.md

@@ -10,7 +10,7 @@ for use in tests.
 
 ## Requirements
 
-Ruby 2.6+
+Ruby 3.0+
 
 The current implementation is tested against Redis 6.2. Older versions may work, but can also return different results or not support some commands.
 
@@ -55,8 +55,8 @@ since it's an in-memory object confined to a single process. MockRedis
 makes every attempt to be Redis-compatible, but there are some
 necessary exceptions.
 
-* Blocking list commands (`#blpop`, `#brpop`, and `#brpoplpush`) work
-  as expected if there is data for them to retrieve. If you use one of
+* Blocking list commands (`#blmove`, `#blpop`, `#brpop`, and `#brpoplpush`)
+  work as expected if there is data for them to retrieve. If you use one of
   these commands with a nonzero timeout and there is no data for it to
   retrieve, then the command returns immediately. However, if you ask
   one of these commands for data with a 0 timeout (means "wait
@@ -105,7 +105,7 @@ We recommend running Redis within a Docker container to make development as simp
 
 1. Start Redis.
    ```bash
-   docker run --rm -p 6379:6379 redis
+   docker run --rm -p 6379:6379 redis:6.2-alpine
    ```
 2. Install dependencies.
    ```bash

data/lib/mock_redis/database.rb

@@ -12,6 +12,7 @@ require 'mock_redis/utility_methods'
 require 'mock_redis/geospatial_methods'
 require 'mock_redis/stream_methods'
 require 'mock_redis/connection_method'
+require 'mock_redis/memory_method'
 
 class MockRedis
   class Database
@@ -26,6 +27,7 @@ class MockRedis
     include GeospatialMethods
     include StreamMethods
     include ConnectionMethod
+    include MemoryMethod
 
     attr_reader :data, :expire_times
 
@@ -43,6 +45,13 @@ class MockRedis
 
     # Redis commands go below this line and above 'private'
 
+    # FIXME: Current implementation of `call` does not work propetly with kwarg-options.
+    # i.e. `call("EXPIRE", "foo", 40, "NX")` (which redis-rb will simply transmit to redis-server)
+    # will be passed to `#expire` without keywords transformation.
+    def call(command, &_block)
+      public_send(command[0].downcase, *command[1..])
+    end
+
     def auth(_)
       'OK'
     end
@@ -71,7 +80,7 @@ class MockRedis
 
     def del(*keys)
       keys = keys.flatten.map(&:to_s)
-      assert_has_args(keys, 'del')
+      # assert_has_args(keys, 'del') # no longer errors in redis > v4.5
 
       keys.
         find_all { |key| data[key] }.
@@ -85,32 +94,42 @@ class MockRedis
       msg.to_s
     end
 
-    def expire(key, seconds)
+    def expire(key, seconds, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
       assert_valid_integer(seconds)
 
-      pexpire(key, seconds.to_i * 1000)
+      pexpire(key, seconds.to_i * 1000, nx: nx, xx: xx, lt: lt, gt: gt)
     end
 
-    def pexpire(key, ms)
+    def pexpire(key, ms, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
       assert_valid_integer(ms)
 
       now, miliseconds = @base.now
       now_ms = (now * 1000) + miliseconds
-      pexpireat(key, now_ms + ms.to_i)
+      pexpireat(key, now_ms + ms.to_i, nx: nx, xx: xx, lt: lt, gt: gt)
     end
 
-    def expireat(key, timestamp)
+    def expireat(key, timestamp, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
       assert_valid_integer(timestamp)
 
-      pexpireat(key, timestamp.to_i * 1000)
+      pexpireat(key, timestamp.to_i * 1000, nx: nx, xx: xx, lt: lt, gt: gt)
     end
 
-    def pexpireat(key, timestamp_ms)
+    def pexpireat(key, timestamp_ms, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
       assert_valid_integer(timestamp_ms)
 
-      if exists?(key)
-        timestamp = Rational(timestamp_ms.to_i, 1000)
-        set_expiration(key, @base.time_at(timestamp))
+      if nx && gt || gt && lt || lt && nx || nx && xx
+        raise Redis::CommandError, <<~TXT.chomp
+          ERR NX and XX, GT or LT options at the same time are not compatible
+        TXT
+      end
+
+      return false unless exists?(key)
+
+      expiry = expiration(key)
+      new_expiry = @base.time_at(Rational(timestamp_ms.to_i, 1000))
+
+      if should_update_expiration?(expiry, new_expiry, nx: nx, xx: xx, lt: lt, gt: gt)
+        set_expiration(key, new_expiry)
         true
       else
         false
@@ -267,6 +286,8 @@ class MockRedis
         'set'
       elsif zsety?(key)
         'zset'
+      elsif streamy?(key)
+        'stream'
       else
         raise ArgumentError, "Not sure how #{data[key].inspect} got in here"
       end
@@ -318,7 +339,7 @@ class MockRedis
     end
 
     def expiration(key)
-      expire_times.find { |(_, k)| k == key.to_s }.first
+      expire_times.find { |(_, k)| k == key.to_s }&.first
     end
 
     def has_expiration?(key)
@@ -333,10 +354,18 @@ class MockRedis
       !!Float(str) rescue false
     end
 
+    def should_update_expiration?(expiry, new_expiry, nx:, xx:, lt:, gt:) # rubocop:disable Metrics/ParameterLists
+      return false if nx && expiry || xx && !expiry
+      return false if lt && expiry && new_expiry > expiry
+      return false if gt && (!expiry || new_expiry < expiry)
+
+      true
+    end
+
     def redis_pattern_to_ruby_regex(pattern)
       Regexp.new(
         "^#{pattern}$".
-        gsub(/([+|()])/, '\\\\\1').
+        gsub(/([+|(){}])/, '\\\\\1').
         gsub(/(?<!\\)\?/, '\\1.').
         gsub(/([^\\])\*/, '\\1.*')
       )

data/lib/mock_redis/geospatial_methods.rb

@@ -1,7 +1,7 @@
 class MockRedis
   module GeospatialMethods
-    LNG_RANGE = (-180..180).freeze
-    LAT_RANGE = (-85.05112878..85.05112878).freeze
+    LNG_RANGE = (-180..180)
+    LAT_RANGE = (-85.05112878..85.05112878)
     STEP = 26
     UNITS = {
       m: 1,

data/lib/mock_redis/hash_methods.rb

@@ -93,7 +93,7 @@ class MockRedis
     def hmset(key, *kvpairs)
       if key.is_a? Array
         err_msg = 'ERR wrong number of arguments for \'hmset\' command'
-        kvpairs = key[1..-1]
+        kvpairs = key[1..]
         key = key[0]
       end
 

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)

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

@@ -31,7 +31,7 @@ class MockRedis
 
     # Redis commands
     def flushall
-      @databases.values.each(&:flushdb)
+      @databases.each_value(&:flushdb)
       'OK'
     end
 

data/lib/mock_redis/pipelined_wrapper.rb

@@ -41,22 +41,20 @@ class MockRedis
       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
-          else
-            [result]
-          end
-        rescue StandardError => e
-          e
+        if future.block
+          result
+        else
+          [result]
         end
+      rescue StandardError => e
+        e
       end
       @pipelined_futures = []
       responses

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
@@ -126,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
@@ -165,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.rb

@@ -37,7 +37,7 @@ class MockRedis
         @members = if count == 0
                      Set.new
                    else
-                     @members.to_a[-count..-1].to_set
+                     @members.to_a[-count..].to_set
                    end
         deleted
       else
@@ -71,8 +71,8 @@ class MockRedis
       items
     end
 
-    def each
-      members.each { |m| yield m }
+    def each(&block)
+      members.each(&block)
     end
 
     private

data/lib/mock_redis/string_methods.rb

@@ -38,7 +38,7 @@ class MockRedis
         type, offset = args.shift(2)
 
         is_signed = type.slice(0) == 'i'
-        type_size = type[1..-1].to_i
+        type_size = type[1..].to_i
 
         if (type_size > 64 && is_signed) || (type_size >= 64 && !is_signed)
           raise Redis::CommandError,
@@ -47,7 +47,7 @@ class MockRedis
         end
 
         if offset.to_s[0] == '#'
-          offset = offset[1..-1].to_i * type_size
+          offset = offset[1..].to_i * type_size
         end
 
         bits = []
@@ -107,6 +107,12 @@ class MockRedis
       end
     end
 
+    def getdel(key)
+      value = get(key)
+      del(key)
+      value
+    end
+
     def getrange(key, start, stop)
       assert_stringy(key)
       (data[key] || '')[start..stop]
@@ -204,10 +210,13 @@ class MockRedis
       msetnx(*hash.to_a.flatten)
     end
 
-    # Parameer list required to ensure the ArgumentError is returned correctly
+    # Parameter 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)
+    def set(key, value, _hash = nil, ex: nil, px: nil, exat: nil, pxat: nil, nx: nil, xx: nil,
+      keepttl: nil, get: nil)
       key = key.to_s
+      retval = self.get(key) if get
+
       return_true = false
       if nx
         if exists?(key)
@@ -240,7 +249,25 @@ class MockRedis
         pexpire(key, px)
       end
 
-      return_true ? true : 'OK'
+      if exat
+        if exat == 0
+          raise Redis::CommandError, 'ERR invalid expire time in set'
+        end
+        expireat(key, exat)
+      end
+
+      if pxat
+        if pxat == 0
+          raise Redis::CommandError, 'ERR invalid expire time in set'
+        end
+        pexpireat(key, pxat)
+      end
+
+      if get
+        retval
+      else
+        return_true ? true : 'OK'
+      end
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -353,7 +380,7 @@ class MockRedis
       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)..] || '')
       data[key].length
     end
 

data/lib/mock_redis/transaction_wrapper.rb

@@ -57,13 +57,11 @@ class MockRedis
       @multi_block_given = false
 
       responses = @transaction_futures.map do |future|
-        begin
-          result = send(*future.command)
-          future.store_result(result)
-          future.value
-        rescue StandardError => e
-          e
-        end
+        result = send(*future.command)
+        future.store_result(result)
+        future.value
+      rescue StandardError => e
+        e
       end
 
       @transaction_futures = []

data/lib/mock_redis/utility_methods.rb

@@ -28,6 +28,7 @@ class MockRedis
       cursor = cursor.to_i
       match = opts[:match] || '*'
       key = opts[:key] || lambda { |x| x }
+      type_opt = opts[:type]
       filtered_values = []
 
       limit = cursor + count
@@ -35,7 +36,8 @@ class MockRedis
 
       unless values[cursor...limit].nil?
         filtered_values = values[cursor...limit].select do |val|
-          redis_pattern_to_ruby_regex(match).match(key.call(val))
+          redis_pattern_to_ruby_regex(match).match(key.call(val)) &&
+            (type_opt.nil? || type(val) == type_opt)
         end
       end
 
@@ -68,7 +70,7 @@ class MockRedis
     end
 
     def left_pad(str, size)
-      str = '0' + str while str.length < size
+      str = "0#{str}" while str.length < size
 
       str
     end

data/lib/mock_redis/version.rb

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

data/lib/mock_redis/zset.rb

@@ -10,9 +10,11 @@ class MockRedis
 
     def_delegators :members, :empty?, :include?, :size
 
-    def initialize
+    def initialize(enum = nil)
       @members = Set.new
-      @scores  = {}
+      @members.merge(enum) if enum
+
+      @scores = {}
     end
 
     def initialize_copy(source)

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.to_s =~ /(\+|\-)inf/
+      assert_scorey(score) unless score.to_s =~ /(\+|-)inf/
 
       with_zset_at(key) do |zset|
         if zadd_options[:incr]
@@ -147,7 +147,7 @@ class MockRedis
         else
           retval = args.map { |member| !!zscore(key, member.to_s) }.count(true)
           with_zset_at(key) do |z|
-            args.each { |member| z.delete?(member) }
+            args.each { |member| z.delete?(member.to_s) }
           end
         end
       end
@@ -233,6 +233,15 @@ class MockRedis
       end
     end
 
+    def zmscore(key, *members)
+      with_zset_at(key) do |z|
+        members.map do |member|
+          score = z.score(member.to_s)
+          score&.to_f
+        end
+      end
+    end
+
     def zunionstore(destination, keys, options = {})
       assert_has_args(keys, 'zunionstore')
 
@@ -316,7 +325,7 @@ class MockRedis
         with_zset_at(keys.first, coercible: coercible, &blk)
       else
         with_zset_at(keys.first, coercible: coercible) do |set|
-          with_zsets_at(*(keys[1..-1]), coercible: coercible) do |*sets|
+          with_zsets_at(*(keys[1..]), coercible: coercible) do |*sets|
             yield(*([set] + sets))
           end
         end
@@ -351,7 +360,7 @@ class MockRedis
     end
 
     def assert_scorey(value, message = 'ERR value is not a valid float')
-      return if value.to_s =~ /\(?(\-|\+)inf/
+      return if value.to_s =~ /\(?(-|\+)inf/
 
       value = $1 if value.to_s =~ /\((.*)/
       unless looks_like_float?(value)

data/lib/mock_redis.rb

@@ -1,5 +1,4 @@
 require 'set'
-require 'ruby2_keywords'
 
 require 'mock_redis/assertions'
 require 'mock_redis/database'
@@ -50,10 +49,6 @@ class MockRedis
   end
   alias location id
 
-  def call(command, &_block)
-    send(*command)
-  end
-
   def host
     options[:host]
   end
@@ -86,6 +81,10 @@ class MockRedis
     self
   end
 
+  def with
+    yield self
+  end
+
   def respond_to?(method, include_private = false)
     super || @db.respond_to?(method, include_private)
   end
@@ -126,7 +125,7 @@ class MockRedis
         defaults[:host]     = uri.host
         defaults[:port]     = uri.port if uri.port
         defaults[:password] = uri.password if uri.password
-        defaults[:db]       = uri.path[1..-1].to_i if uri.path
+        defaults[:db]       = uri.path[1..].to_i if uri.path
       end
     end