mock_redis 0.5.4 → 0.31.0

data/lib/mock_redis/geospatial_methods.rb

@@ -0,0 +1,240 @@
+class MockRedis
+  module GeospatialMethods
+    LNG_RANGE = (-180..180).freeze
+    LAT_RANGE = (-85.05112878..85.05112878).freeze
+    STEP = 26
+    UNITS = {
+      m: 1,
+      km: 1000,
+      ft: 0.3048,
+      mi: 1609.34
+    }.freeze
+    D_R = Math::PI / 180.0
+    EARTH_RADIUS_IN_METERS = 6_372_797.560856
+
+    ruby2_keywords def geoadd(key, *args)
+      points = parse_points(args)
+
+      scored_points = points.map do |point|
+        score = geohash_encode(point[:lng], point[:lat])[:bits]
+        [score.to_s, point[:key]]
+      end
+
+      zadd(key, scored_points)
+    end
+
+    def geodist(key, member1, member2, unit = 'm')
+      to_meter = parse_unit(unit)
+
+      return nil if zcard(key).zero?
+
+      score1 = zscore(key, member1)
+      score2 = zscore(key, member2)
+      return nil if score1.nil? || score2.nil?
+      hash1 = { bits: score1.to_i, step: STEP }
+      hash2 = { bits: score2.to_i, step: STEP }
+
+      lng1, lat1 = geohash_decode(hash1)
+      lng2, lat2 = geohash_decode(hash2)
+
+      distance = geohash_distance(lng1, lat1, lng2, lat2) / to_meter
+      format('%<distance>.4f', distance: distance)
+    end
+
+    def geohash(key, members)
+      lng_range = (-180..180)
+      lat_range = (-90..90)
+      geoalphabet = '0123456789bcdefghjkmnpqrstuvwxyz'
+
+      Array(members).map do |member|
+        score = zscore(key, member)
+        next nil unless score
+        score = score.to_i
+        hash = { bits: score, step: STEP }
+        lng, lat = geohash_decode(hash)
+        bits = geohash_encode(lng, lat, lng_range, lat_range)[:bits]
+        hash = ''
+        11.times do |i|
+          shift = (52 - ((i + 1) * 5))
+          idx = shift > 0 ? (bits >> shift) & 0x1f : 0
+          hash << geoalphabet[idx]
+        end
+        hash
+      end
+    end
+
+    def geopos(key, members)
+      Array(members).map do |member|
+        score = zscore(key, member)
+        next nil unless score
+        hash = { bits: score.to_i, step: STEP }
+        lng, lat = geohash_decode(hash)
+        lng = format_decoded_coord(lng)
+        lat = format_decoded_coord(lat)
+        [lng, lat]
+      end
+    end
+
+    private
+
+    def parse_points(args)
+      points = args.each_slice(3).to_a
+
+      if points.last.size != 3
+        raise Redis::CommandError,
+          "ERR wrong number of arguments for 'geoadd' command"
+      end
+
+      points.map do |point|
+        parse_point(point)
+      end
+    end
+
+    def parse_point(point)
+      lng = Float(point[0])
+      lat = Float(point[1])
+
+      unless LNG_RANGE.include?(lng) && LAT_RANGE.include?(lat)
+        lng = format('%<long>.6f', long: lng)
+        lat = format('%<lat>.6f', lat: lat)
+        raise Redis::CommandError,
+          "ERR invalid longitude,latitude pair #{lng},#{lat}"
+      end
+
+      { key: point[2], lng: lng, lat: lat }
+    rescue ArgumentError
+      raise Redis::CommandError, 'ERR value is not a valid float'
+    end
+
+    # Returns ZSET score for passed coordinates
+    def geohash_encode(lng, lat, lng_range = LNG_RANGE, lat_range = LAT_RANGE, step = STEP)
+      lat_offset = (lat - lat_range.min) / (lat_range.max - lat_range.min)
+      lng_offset = (lng - lng_range.min) / (lng_range.max - lng_range.min)
+
+      lat_offset *= (1 << step)
+      lng_offset *= (1 << step)
+
+      bits = interleave(lat_offset.to_i, lng_offset.to_i)
+
+      { bits: bits, step: step }
+    end
+
+    def interleave(x, y)
+      b = [0x5555555555555555, 0x3333333333333333, 0x0F0F0F0F0F0F0F0F,
+           0x00FF00FF00FF00FF, 0x0000FFFF0000FFFF]
+      s = [1, 2, 4, 8, 16]
+
+      x = (x | (x << s[4])) & b[4]
+      y = (y | (y << s[4])) & b[4]
+
+      x = (x | (x << s[3])) & b[3]
+      y = (y | (y << s[3])) & b[3]
+
+      x = (x | (x << s[2])) & b[2]
+      y = (y | (y << s[2])) & b[2]
+
+      x = (x | (x << s[1])) & b[1]
+      y = (y | (y << s[1])) & b[1]
+
+      x = (x | (x << s[0])) & b[0]
+      y = (y | (y << s[0])) & b[0]
+
+      x | (y << 1)
+    end
+
+    # Decodes ZSET score to coordinates pair
+    def geohash_decode(hash, lng_range = LNG_RANGE, lat_range = LAT_RANGE)
+      area = calculate_approximate_area(hash, lng_range, lat_range)
+
+      lng = (area[:lng_min] + area[:lng_max]) / 2
+      lat = (area[:lat_min] + area[:lat_max]) / 2
+
+      [lng, lat]
+    end
+
+    def calculate_approximate_area(hash, lng_range, lat_range)
+      bits = hash[:bits]
+      step = hash[:step]
+      hash_sep = deinterleave(bits)
+
+      lat_scale = lat_range.max - lat_range.min
+      lng_scale = lng_range.max - lng_range.min
+
+      ilato = hash_sep & 0xFFFFFFFF # cast int64 to int32 to get lat part of deinterleaved hash
+      ilngo = hash_sep >> 32        # shift over to get lng part of hash
+
+      {
+        lat_min: lat_range.min + (ilato * 1.0 / (1 << step)) * lat_scale,
+        lat_max: lat_range.min + ((ilato + 1) * 1.0 / (1 << step)) * lat_scale,
+        lng_min: lng_range.min + (ilngo * 1.0 / (1 << step)) * lng_scale,
+        lng_max: lng_range.min + ((ilngo + 1) * 1.0 / (1 << step)) * lng_scale
+      }
+    end
+
+    def deinterleave(bits)
+      b = [0x5555555555555555, 0x3333333333333333, 0x0F0F0F0F0F0F0F0F,
+           0x00FF00FF00FF00FF, 0x0000FFFF0000FFFF, 0x00000000FFFFFFFF]
+      s = [0, 1, 2, 4, 8, 16]
+
+      x = bits
+      y = bits >> 1
+
+      x = (x | (x >> s[0])) & b[0]
+      y = (y | (y >> s[0])) & b[0]
+
+      x = (x | (x >> s[1])) & b[1]
+      y = (y | (y >> s[1])) & b[1]
+
+      x = (x | (x >> s[2])) & b[2]
+      y = (y | (y >> s[2])) & b[2]
+
+      x = (x | (x >> s[3])) & b[3]
+      y = (y | (y >> s[3])) & b[3]
+
+      x = (x | (x >> s[4])) & b[4]
+      y = (y | (y >> s[4])) & b[4]
+
+      x = (x | (x >> s[5])) & b[5]
+      y = (y | (y >> s[5])) & b[5]
+
+      x | (y << 32)
+    end
+
+    def format_decoded_coord(coord)
+      coord = format('%<coord>.17f', coord: coord)
+      l = 1
+      l += 1 while coord[-l] == '0'
+      coord = coord[0..-l]
+      coord[-1] == '.' ? coord[0..-2] : coord
+    end
+
+    def parse_unit(unit)
+      unit = unit.to_sym
+      return UNITS[unit] if UNITS[unit]
+
+      raise Redis::CommandError,
+        'ERR unsupported unit provided. please use m, km, ft, mi'
+    end
+
+    def geohash_distance(lng1d, lat1d, lng2d, lat2d)
+      lat1r = deg_rad(lat1d)
+      lng1r = deg_rad(lng1d)
+      lat2r = deg_rad(lat2d)
+      lng2r = deg_rad(lng2d)
+
+      u = Math.sin((lat2r - lat1r) / 2)
+      v = Math.sin((lng2r - lng1r) / 2)
+
+      2.0 * EARTH_RADIUS_IN_METERS *
+        Math.asin(Math.sqrt(u * u + Math.cos(lat1r) * Math.cos(lat2r) * v * v))
+    end
+
+    def deg_rad(ang)
+      ang * D_R
+    end
+
+    def rad_deg(ang)
+      ang / D_R
+    end
+  end
+end

