mock_redis 0.14.1 → 0.15.0

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
 

data/lib/mock_redis/future.rb

@@ -14,7 +14,7 @@ class MockRedis
       @result
     end
 
-    def set_result(result)
+    def store_result(result)
       @result_set = true
       @result = result
     end

data/lib/mock_redis/hash_methods.rb

@@ -11,7 +11,7 @@ class MockRedis
         if field.is_a?(Array)
           orig_size = hash.size
           fields    = field.map(&:to_s)
-          hash.delete_if { |k,v| fields.include?(k) }
+          hash.delete_if { |k, _v| fields.include?(k) }
           orig_size - hash.size
         else
           hash.delete(field.to_s) ? 1 : 0
@@ -20,28 +20,28 @@ class MockRedis
     end
 
     def hexists(key, field)
-      with_hash_at(key) {|h| h.has_key?(field.to_s)}
+      with_hash_at(key) { |h| h.key?(field.to_s) }
     end
 
     def hget(key, field)
-      with_hash_at(key) {|h| h[field.to_s]}
+      with_hash_at(key) { |h| h[field.to_s] }
     end
 
     def hgetall(key)
-      with_hash_at(key) {|h| h}
+      with_hash_at(key) { |h| h }
     end
 
     def hincrby(key, field, increment)
       with_hash_at(key) do |hash|
         field = field.to_s
         unless can_incr?(data[key][field])
