mock_redis 0.5.4 → 0.31.0

data/lib/mock_redis/database.rb

@@ -5,6 +5,13 @@ require 'mock_redis/list_methods'
 require 'mock_redis/set_methods'
 require 'mock_redis/string_methods'
 require 'mock_redis/zset_methods'
+require 'mock_redis/sort_method'
+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'
 
 class MockRedis
   class Database
@@ -13,277 +20,157 @@ class MockRedis
     include SetMethods
     include StringMethods
     include ZsetMethods
+    include SortMethod
+    include InfoMethod
+    include UtilityMethods
+    include GeospatialMethods
+    include StreamMethods
+    include ConnectionMethod
 
     attr_reader :data, :expire_times
 
-    def initialize(*args)
-      @data = {}
+    def initialize(base, *_args)
+      @base = base
+      @data = MockRedis::IndifferentHash.new
       @expire_times = []
     end
 
-    def initialize_copy(source)
+    def initialize_copy(_source)
       @data = @data.clone
-      @data.keys.each {|k| @data[k] = @data[k].clone}
-      @expire_times = @expire_times.map{|x| x.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'
 
-    def auth(_) 'OK' end
+    def auth(_)
+      'OK'
+    end
+
+    def bgrewriteaof
+      'Background append only file rewriting started'
+    end
 
-    def bgrewriteaof() "Background append only file rewriting started" end
+    def bgsave
+      'Background saving started'
+    end
+
+    def disconnect
+      nil
+    end
+    alias close disconnect
+    alias disconnect! close
 
-    def bgsave() "Background saving started" end
+    def connected?
+      true
+    end
 
     def dbsize
       data.keys.length
     end
 
     def del(*keys)
+      keys = keys.flatten.map(&:to_s)
+      assert_has_args(keys, 'del')
+
       keys.
-        find_all{|key| data[key]}.
-        each {|k| persist(k)}.
-        each {|k| data.delete(k)}.
+        find_all { |key| data[key] }.
+        each { |k| persist(k) }.
+        each { |k| data.delete(k) }.
         length
     end
+    alias unlink del
 
     def echo(msg)
       msg.to_s
     end
 
     def expire(key, seconds)
-      expireat(key, Time.now.to_i + seconds.to_i)
+      assert_valid_integer(seconds)
+
+      pexpire(key, seconds.to_i * 1000)
+    end
+
+    def pexpire(key, ms)
+      assert_valid_integer(ms)
+
+      now, miliseconds = @base.now
+      now_ms = (now * 1000) + miliseconds
+      pexpireat(key, now_ms + ms.to_i)
     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
+      assert_valid_integer(timestamp)
 
-      if exists(key)
-        set_expiration(key, Time.at(timestamp.to_i))
+      pexpireat(key, timestamp.to_i * 1000)
+    end
+
+    def pexpireat(key, timestamp_ms)
+      assert_valid_integer(timestamp_ms)
+
+      if exists?(key)
+        timestamp = Rational(timestamp_ms.to_i, 1000)
+        set_expiration(key, @base.time_at(timestamp))
         true
       else
         false
       end
     end
 
-    def exists(key)
-      data.has_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
 
-    def info
-      astats = [
-        ["2", "2699"],
-        ["6", "1"],
-        ["7", "1"],
-        ["8", "17197"],
-        ["9", "109875"],
-        ["10", "94348"],
-        ["11", "32580"],
-        ["12", "52347"],
-        ["13", "86475"],
-        ["14", "58175"],
-        ["15", "53408"],
-        ["16", "876949"],
-        ["17", "71157"],
-        ["18", "5104"],
-        ["19", "2705"],
-        ["20", "2903"],
-        ["21", "1024"],
-        ["22", "2546"],
-        ["23", "952"],
-        ["24", "186080"],
-        ["25", "611"],
-        ["26", "40936"],
-        ["27", "960"],
-        ["28", "1323"],
-        ["29", "14216"],
-        ["30", "52412"],
-        ["31", "21130"],
-        ["32", "47959"],
-        ["33", "6891"],
-        ["34", "9712"],
-        ["35", "3366"],
-        ["36", "5737"],
-        ["37", "11274"],
-        ["38", "8057"],
-        ["39", "2957"],
-        ["40", "51200"],
-        ["42", "8220"],
-        ["43", "8278"],
-        ["44", "6539"],
-        ["45", "764"],
-        ["47", "1018"],
-        ["48", "19250"],
-        ["49", "713"],
-        ["51", "51"],
-        ["53", "2"],
-        ["55", "3922"],
-        ["56", "153"],
-        ["57", "614"],
-        ["58", "1"],
-        ["59", "1775"],
-        ["61", "32865"],
-        ["63", "2530"],
-        ["64", "565"],
-        ["65", "1322"],
-        ["67", "1572"],
-        ["69", "1421"],
-        ["71", "1220"],
-        ["72", "241"],
-        ["73", "5432"],
-        ["74", "1122"],
-        ["75", "2555"],
-        ["77", "1539"],
-        ["78", "612"],
-        ["79", "902"],
-        ["81", "1678"],
-        ["83", "51"],
-        ["84", "612"],
-        ["85", "706"],
-        ["87", "410"],
-        ["88", "5435"],
-        ["89", "813"],
-        ["90", "612"],
-        ["93", "153"],
-        ["94", "612"],
-        ["96", "159"],
-        ["97", "306"],
-        ["99", "153"],
-        ["101", "456"],
-        ["103", "741"],
-        ["105", "447"],
-        ["107", "754"],
-        ["109", "414"],
-        ["111", "475"],
-        ["113", "757"],
-        ["115", "287"],
-        ["117", "420"],
-        ["118", "765"],
-        ["119", "642"],
-        ["120", "159"],
-        ["121", "926"],
-        ["122", "612"],
-        ["123", "251"],
-        ["125", "390"],
-        ["127", "354"],
-        ["128", "617"],
-        ["129", "528"],
-        ["131", "298"],
-        ["132", "612"],
-        ["133", "809"],
-        ["135", "244"],
-        ["136", "306"],
-        ["137", "504"],
-        ["139", "201"],
-        ["141", "1124"],
-        ["143", "139"],
-        ["144", "159"],
-        ["145", "1322"],
-        ["147", "410"],
-        ["149", "253"],
-        ["151", "304"],
-        ["153", "312"],
-        ["155", "249"],
-        ["157", "306"],
-        ["159", "348"],
-        ["161", "255"],
-        ["163", "458"],
-        ["165", "5"],
-        ["167", "306"],
-        ["168", "47"],
-        ["169", "214"],
-        ["171", "250"],
-        ["173", "5"],
-        ["177", "10"],
-        ["179", "158"],
-        ["181", "5"],
-        ["183", "10"],
-        ["185", "51"],
-        ["187", "49"],
-        ["191", "5"],
-        ["192", "47"],
-        ["193", "51"],
-        ["197", "112"],
-        ["199", "5"],
-        ["201", "5"],
-        ["203", "5"],
-        ["209", "5"],
-        ["213", "51"],
-        ["217", "102"],
-        ["225", "357"],
-        ["229", "51"],
-        ["233", "204"],
-        ["237", "51"],
-        ["239", "1"],
-        ["247", "46"],
-        ["255", "102"],
-        [">=256", "6201"],
-      ]
-
-      {
-        "allocation_stats" => astats.map {|(a,b)| "#{a}=#{b}"}.join(','),
-        "aof_enabled" => "0",
-        "arch_bits" => "64",
-        "bgrewriteaof_in_progress" => "0",
-        "bgsave_in_progress" => "0",
-        "blocked_clients" => "0",
-        "changes_since_last_save" => "0",
-        "client_biggest_input_buf" => "0",
-        "client_longest_output_list" => "0",
-        "connected_clients" => "1",
-        "connected_slaves" => "0",
-        "db0" => "keys=8,expires=0",
-        "evicted_keys" => "0",
-        "expired_keys" => "0",
-        "hash_max_zipmap_entries" => "512",
-        "hash_max_zipmap_value" => "64",
-        "keyspace_hits" => "62645",
-        "keyspace_misses" => "29757",
-        "last_save_time" => "1310596333",
-        "loading" => "0",
-        "lru_clock" => "1036434",
-        "mem_fragmentation_ratio" => "2.04",
-        "multiplexing_api" => "kqueue",
-        "process_id" => "14508",
-        "pubsub_channels" => "0",
-        "pubsub_patterns" => "0",
-        "redis_git_dirty" => "0",
-        "redis_git_sha1" => "00000000",
-        "redis_version" => "2.2.11",
-        "role" => "master",
-        "total_commands_processed" => "196800",
-        "total_connections_received" => "4359",
-        "uptime_in_days" => "0",
-        "uptime_in_seconds" => "84215",
-        "use_tcmalloc" => "0",
-        "used_cpu_sys" => "5.54",
-        "used_cpu_sys_childrens" => "0.00",
-        "used_cpu_user" => "7.65",
-        "used_cpu_user_childrens" => "0.02",
-        "used_memory" => "931456",
-        "used_memory_human" => "909.62K",
-        "used_memory_rss" => "1904640",
-        "vm_enabled" => "0",
-      }
-    end
-
-    def keys(format)
+    def keys(format = '*')
       data.keys.grep(redis_pattern_to_ruby_regex(format))
     end
 
+    def scan(cursor, opts = {})
+      common_scan(data.keys, cursor, opts)
+    end
+
+    def scan_each(opts = {}, &block)
+      return to_enum(:scan_each, opts) unless block_given?
+      cursor = 0
+      loop do
+        cursor, keys = scan(cursor, opts)
+        keys.each(&block)
+        break if cursor == '0'
+      end
+    end
+
     def lastsave
-      Time.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
@@ -291,8 +178,8 @@ class MockRedis
       end
     end
 
-    def ping
-      'PONG'
+    def ping(response = 'PONG')
+      response
     end
 
     def quit
@@ -304,22 +191,27 @@ class MockRedis
     end
 
     def rename(key, newkey)
-      if !data.include?(key)
-        raise Redis::CommandError, "ERR no such key"
-      elsif key == newkey
-        raise Redis::CommandError, "ERR source and destination objects are the same"
+      unless data.include?(key)
+        raise Redis::CommandError, 'ERR no such key'
       end
-      data[newkey] = data.delete(key)
+
+      if key != newkey
+        data[newkey] = data.delete(key)
+        if has_expiration?(key)
+          set_expiration(newkey, expiration(key))
+          remove_expiration(key)
+        end
+      end
+
       'OK'
     end
 
     def renamenx(key, newkey)
-      if !data.include?(key)
-        raise Redis::CommandError, "ERR no such key"
-      elsif key == newkey
-        raise Redis::CommandError, "ERR source and destination objects are the same"
+      unless data.include?(key)
+        raise Redis::CommandError, 'ERR no such key'
       end
-      if exists(newkey)
+
+      if exists?(newkey)
         false
       else
         rename(key, newkey)
@@ -332,15 +224,38 @@ class MockRedis
     end
 
     def ttl(key)
-      if has_expiration?(key)
-        expiration(key).to_i - Time.now.to_i
+      if !exists?(key)
+        -2
+      elsif has_expiration?(key)
+        now, = @base.now
+        expiration(key).to_i - now
       else
         -1
       end
     end
 
+    def pttl(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 - 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'
@@ -357,13 +272,26 @@ class MockRedis
       end
     end
 
+    def script(subcommand, *args); end
+
+    def evalsha(*args); end
+
+    def eval(*args); end
+
     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_float?(timeout.to_s)
-        raise Redis::CommandError, "ERR timeout is not a float or out of range"
+      if !looks_like_integer?(timeout.to_s)
+        raise Redis::CommandError, 'ERR timeout is not an integer or out of range'
       elsif timeout < 0
-        raise Redis::CommandError, "ERR timeout is negative"
+        raise Redis::CommandError, 'ERR timeout is negative'
       end
       timeout
     end
@@ -377,16 +305,24 @@ class MockRedis
     end
 
     def extract_timeout(arglist)
-      timeout = assert_valid_timeout(arglist.last)
-      [arglist[0..-2], arglist.last]
+      options = arglist.last
+      if options.is_a?(Hash) && options[:timeout]
+        timeout = assert_valid_timeout(options[:timeout])
+        [arglist[0..-2], timeout]
+      elsif options.is_a?(Integer)
+        timeout = assert_valid_timeout(options)
+        [arglist[0..-2], timeout]
+      else
+        [arglist, 0]
+      end
     end
 
     def expiration(key)
-      expire_times.find {|(_,k)| k == key}.first
+      expire_times.find { |(_, k)| k == key.to_s }.first
     end
 
     def has_expiration?(key)
-      expire_times.any? {|(_,k)| k == key}
+      expire_times.any? { |(_, k)| k == key.to_s }
     end
 
     def looks_like_integer?(str)
@@ -400,23 +336,23 @@ class MockRedis
     def redis_pattern_to_ruby_regex(pattern)
       Regexp.new(
         "^#{pattern}$".
-        gsub(/([^\\])\?/, "\\1.").
-        gsub(/([^\\])\*/, "\\1.+"))
+        gsub(/([+|()])/, '\\\\\1').
+        gsub(/(?<!\\)\?/, '\\1.').
+        gsub(/([^\\])\*/, '\\1.*')
+      )
     end
 
     def remove_expiration(key)
-      expire_times.delete_if do |(t, k)|
-        key == k
+      expire_times.delete_if do |(_t, k)|
+        key.to_s == k
       end
     end
 
     def set_expiration(key, time)
       remove_expiration(key)
-
-      expire_times << [time, key]
-      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)
@@ -425,20 +361,20 @@ class MockRedis
     end
 
     public