data/lib/mock_redis/hash_methods.rb

@@ -6,41 +6,61 @@ class MockRedis
     include Assertions
     include UtilityMethods
 
-    def hdel(key, field)
+    def hdel(key, *fields)
       with_hash_at(key) do |hash|
-        if field.is_a?(Array)
-          orig_size = hash.size
-          hash.delete_if { |k,v| field.include?(k) }
-          orig_size - hash.size
-        else
-          hash.delete(field.to_s) ? 1 : 0
+        orig_size = hash.size
+        fields = Array(fields).flatten.map(&:to_s)
+
+        if fields.empty?
+          raise Redis::CommandError, "ERR wrong number of arguments for 'hdel' command"
         end
+
+        hash.delete_if { |k, _v| fields.include?(k) }
+        orig_size - hash.size
       end
     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
+    end
+
+    def hincrbyfloat(key, field, increment)
+      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 float'
+        end
+
+        unless looks_like_float?(increment.to_s)
+          raise Redis::CommandError, 'ERR value is not a valid float'
+        end
+
+        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
       end
@@ -55,22 +75,36 @@ class MockRedis
     end
 
     def hmget(key, *fields)
+      fields.flatten!
+
       assert_has_args(fields, 'hmget')
-      fields.map{|f| hget(key, f)}
+      fields.map { |f| hget(key, f) }
     end
 
     def mapped_hmget(key, *fields)
       reply = hmget(key, *fields)
