mock_redis 0.19.0 → 0.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da2c2693b445e51b487e52f7c9b3986960417686792f9a5e554ca4d215c323e2
-  data.tar.gz: 8da2170fcc49e768133a61deb716d72cc18d66291567008d96287b8d2104b15c
+  metadata.gz: 7e495091d84ea1fec4bf5206d2a02e32c446ef0bd89b0feaed38f31d95b142b2
+  data.tar.gz: 696f65058fe29cd5fa849363b6cfa60454a432c0d392f530ac1494cba31ff062
 SHA512:
-  metadata.gz: 15b8b59cff1120de0befaee6cf08facfb120e239d3fbc1b6b55f40bb60c526f57e5cbb61f1d9f6fd5538067122e49b80e9e782590cd98070a3d49943ec8bb929
-  data.tar.gz: 52a09f0896a405137be0075db930bec09898dd96e3d5366a95ef6a189268348f91244c051dbe45db5b4b37023a12f87552868fcaf2a5383316bebe9bdaf44997
+  metadata.gz: 78b558108b350dc35df4d1f202e96326096394f9e23d89398d07cdbb33c6b088e0089467b14624a9e2c73210406457e291ab0cb09495a8d12a854df5ab8da1c3
+  data.tar.gz: f7e6d3021a4f2f5dd78e53d126ecea26fa7d3f8903bbcf96b0cf2a03b74049acbb169a18ff571c2aab18a0678cf57b90908d06b8c0e10039e00fce5b6050ad26

data/CHANGELOG.md

@@ -1,5 +1,166 @@
 # 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`