-          raise Redis::CommandError, "ERR hash value is not an integer"
+          raise Redis::CommandError, 'ERR hash value is not an integer'
         end
         unless looks_like_integer?(increment.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 = (hash[field] || "0").to_i + increment.to_i
+        new_value = (hash[field] || '0').to_i + increment.to_i
         hash[field] = new_value.to_s
         new_value
       end
@@ -51,14 +51,14 @@ class MockRedis
       with_hash_at(key) do |hash|
         field = field.to_s
         unless can_incr_float?(data[key][field])
-          raise Redis::CommandError, "ERR hash value is not a valid float"
+          raise Redis::CommandError, 'ERR hash value is not a valid float'
         end
 
         unless looks_like_float?(increment.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 = (hash[field] || "0").to_f + increment.to_f
+        new_value = (hash[field] || '0').to_f + increment.to_f
         new_value = new_value.to_i if new_value % 1 == 0
         hash[field] = new_value.to_s
         new_value
@@ -75,7 +75,7 @@ class MockRedis
 
     def hmget(key, *fields)
       assert_has_args(fields, 'hmget')
-      fields.map{|f| hget(key, f)}
+      fields.map { |f| hget(key, f) }
     end
 
     def mapped_hmget(key, *fields)
@@ -86,10 +86,10 @@ class MockRedis
     def hmset(key, *kvpairs)
       assert_has_args(kvpairs, 'hmset')
       if kvpairs.length.odd?
-        raise Redis::CommandError, "ERR wrong number of arguments for HMSET"
+        raise Redis::CommandError, 'ERR wrong number of arguments for HMSET'
       end
 
-      kvpairs.each_slice(2) do |(k,v)|
+      kvpairs.each_slice(2) do |(k, v)|
         hset(key, k, v)
       end
       'OK'
@@ -106,7 +106,7 @@ class MockRedis
     end
 
     def hset(key, field, value)
-      with_hash_at(key) {|h| h[field.to_s] = value.to_s}
+      with_hash_at(key) { |h| h[field.to_s] = value.to_s }
       true
     end
 
@@ -126,16 +126,17 @@ class MockRedis
     private
 
     def with_hash_at(key, &blk)
-      with_thing_at(key, :assert_hashy, proc {{}}, &blk)
+      with_thing_at(key, :assert_hashy, proc { {} }, &blk)
     end
 
     def hashy?(key)
-      data[key].nil? || data[key].kind_of?(Hash)
+      data[key].nil? || data[key].is_a?(Hash)
     end
 
     def assert_hashy(key)
       unless hashy?(key)
-        raise Redis::CommandError, "WRONGTYPE 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

data/lib/mock_redis/indifferent_hash.rb

@@ -11,5 +11,9 @@ class MockRedis
     def has_key?(key)
       super(key.to_s)
     end
+
+    def key?(key)
+      super(key.to_s)
+    end
   end
 end

data/lib/mock_redis/info_method.rb

@@ -1,127 +1,129 @@
 class MockRedis
   module InfoMethod
     SERVER_INFO = {
-      "arch_bits" => "64",
-      "gcc_version" => "4.2.1",
-      "lru_clock" => "1036434",
-      "multiplexing_api" => "kqueue",
-      "os" => "Darwin 12.2.1 x86_64",
-      "process_id" => "14508",
-      "redis_git_dirty" => "0",
-      "redis_git_sha1" => "00000000",
-      "redis_mode" => "standalone",
-      "redis_version" => "2.6.10",
-      "run_id" => "1f3f7af2fc11eb68011eb43e154adce125c85e9a",
-      "tcp_port" => "6379",
-      "uptime_in_days" => "0",
-      "uptime_in_seconds" => "84215"
+      'arch_bits' => '64',
+      'gcc_version' => '4.2.1',
+      'lru_clock' => '1036434',
+      'multiplexing_api' => 'kqueue',
+      'os' => 'Darwin 12.2.1 x86_64',
+      'process_id' => '14508',
+      'redis_git_dirty' => '0',
+      'redis_git_sha1' => '00000000',
+      'redis_mode' => 'standalone',
+      'redis_version' => '2.6.10',
+      'run_id' => '1f3f7af2fc11eb68011eb43e154adce125c85e9a',
+      'tcp_port' => '6379',
+      'uptime_in_days' => '0',
+      'uptime_in_seconds' => '84215',
     }
 
     CLIENTS_INFO = {
-      "blocked_clients" => "0",
-      "client_biggest_input_buf" => "0",
-      "client_longest_output_list" => "0",
-      "connected_clients" => "1"
+      'blocked_clients' => '0',
+      'client_biggest_input_buf' => '0',
+      'client_longest_output_list' => '0',
+      'connected_clients' => '1',
     }
 
     MEMORY_INFO = {
-      "mem_allocator" => "libc",
-      "mem_fragmentation_ratio" => "2.04",
-      "used_memory" => "931456",
-      "used_memory_human" => "909.62K",
-      "used_memory_lua" => "31744",
-      "used_memory_peak" => "1005424",
-      "used_memory_peak_human" => "981.86K",
-      "used_memory_rss" => "1904640"
+      'mem_allocator' => 'libc',
+      'mem_fragmentation_ratio' => '2.04',
+      'used_memory' => '931456',
+      'used_memory_human' => '909.62K',
+      'used_memory_lua' => '31744',
+      'used_memory_peak' => '1005424',
+      'used_memory_peak_human' => '981.86K',
+      'used_memory_rss' => '1904640',
     }
 
     PERSISTENCE_INFO = {
-      "aof_current_rewrite_time_sec" => "-1",
-      "aof_enabled" => "0",
-      "aof_last_bgrewrite_status" => "ok",
-      "aof_last_rewrite_time_sec" => "-1",
-      "aof_rewrite_in_progress" => "0",
-      "aof_rewrite_scheduled" => "0",
-      "loading" => "0",
-      "rdb_bgsave_in_progress" => "0",
-      "rdb_changes_since_last_save" => "0",
-      "rdb_current_bgsave_time_sec" => "-1",
-      "rdb_last_bgsave_status" => "ok",
-      "rdb_last_bgsave_time_sec" => "-1",
-      "rdb_last_save_time" => "1361423635"
+      'aof_current_rewrite_time_sec' => '-1',
+      'aof_enabled' => '0',
+      'aof_last_bgrewrite_status' => 'ok',
+      'aof_last_rewrite_time_sec' => '-1',
+      'aof_rewrite_in_progress' => '0',
+      'aof_rewrite_scheduled' => '0',
+      'loading' => '0',
+      'rdb_bgsave_in_progress' => '0',
+      'rdb_changes_since_last_save' => '0',
+      'rdb_current_bgsave_time_sec' => '-1',
+      'rdb_last_bgsave_status' => 'ok',
+      'rdb_last_bgsave_time_sec' => '-1',
+      'rdb_last_save_time' => '1361423635',
     }
 
     STATS_INFO = {
-      "evicted_keys" => "0",
-      "expired_keys" => "0",
-      "instantaneous_ops_per_sec" => "0",
-      "keyspace_hits" => "62645",
-      "keyspace_misses" => "29757",
-      "latest_fork_usec" => "0",
-      "pubsub_channels" => "0",
-      "pubsub_patterns" => "0",
-      "rejected_connections" => "0",
-      "total_commands_processed" => "196800",
-      "total_connections_received" => "4359"
+      'evicted_keys' => '0',
+      'expired_keys' => '0',
+      'instantaneous_ops_per_sec' => '0',
+      'keyspace_hits' => '62645',
+      'keyspace_misses' => '29757',
+      'latest_fork_usec' => '0',
+      'pubsub_channels' => '0',
+      'pubsub_patterns' => '0',
+      'rejected_connections' => '0',
+      'total_commands_processed' => '196800',
+      'total_connections_received' => '4359',
     }
 
     REPLICATION_INFO = {
-      "role" => "master",
-      "connected_slaves" => "0"
+      'role' => 'master',
+      'connected_slaves' => '0',
     }
 
     CPU_INFO = {
-      "used_cpu_sys" => "5.54",
-      "used_cpu_sys_childrens" => "0.00",
-      "used_cpu_user" => "7.65",
-      "used_cpu_user_childrens" => "0.02"
+      'used_cpu_sys' => '5.54',
+      'used_cpu_sys_childrens' => '0.00',
+      'used_cpu_user' => '7.65',
+      'used_cpu_user_childrens' => '0.02',
     }
 
     KEYSPACE_INFO = {
-      "db0" => "keys=8,expires=0"
+      'db0' => 'keys=8,expires=0',
     }
 
     # The Ruby Reids client returns commandstats differently when it's called as
     # "INFO commandstats".
+    # rubocop:disable Metrics/LineLength
     COMMAND_STATS_SOLO_INFO = {
-      "auth"=>{"calls"=>"572501", "usec"=>"2353163", "usec_per_call"=>"4.11"},
-      "client"=>{"calls"=>"1", "usec"=>"80", "usec_per_call"=>"80.00"},
-      "config"=>{"calls"=>"4", "usec"=>"71", "usec_per_call"=>"17.75"},
-      "flushall"=>{"calls"=>"2097790", "usec"=>"27473940655", "usec_per_call"=>"13096.61"},
-      "flushdb"=>{"calls"=>"692247", "usec"=>"2235143397", "usec_per_call"=>"3228.82"},
-      "get"=>{"calls"=>"185724", "usec"=>"604479", "usec_per_call"=>"3.25"},
-      "info"=>{"calls"=>"965566", "usec"=>"229377331", "usec_per_call"=>"237.56"},
-      "keys"=>{"calls"=>"16591", "usec"=>"917676", "usec_per_call"=>"55.31"},
-      "llen"=>{"calls"=>"39", "usec"=>"150", "usec_per_call"=>"3.85"},
-      "ping"=>{"calls"=>"697509", "usec"=>"3836044", "usec_per_call"=>"5.50"},
-      "rpush"=>{"calls"=>"2239810", "usec"=>"15013298", "usec_per_call"=>"6.70"},
-      "sadd"=>{"calls"=>"13950129156", "usec"=>"30126628979", "usec_per_call"=>"2.16"},
-      "scard"=>{"calls"=>"153929", "usec"=>"726596", "usec_per_call"=>"4.72"},
-      "set"=>{"calls"=>"6975081982", "usec"=>"16453671451", "usec_per_call"=>"2.36"},
-      "slowlog"=>{"calls"=>"136", "usec"=>"16815", "usec_per_call"=>"123.64"},
-      "smembers"=>{"calls"=>"58", "usec"=>"231", "usec_per_call"=>"3.98"},
-      "sunionstore"=>{"calls"=>"4185027", "usec"=>"11762454022", "usec_per_call"=>"2810.60"}
+      'auth' => { 'calls' => '572501', 'usec' => '2353163', 'usec_per_call' => '4.11' },
+      'client' => { 'calls' => '1', 'usec' => '80', 'usec_per_call' => '80.00' },
+      'config' => { 'calls' => '4', 'usec' => '71', 'usec_per_call' => '17.75' },
+      'flushall' => { 'calls' => '2097790', 'usec' => '27473940655', 'usec_per_call' => '13096.61' },
+      'flushdb' => { 'calls' => '692247', 'usec' => '2235143397', 'usec_per_call' => '3228.82' },
+      'get' => { 'calls' => '185724', 'usec' => '604479', 'usec_per_call' => '3.25' },
+      'info' => { 'calls' => '965566', 'usec' => '229377331', 'usec_per_call' => '237.56' },
+      'keys' => { 'calls' => '16591', 'usec' => '917676', 'usec_per_call' => '55.31' },
+      'llen' => { 'calls' => '39', 'usec' => '150', 'usec_per_call' => '3.85' },
+      'ping' => { 'calls' => '697509', 'usec' => '3836044', 'usec_per_call' => '5.50' },
+      'rpush' => { 'calls' => '2239810', 'usec' => '15013298', 'usec_per_call' => '6.70' },
+      'sadd' => { 'calls' => '13950129156', 'usec' => '30126628979', 'usec_per_call' => '2.16' },
+      'scard' => { 'calls' => '153929', 'usec' => '726596', 'usec_per_call' => '4.72' },
+      'set' => { 'calls' => '6975081982', 'usec' => '16453671451', 'usec_per_call' => '2.36' },
+      'slowlog' => { 'calls' => '136', 'usec' => '16815', 'usec_per_call' => '123.64' },
+      'smembers' => { 'calls' => '58', 'usec' => '231', 'usec_per_call' => '3.98' },
+      'sunionstore' => { 'calls' => '4185027', 'usec' => '11762454022', 'usec_per_call' => '2810.60' },
     }
 
     COMMAND_STATS_COMBINED_INFO = {
-      "cmdstat_auth"=>"calls=572506,usec=2353182,usec_per_call=4.11",
-      "cmdstat_client"=>"calls=1,usec=80,usec_per_call=80.00",
-      "cmdstat_config"=>"calls=4,usec=71,usec_per_call=17.75",
-      "cmdstat_flushall"=>"calls=2097790,usec=27473940655,usec_per_call=13096.61",
-      "cmdstat_flushdb"=>"calls=692247,usec=2235143397,usec_per_call=3228.82",
-      "cmdstat_get"=>"calls=185724,usec=604479,usec_per_call=3.25",
-      "cmdstat_info"=>"calls=965571,usec=229378327,usec_per_call=237.56",
-      "cmdstat_keys"=>"calls=16591,usec=917676,usec_per_call=55.31",
-      "cmdstat_llen"=>"calls=39,usec=150,usec_per_call=3.85",
-      "cmdstat_ping"=>"calls=697509,usec=3836044,usec_per_call=5.50",
-      "cmdstat_rpush"=>"calls=2239810,usec=15013298,usec_per_call=6.70",
-      "cmdstat_sadd"=>"calls=13950129156,usec=30126628979,usec_per_call=2.16",
-      "cmdstat_scard"=>"calls=153929,usec=726596,usec_per_call=4.72",
-      "cmdstat_set"=>"calls=6975081982,usec=16453671451,usec_per_call=2.36",
-      "cmdstat_slowlog"=>"calls=136,usec=16815,usec_per_call=123.64",
-      "cmdstat_smembers"=>"calls=58,usec=231,usec_per_call=3.98",
-      "cmdstat_sunionstore"=>"calls=4185027,usec=11762454022,usec_per_call=2810.60"
+      'cmdstat_auth' => 'calls=572506,usec=2353182,usec_per_call=4.11',
+      'cmdstat_client' => 'calls=1,usec=80,usec_per_call=80.00',
+      'cmdstat_config' => 'calls=4,usec=71,usec_per_call=17.75',
+      'cmdstat_flushall' => 'calls=2097790,usec=27473940655,usec_per_call=13096.61',
+      'cmdstat_flushdb' => 'calls=692247,usec=2235143397,usec_per_call=3228.82',
+      'cmdstat_get' => 'calls=185724,usec=604479,usec_per_call=3.25',
+      'cmdstat_info' => 'calls=965571,usec=229378327,usec_per_call=237.56',
+      'cmdstat_keys' => 'calls=16591,usec=917676,usec_per_call=55.31',
+      'cmdstat_llen' => 'calls=39,usec=150,usec_per_call=3.85',
+      'cmdstat_ping' => 'calls=697509,usec=3836044,usec_per_call=5.50',
+      'cmdstat_rpush' => 'calls=2239810,usec=15013298,usec_per_call=6.70',
+      'cmdstat_sadd' => 'calls=13950129156,usec=30126628979,usec_per_call=2.16',
+      'cmdstat_scard' => 'calls=153929,usec=726596,usec_per_call=4.72',
+      'cmdstat_set' => 'calls=6975081982,usec=16453671451,usec_per_call=2.36',
+      'cmdstat_slowlog' => 'calls=136,usec=16815,usec_per_call=123.64',
+      'cmdstat_smembers' => 'calls=58,usec=231,usec_per_call=3.98',
+      'cmdstat_sunionstore' => 'calls=4185027,usec=11762454022,usec_per_call=2810.60',
     }
+    # rubocop:enable Metrics/LineLength
 
     DEFAULT_INFO = [
       SERVER_INFO,
@@ -131,29 +133,28 @@ class MockRedis
       STATS_INFO,
       REPLICATION_INFO,
       CPU_INFO,
-      KEYSPACE_INFO
-    ].inject({}){|memo,info| memo.merge(info)}
+      KEYSPACE_INFO,
+    ].inject({}) { |memo, info| memo.merge(info) }
 
     ALL_INFO = [
       DEFAULT_INFO,
-      COMMAND_STATS_COMBINED_INFO
-    ].inject({}){|memo,info| memo.merge(info)}
+      COMMAND_STATS_COMBINED_INFO,
+    ].inject({}) { |memo, info| memo.merge(info) }
 