-      Hash[*fields.zip(reply).flatten]
+      if reply.is_a?(Array)
+        Hash[fields.zip(reply)]
+      else
+        reply
+      end
     end
 
     def hmset(key, *kvpairs)
+      if key.is_a? Array
+        err_msg = 'ERR wrong number of arguments for \'hmset\' command'
+        kvpairs = key[1..-1]
+        key = key[0]
+      end
+
+      kvpairs.flatten!
       assert_has_args(kvpairs, 'hmset')
+
       if kvpairs.length.odd?
-        raise Redis::CommandError, "ERR wrong number of arguments for HMSET"
+        raise Redis::CommandError, err_msg || 'ERR wrong number of arguments for \'hmset\' command'
       end
 
-      kvpairs.each_slice(2) do |(k,v)|
+      kvpairs.each_slice(2) do |(k, v)|
         hset(key, k, v)
       end
       'OK'
@@ -86,9 +120,34 @@ class MockRedis
       hmset(key, *kvpairs)
     end
 
-    def hset(key, field, value)
-      with_hash_at(key) {|h| h[field.to_s] = value.to_s}
-      true
+    def hscan(key, cursor, opts = {})
+      opts = opts.merge(key: lambda { |x| x[0] })
+      common_scan(hgetall(key).to_a, cursor, opts)
+    end
+
+    def hscan_each(key, opts = {}, &block)
+      return to_enum(:hscan_each, key, opts) unless block_given?
+      cursor = 0
+      loop do
+        cursor, values = hscan(key, cursor, opts)
+        values.each(&block)
+        break if cursor == '0'
+      end
+    end
+
+    def hset(key, *args)
+      added = 0
+      with_hash_at(key) do |hash|
+        if args.length == 1 && args[0].is_a?(Hash)
+          args = args[0].to_a.flatten
+        end
+
+        args.each_slice(2) do |field, value|
+          added += 1 unless hash.key?(field.to_s)
+          hash[field.to_s] = value.to_s
+        end
+      end
+      added
     end
 
     def hsetnx(key, field, value)
@@ -107,18 +166,18 @@ class MockRedis
     private
 
     def with_hash_at(key, &blk)
-      with_thing_at(key, :assert_hashy, proc {{}}, &blk)
+      with_thing_at(key.to_s, :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, "ERR 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
 end

data/lib/mock_redis/indifferent_hash.rb

@@ -0,0 +1,11 @@
+class MockRedis
+  class IndifferentHash < Hash
+    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

@@ -0,0 +1,160 @@
+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',
+    }.freeze
+
+    CLIENTS_INFO = {
+      'blocked_clients' => '0',
+      'client_biggest_input_buf' => '0',
+      'client_longest_output_list' => '0',
+      'connected_clients' => '1',
+    }.freeze
+
+    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',
+    }.freeze
+
+    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',
+    }.freeze
+
+    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',
+    }.freeze
+
+    REPLICATION_INFO = {
+      'role' => 'master',
+      'connected_slaves' => '0',
+    }.freeze
+
+    CPU_INFO = {
+      'used_cpu_sys' => '5.54',
+      'used_cpu_sys_childrens' => '0.00',
+      'used_cpu_user' => '7.65',
+      'used_cpu_user_childrens' => '0.02',
+    }.freeze
+
+    KEYSPACE_INFO = {
+      'db0' => 'keys=8,expires=0',
+    }.freeze
+
+    # The Ruby Redis client returns commandstats differently when it's called as
+    # "INFO commandstats".
+    # rubocop:disable Layout/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' },
+    }.freeze
+
+    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',
+    }.freeze
+    # rubocop:enable Layout/LineLength
+
+    DEFAULT_INFO = [
+      SERVER_INFO,
+      CLIENTS_INFO,
+      MEMORY_INFO,
+      PERSISTENCE_INFO,
+      STATS_INFO,
+      REPLICATION_INFO,
+      CPU_INFO,
+      KEYSPACE_INFO,
+    ].inject({}) { |memo, info| memo.merge(info) }
+
+    ALL_INFO = [
+      DEFAULT_INFO,
+      COMMAND_STATS_COMBINED_INFO,
+    ].inject({}) { |memo, info| memo.merge(info) }
+
+    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
+      end
+    end
+  end
+end