+
     # 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 = Time.now
+      now_sec, miliseconds = now
+      now_ms = now_sec * 1_000 + miliseconds
 
-      to_delete = expire_times.take_while do |(time, key)|
-        time <= now
+      to_delete = expire_times.take_while do |(time, _key)|
+        (time.to_r * 1_000).to_i <= now_ms
       end
 
-      to_delete.each do |(time, key)|
+      to_delete.each do |(_time, key)|
         del(key)
       end
-
-      expire_times.slice!(0, to_delete.length)
     end
   end
 end

data/lib/mock_redis/expire_wrapper.rb

@@ -4,7 +4,7 @@ class MockRedis
   class ExpireWrapper
     include UndefRedisMethods
 
-    def respond_to?(method, include_private=false)
+    def respond_to?(method, include_private = false)
       super || @db.respond_to?(method)
     end
 
@@ -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

@@ -0,0 +1,23 @@
+class MockRedis
+  class FutureNotReady < RuntimeError; end
+
+  class Future
+    attr_reader :command, :block
+
+    def initialize(command, block = nil)
+      @command = command
+      @block = block
+      @result_set = false
+    end
+
+    def value
+      raise FutureNotReady unless @result_set
+      @result
+    end
+
+    def store_result(result)
+      @result_set = true
+      @result = @block ? @block.call(result) : result
+    end
+  end
+end