-    def info( section = :default )
+    def info(section = :default)
       case section
-        when :default ;      DEFAULT_INFO
-        when :all ;          ALL_INFO
-        when :server ;       SERVER_INFO
-        when :clients ;      CLIENTS_INFO
-        when :memory ;       MEMORY_INFO
-        when :persistence ;  PERSISTENCE_INFO
-        when :stats ;        STATS_INFO
-        when :replication ;  REPLICATION_INFO
-        when :cpu ;          CPU_INFO
-        when :keyspace ;     KEYSPACE_INFO
-        when :commandstats ; COMMAND_STATS_SOLO_INFO
+      when :default;      DEFAULT_INFO
+      when :all;          ALL_INFO
+      when :server;       SERVER_INFO
+      when :clients;      CLIENTS_INFO
+      when :memory;       MEMORY_INFO
+      when :persistence;  PERSISTENCE_INFO
+      when :stats;        STATS_INFO
+      when :replication;  REPLICATION_INFO
+      when :cpu;          CPU_INFO
+      when :keyspace;     KEYSPACE_INFO
+      when :commandstats; COMMAND_STATS_SOLO_INFO
       end
     end
   end
 end
-

data/lib/mock_redis/list_methods.rb

@@ -33,7 +33,7 @@ class MockRedis
     end
 
     def brpoplpush(source, destination, options = {})