+
+### 0.31.0
+
+* Allow `ping` to take argument
+* Raise `CommandError` on `hmget` with empty list of fields
+
+### 0.30.0
+
+* Drop support for Ruby 2.4 and Ruby 2.5 since they are EOL
+* Fix `expire` to to raise error on invalid integer
+
+### 0.29.0
+
+* Add support for `logger` option ([#211](https://github.com/sds/mock_redis/pull/211))
+* Fix `zadd` to not perform conditional type conversion ([#214](https://github.com/sds/mock_redis/pull/214))
+* Fix `hdel` to raise error when called with empty array ([#215](https://github.com/sds/mock_redis/pull/215))
+
+### 0.28.0
+
+* Fix `hmset` exception ([#206](https://github.com/sds/mock_redis/pull/206))
+* Fix `hmset` to accept hashes in addition to key/value pairs ([#208](https://github.com/sds/mock_redis/pull/208))
+* Fix stream ID regex to support `(` ([#209](https://github.com/sds/mock_redis/pull/209))
+* Allow `mget` to accept a block ([#210](https://github.com/sds/mock_redis/pull/210))
+
+### 0.27.3
+
+* Ensure `ruby2_keywords` dependency is `require`d at runtime
+
+### 0.27.2
+
+* Switch `ruby2_keywords` gem from development dependency to runtime dependency
+
+### 0.27.1
+
+* Fix missing `ruby2_keywords` gem
+* Allow passing string `offset` to `getbit` ([#203](https://github.com/sds/mock_redis/pull/203))
+
+### 0.27.0
+
+* Fix handling of keyword arguments on Ruby 3 ([#199](https://github.com/sds/mock_redis/pull/199))
+* Allow passing string `offset` to `setbit` ([#200](https://github.com/sds/mock_redis/pull/200))
+* Add `connection` method ([#201](https://github.com/sds/mock_redis/pull/201))
+
+### 0.26.0
+
+* Add block and count support to `xread` ([#194](https://github.com/sds/mock_redis/pull/194))
+
+### 0.25.0
+
+* Add support for `xread` command ([#190](https://github.com/sds/mock_redis/pull/190))
+* Fix `mget` to raise error when passing empty array ([#191](https://github.com/sds/mock_redis/pull/191))
+* Fix `xadd` when `maxlen` is zero ([#192](https://github.com/sds/mock_redis/pull/192))
+
+### 0.24.0
+
+* Fix handling of blocks within `multi` blocks ([#185](https://github.com/sds/mock_redis/pull/185))
+* Fix handling of multiple consecutive `?` characters in key pattern matching ([#186](https://github.com/sds/mock_redis/pull/186))
+* Change `exists` to return an integer and add `exists?` ([#188](https://github.com/sds/mock_redis/pull/188))
+
+### 0.23.0
+
+* Raise error when `setex` called with negative timeout ([#174](https://github.com/sds/mock_redis/pull/174))
+* Add support for `dump`/`restore` between MockRedis instances ([#176](https://github.com/sds/mock_redis/pull/176))
+* Fix warnings for ZSET methods on Ruby 2.7 ([#177](https://github.com/sds/mock_redis/pull/177))
+* Add support for returning time in pipelines ([#179](https://github.com/sds/mock_redis/pull/179))
+* Fix SET methods to correct set milliseconds with `px` ([#180](https://github.com/sds/mock_redis/pull/180))
+* Add support for unsorted sets within `zinterstore`/`zunionstore`([#182](https://github.com/sds/mock_redis/pull/182))
+
+### 0.22.0
+
+* Gracefully handle cursors larger than the collection size in scan commands ([#171](https://github.com/sds/mock_redis/pull/171))
+* Add `zpopmin` and `zpopmax` commands ([#172](https://github.com/sds/mock_redis/pull/172))
+* Fix `hmset` to support array arguments ([#173](https://github.com/sds/mock_redis/pull/173))
+* Fix `hmset` to always treat keys as strings ([#173](https://github.com/sds/mock_redis/pull/173))
+* Remove unnecessary dependency on `rake` gem
+
+### 0.21.0
+
+* Fix behavior of `time` to return array of two integers ([#161](https://github.com/sds/mock_redis/pull/161))
+* Add support for `close` and `disconnect!` ([#163](https://github.com/sds/mock_redis/pull/163))
+* Fix `set` to properly handle (and ignore) other options ([#164](https://github.com/sds/mock_redis/pull/163))
+* Fix `srem` to allow array of integers as argument ([#166](https://github.com/sds/mock_redis/pull/166))
+* Fix `hdel` to allow array as argument ([#168](https://github.com/sds/mock_redis/pull/168))
+
+### 0.20.0
+
+* Add support for `count` parameter of `spop`
+* Fix `mget` and `mset` to accept array as parameters
+* Fix pipelined array replies
+* Fix nested pipelining
+* Allow nested multi
+* Require Redis gem 4.0.1 or newer
+* Add support for stream commands on Redis 5
+* Keep empty strings on type mismatch
+* Improve performance of `set_expiration`
+* Fix `watch` to allow multiple keys
+* Add `unlink` alias for `del`
+* Drop support for Ruby 2.3 or older
+
 ### 0.19.0
 
 * Require Ruby 2.2+

data/LICENSE.md

@@ -0,0 +1,21 @@
+MockRedis released under the MIT license.
+
+> Copyright (c) Shane da Silva. http://shane.io
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.

data/README.md

@@ -1,18 +1,27 @@
 # MockRedis
 
 [![Gem Version](https://badge.fury.io/rb/mock_redis.svg)](http://badge.fury.io/rb/mock_redis)
-[![Build Status](https://travis-ci.org/brigade/mock_redis.svg)](https://travis-ci.org/brigade/mock_redis)
-[![Coverage Status](https://coveralls.io/repos/brigade/mock_redis/badge.svg)](https://coveralls.io/r/brigade/mock_redis)
+![Build Status](https://github.com/sds/mock_redis/actions/workflows/tests.yml/badge.svg)
+[![Coverage Status](https://coveralls.io/repos/sds/mock_redis/badge.svg)](https://coveralls.io/r/sds/mock_redis)
 
 MockRedis provides the same interface as `redis-rb`, but it stores its
 data in memory instead of talking to a Redis server. It is intended
 for use in tests.
 
-The current implementation is tested against *Redis 4*. Older versions
-of Redis may return different results or not support some commands.
+## Requirements
+
+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.
 
 ## Getting Started
 
+Install the gem:
+
+```bash
+gem install mock_redis
+```
+
 It's as easy as `require 'mock_redis'; mr = MockRedis.new`. Then you can
 call the same methods on it as you can call on a real `Redis` object.
 
@@ -46,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
@@ -90,17 +99,32 @@ please submit a pull request with your (tested!) implementation.
 * `#config(:get|:set|:resetstat)` isn't done. They can just return
   canned values.
 
-## Compatibility
+## Running tests
+
+We recommend running Redis within a Docker container to make development as simple as possible, but as long as you have a Redis instance listening on `localhost:6379` you should be good to go.
+
+1. Start Redis.
+   ```bash
+   docker run --rm -p 6379:6379 redis:6.2-alpine
+   ```
+2. Install dependencies.
+   ```bash
+   bundle install
+   ```
+3. Run tests.
+   ```bash
+   bundle exec rspec
+   ```
+
+These tests were written with Redis running on `localhost` without any
+passwords required. If you're using a different version of Redis, you
+may see failures due to error message text being different and other
+breaking changes over time.
+
+## Changelog
 
-As of version `0.19.0`, Ruby 2.2 and above are supported. For
-older versions of Ruby, use `0.18.0` or older.
+If you're interested in seeing the changes and bug fixes between each version of `mock_redis`, read the [MockRedis Changelog](CHANGELOG.md).
 
-## Running the Tests
+## License
 
-If you want to work on this, you'll probably want to run the
-tests. (Just kidding! There's no probably about it.) These tests were
-written with Redis running on `localhost` without any passwords
-required. If you're using a different version of Redis, you may see
-failures due to error message text being different. If you're running
-a really old version of Redis, you'll definitely see failures due to
-stuff that doesn't work!
+This project is released under the [MIT license](LICENSE.md).

data/lib/mock_redis/connection_method.rb

@@ -0,0 +1,13 @@
+class MockRedis
+  module ConnectionMethod
+    def connection
+      {
+        :host => @base.host,
+        :port => @base.port,
+        :db => @base.db,
+        :id => @base.id,
+        :location => "#{@base.host}:#{@base.port}"
+      }
+    end
+  end
+end

data/lib/mock_redis/database.rb

@@ -10,6 +10,9 @@ require 'mock_redis/indifferent_hash'
 require 'mock_redis/info_method'
 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
@@ -22,6 +25,9 @@ class MockRedis
     include InfoMethod
     include UtilityMethods
     include GeospatialMethods
+    include StreamMethods
+    include ConnectionMethod
+    include MemoryMethod
 
     attr_reader :data, :expire_times
 
@@ -33,12 +39,19 @@ class MockRedis
 
     def initialize_copy(_source)
       @data = @data.clone
-      @data.keys.each { |k| @data[k] = @data[k].clone }
+      @data.each_key { |k| @data[k] = @data[k].clone }
       @expire_times = @expire_times.map(&:clone)
     end
 
     # 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
@@ -54,6 +67,8 @@ class MockRedis
     def disconnect
       nil
     end
+    alias close disconnect
+    alias disconnect! close
 
     def connected?
       true
@@ -65,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] }.
@@ -73,48 +88,81 @@ class MockRedis
         each { |k| data.delete(k) }.
         length
     end
+    alias unlink del
 
     def echo(msg)
       msg.to_s
     end
 
-    def expire(key, seconds)
-      pexpire(key, seconds.to_i * 1000)
+    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, nx: nx, xx: xx, lt: lt, gt: gt)
     end
 
-    def pexpire(key, ms)
-      now_ms = (@base.now.to_r * 1000).to_i
-      pexpireat(key, now_ms + ms.to_i)
+    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, nx: nx, xx: xx, lt: lt, gt: gt)
     end
 
-    def expireat(key, timestamp)
-      unless looks_like_integer?(timestamp.to_s)
-        raise Redis::CommandError, 'ERR value is not an integer or out of range'
-      end
+    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)
-      unless looks_like_integer?(timestamp_ms.to_s)
-        raise Redis::CommandError, 'ERR value is not an integer or out of range'
+    def pexpireat(key, timestamp_ms, nx: nil, xx: nil, lt: nil, gt: nil) # rubocop:disable Metrics/ParameterLists
+      assert_valid_integer(timestamp_ms)
+
+      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
 
-      if exists(key)
-        timestamp = Rational(timestamp_ms.to_i, 1000)
-        set_expiration(key, @base.time_at(timestamp))
+      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
       end
     end
 
-    def exists(key)
-      data.key?(key)
+    def exists(*keys)
+      keys.count { |key| data.key?(key) }
+    end
+
+    def exists?(*keys)
+      keys.each { |key| return true if data.key?(key) }
+      false
     end
 
     def flushdb
-      data.keys.each { |k| del(k) }
+      data.each_key { |k| del(k) }
+      'OK'
+    end
+
+    def dump(key)
+      value = data[key]
+      value ? Marshal.dump(value) : nil
+    end
+
+    def restore(key, ttl, value, replace: false)
+      if !replace && exists?(key)
+        raise Redis::CommandError, 'BUSYKEY Target key name already exists.'
+      end
+      data[key] = Marshal.load(value) # rubocop:disable Security/MarshalLoad
+      if ttl > 0
+        pexpire(key, ttl)
+      end
       'OK'
     end
 
@@ -137,11 +185,11 @@ class MockRedis
     end
 
     def lastsave
-      @base.now.to_i
+      now.first
     end
 
     def persist(key)
-      if exists(key) && has_expiration?(key)
+      if exists?(key) && has_expiration?(key)
         remove_expiration(key)
         true
       else
@@ -149,8 +197,8 @@ class MockRedis
       end
     end
 
-    def ping
-      'PONG'
+    def ping(response = 'PONG')
+      response
     end
 
     def quit
@@ -182,7 +230,7 @@ class MockRedis
         raise Redis::CommandError, 'ERR no such key'
       end
 
-      if exists(newkey)
+      if exists?(newkey)
         false
       else
         rename(key, newkey)
@@ -195,27 +243,38 @@ class MockRedis
     end
 
     def ttl(key)
-      if !exists(key)
+      if !exists?(key)
         -2
       elsif has_expiration?(key)
-        expiration(key).to_i - @base.now.to_i
+        now, = @base.now
+        expiration(key).to_i - now
       else
         -1
       end
     end
 
     def pttl(key)
-      if !exists(key)
+      now, miliseconds = @base.now
+      now_ms = now * 1000 + miliseconds
+
+      if !exists?(key)
         -2
       elsif has_expiration?(key)
-        (expiration(key).to_r * 1000).to_i - (@base.now.to_r * 1000).to_i
+        (expiration(key).to_r * 1000).to_i - now_ms
       else
         -1
       end
     end
 
+    def now
+      current_time = @base.options[:time_class].now
+      miliseconds = (current_time.to_r - current_time.to_i) * 1_000
+      [current_time.to_i, miliseconds.to_i]
+    end
+    alias time now
+
     def type(key)
-      if !exists(key)
+      if !exists?(key)
         'none'
       elsif hashy?(key)
         'hash'
@@ -227,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
@@ -240,6 +301,13 @@ class MockRedis
 
     private
 
+    def assert_valid_integer(integer)
+      unless looks_like_integer?(integer.to_s)
+        raise Redis::CommandError, 'ERR value is not an integer or out of range'
+      end
+      integer
+    end
+
     def assert_valid_timeout(timeout)
       if !looks_like_integer?(timeout.to_s)
         raise Redis::CommandError, 'ERR timeout is not an integer or out of range'
@@ -271,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)
@@ -286,11 +354,19 @@ 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.').
         gsub(/([^\\])\*/, '\\1.*')
       )
     end
@@ -303,11 +379,9 @@ class MockRedis
 
     def set_expiration(key, time)
       remove_expiration(key)
-
-      expire_times << [time, key.to_s]
-      expire_times.sort! do |a, b|
-        a.first <=> b.first
-      end
+      found = expire_times.each_with_index.to_a.bsearch { |item, _| item.first >= time }
+      index = found ? found.last : -1
+      expire_times.insert(index, [time, key.to_s])
     end
 
     def zero_pad(string, desired_length)
@@ -320,10 +394,11 @@ class MockRedis
     # This method isn't private, but it also isn't a Redis command, so
     # it doesn't belong up above with all the Redis commands.
     def expire_keys
-      now = @base.now
+      now_sec, miliseconds = now
+      now_ms = now_sec * 1_000 + miliseconds
 
       to_delete = expire_times.take_while do |(time, _key)|
-        (time.to_r * 1_000).to_i <= (now.to_r * 1_000).to_i
+        (time.to_r * 1_000).to_i <= now_ms
       end
 
       to_delete.each do |(_time, key)|

data/lib/mock_redis/expire_wrapper.rb

@@ -12,7 +12,7 @@ class MockRedis
       @db = db
     end
 
-    def method_missing(method, *args, &block)
+    ruby2_keywords def method_missing(method, *args, &block)
       @db.expire_keys
       @db.send(method, *args, &block)
     end

data/lib/mock_redis/future.rb

@@ -17,7 +17,7 @@ class MockRedis
 
     def store_result(result)
       @result_set = true
-      @result = result
+      @result = @block ? @block.call(result) : result
     end
   end
 end