-      options = { :timeout => options } if options.kind_of?(Integer)
+      options = { :timeout => options } if options.is_a?(Integer)
       timeout = options.is_a?(Hash) && options[:timeout] || 0
       assert_valid_timeout(timeout)
 
@@ -47,12 +47,12 @@ class MockRedis
     end
 
     def lindex(key, index)
-      with_list_at(key) {|l| l[index.to_i]}
+      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)
@@ -85,7 +85,7 @@ class MockRedis
     def lpush(key, values)
       values = [values] unless values.is_a?(Array)
       assert_has_args(values, 'lpush')
-      with_list_at(key) {|l| values.each {|v| l.unshift(v.to_s)}}
+      with_list_at(key) { |l| values.each { |v| l.unshift(v.to_s) } }
       llen(key)
     end
 
@@ -101,12 +101,12 @@ class MockRedis
 
     def lrange(key, start, stop)
       start = start.to_i
-      with_list_at(key) {|l| start < l.size ? l[[start, -l.length].max..stop.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
@@ -124,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
 
@@ -132,12 +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
 
       index = index.to_i
       unless (0...llen(key)).include?(index)
-        raise Redis::CommandError, "ERR index out of range"
+        raise Redis::CommandError, 'ERR index out of range'
       end
 
       data[key][index] = value.to_s
@@ -152,7 +152,7 @@ class MockRedis
     end
 
     def rpop(key)
-      with_list_at(key) {|list| list.pop if list}
+      with_list_at(key) { |list| list.pop if list }
     end
 
     def rpoplpush(source, destination)
@@ -164,7 +164,7 @@ class MockRedis
     def rpush(key, values)
       values = [values] unless values.is_a?(Array)
       assert_has_args(values, 'rpush')
-      with_list_at(key) {|l| values.each {|v| l.push(v.to_s)}}
+      with_list_at(key) { |l| values.each { |v| l.push(v.to_s) } }
       llen(key)
     end
 
@@ -179,28 +179,29 @@ class MockRedis
     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, "WRONGTYPE 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