mock_redis 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d45157a6761c4ee6db463b692fc9576ea1635576702423d8482e4a108662a1bc
-  data.tar.gz: 1fd788a1b8d7260c68f964af5cad36d83d360ae86616d4b764c1a655b1df953d
+  metadata.gz: da2c2693b445e51b487e52f7c9b3986960417686792f9a5e554ca4d215c323e2
+  data.tar.gz: 8da2170fcc49e768133a61deb716d72cc18d66291567008d96287b8d2104b15c
 SHA512:
-  metadata.gz: fb6a1a256bca8464aff700e90db426ce3e98b454c9bbdb56f44316dba0b8c10dd66afe7938b3f0fb3b22e61cee3c2f96675fc3f5ce1d2efcae24c09c9bd6ba76
-  data.tar.gz: 6720e42db8d2aafeae70dfeb79ad827b054b10143013510a2f3ac8b209438d70a05aafbf1039aae3f9b85194221cb80461c33700cf0215895ab6989999bcf605
+  metadata.gz: 15b8b59cff1120de0befaee6cf08facfb120e239d3fbc1b6b55f40bb60c526f57e5cbb61f1d9f6fd5538067122e49b80e9e782590cd98070a3d49943ec8bb929
+  data.tar.gz: 52a09f0896a405137be0075db930bec09898dd96e3d5366a95ef6a189268348f91244c051dbe45db5b4b37023a12f87552868fcaf2a5383316bebe9bdaf44997

data/.rubocop.yml

@@ -1,3 +1,14 @@
+inherit_from: .rubocop_todo.yml
+
+AllCops:
+  TargetRubyVersion: 2.2
+
+Layout/AlignParameters:
+  Enabled: false
+
+Layout/DotPosition:
+  Enabled: false
+
 Lint/AssignmentInCondition:
   Enabled: false
 
@@ -30,16 +41,18 @@ Metrics/ModuleLength:
 Metrics/PerceivedComplexity:
   Enabled: false
 
-Style/AlignParameters:
+# This hides the has-a versus is-a relationship indicated by the method name
+Naming/PredicateName:
   Enabled: false
 
 Style/Documentation:
   Enabled: false
 
-Style/DotPosition:
+Style/DoubleNegation:
   Enabled: false
 
-Style/DoubleNegation:
+# We have too much code that relies on modifying strings
+Style/FrozenStringLiteralComment:
   Enabled: false
 
 Style/GuardClause:
@@ -55,7 +68,10 @@ Style/Lambda:
   Enabled: false
 
 # TODO: Address these at some point
-Style/MethodMissing:
+Style/MethodMissingSuper:
+  Enabled: false
+
+Style/MissingRespondToMissing:
   Enabled: false
 
 Style/MultilineBlockChain:
@@ -80,10 +96,6 @@ Style/PercentLiteralDelimiters:
 Style/PerlBackrefs:
   Enabled: false
 
-# This hides the has-a versus is-a relationship indicated by the method name
-Style/PredicateName:
-  Enabled: false
-
 Style/RescueModifier:
   Enabled: false
 
@@ -99,7 +111,10 @@ Style/SymbolArray:
 Style/TrailingCommaInArguments:
   Enabled: false
 
-Style/TrailingCommaInLiteral:
+Style/TrailingCommaInArrayLiteral:
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral:
   Enabled: false
 
 Style/WhenThen:

data/.rubocop_todo.yml

@@ -0,0 +1,35 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2018-08-03 11:15:53 -0700 using RuboCop version 0.58.2.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 17
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: io, id, to, by, on, in, at, ip
+Naming/UncommunicativeMethodParamName:
+  Exclude:
+    - 'lib/mock_redis/database.rb'
+    - 'lib/mock_redis/expire_wrapper.rb'
+    - 'lib/mock_redis/geospatial_methods.rb'
+    - 'lib/mock_redis/multi_db_wrapper.rb'
+    - 'lib/mock_redis/pipelined_wrapper.rb'
+    - 'lib/mock_redis/string_methods.rb'
+    - 'lib/mock_redis/transaction_wrapper.rb'
+    - 'lib/mock_redis/utility_methods.rb'
+    - 'lib/mock_redis/zset_methods.rb'
+    - 'spec/support/redis_multiplexer.rb'
+
+# Offense count: 2
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: inline, group
+Style/AccessModifierDeclarations:
+  Exclude:
+    - 'lib/mock_redis/zset_methods.rb'
+
+# Offense count: 1
+Style/DateTime:
+  Exclude:
+    - 'spec/commands/zremrangebyscore_spec.rb'

data/.travis.yml

@@ -13,10 +13,10 @@ services:
   - redis-server
 
 rvm:
-  - 2.0
-  - 2.1
   - 2.2
-  - 2.3.1
+  - 2.3.7
+  - 2.4.4
+  - 2.5.1
 
 before_script:
   - git config --local user.email "travis@travis.ci"

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # MockRedis Changelog
 
+### 0.19.0
+
+* Require Ruby 2.2+
+* Add support for `bitfield` command
+* Add support for `geoadd`, `geopos`, `geohash`, and `geodist` commands
+* Fix multi-nested pipeline not releasing lock issue
+
 ### 0.18.0
 
 * Fix `hset` return value to return false when the field exists in the hash

data/Gemfile

@@ -4,9 +4,9 @@ source 'http://rubygems.org'
 gemspec
 
 # Run all pre-commit hooks via Overcommit during CI runs
-gem 'overcommit', '0.39.0'
+gem 'overcommit', '0.45.0'
 
 # Pin tool versions (which are executed by Overcommit) for Travis builds
-gem 'rubocop', '0.48.1'
+gem 'rubocop', '0.58.2'
 
 gem 'coveralls', require: false

data/README.md

@@ -3,7 +3,6 @@
 [![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)
-[![Dependency Status](https://gemnasium.com/brigade/mock_redis.svg)](https://gemnasium.com/brigade/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
@@ -93,8 +92,8 @@ please submit a pull request with your (tested!) implementation.
 
 ## Compatibility
 
-As of version `0.8.2`, Ruby 2.0.0 and above are supported. For
-older versions of Ruby, use `0.8.1` or older.
+As of version `0.19.0`, Ruby 2.2 and above are supported. For
+older versions of Ruby, use `0.18.0` or older.
 
 ## Running the Tests
 

data/lib/mock_redis/database.rb

@@ -9,6 +9,7 @@ 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'
 
 class MockRedis
   class Database
@@ -20,6 +21,7 @@ class MockRedis
     include SortMethod
     include InfoMethod
     include UtilityMethods
+    include GeospatialMethods
 
     attr_reader :data, :expire_times
 

data/lib/mock_redis/future.rb

@@ -2,10 +2,11 @@ class MockRedis
   class FutureNotReady < RuntimeError; end
 
   class Future
-    attr_reader :command
+    attr_reader :command, :block
 
-    def initialize(command)
+    def initialize(command, block = nil)
       @command = command
+      @block = block
       @result_set = false
     end
 

data/lib/mock_redis/geospatial_methods.rb

@@ -0,0 +1,248 @@
+class MockRedis
+  module GeospatialMethods
+    LNG_RANGE = (-180..180)
+    LAT_RANGE = (-85.05112878..85.05112878)
+    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
+
+    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, *args)
+      if args.length < 2
+        raise Redis::CommandError,
+          "ERR wrong number of arguments for 'geodist' command"
+      end
+
+      raise Redis::CommandError, 'ERR syntax error' if args.length > 3
+
+      to_meter = 1
+      to_meter = parse_unit(args[2]) if args.length == 3
+
+      return nil if zcard(key).zero?
+
+      score1 = zscore(key, args[0])
+      score2 = zscore(key, args[1])
+      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('%.4f', distance)
+    end
+
+    def geohash(key, *members)
+      lng_range = (-180..180)
+      lat_range = (-90..90)
+      geoalphabet = '0123456789bcdefghjkmnpqrstuvwxyz'
+
+      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)
+      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('%.6f', lng)
+        lat = format('%.6f', 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('%.17f', 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/pipelined_wrapper.rb

@@ -20,7 +20,7 @@ class MockRedis
 
     def method_missing(method, *args, &block)
       if @in_pipeline
-        future = MockRedis::Future.new([method, *args])
+        future = MockRedis::Future.new([method, *args], block)
         @pipelined_futures << future
         future
       else
@@ -32,12 +32,16 @@ class MockRedis
       @in_pipeline = true
       yield self
       @in_pipeline = false
-      responses = @pipelined_futures.map do |future|
+      responses = @pipelined_futures.flat_map do |future|
         begin
-          result = send(*future.command)
+          result = if future.block
+                     send(*future.command, &future.block)
+                   else
+                     send(*future.command)
+                   end
           future.store_result(result)
           result
-        rescue => e
+        rescue StandardError => e
           e
         end
       end

data/lib/mock_redis/string_methods.rb

@@ -3,6 +3,7 @@ require 'mock_redis/assertions'
 class MockRedis
   module StringMethods
     include Assertions
+    include UtilityMethods
 
     def append(key, value)
       assert_stringy(key)
@@ -11,6 +12,70 @@ class MockRedis
       data[key].length
     end
 
+    def bitfield(*args)
+      if args.length < 4
+        raise Redis::CommandError, 'ERR wrong number of arguments for BITFIELD'
+      end
+
+      key = args.shift
+      output = []
+      overflow_method = 'wrap'
+
+      until args.empty?
+        command = args.shift.to_s
+
+        if command == 'overflow'
+          new_overflow_method = args.shift.to_s.downcase
+
+          unless %w[wrap sat fail].include? new_overflow_method
+            raise Redis::CommandError, 'ERR Invalid OVERFLOW type specified'
+          end
+
+          overflow_method = new_overflow_method
+          next
+        end
+
+        type, offset = args.shift(2)
+
+        is_signed = type.slice(0) == 'i'
+        type_size = type[1..-1].to_i
+
+        if (type_size > 64 && is_signed) || (type_size >= 64 && !is_signed)
+          raise Redis::CommandError,
+            'ERR Invalid bitfield type. Use something like i16 u8. ' \
+            'Note that u64 is not supported but i64 is.'
+        end
+
+        if offset.to_s[0] == '#'
+          offset = offset[1..-1].to_i * type_size
+        end
+
+        bits = []
+
+        type_size.times do |i|
+          bits.push(getbit(key, offset + i))
+        end
+
+        val = is_signed ? twos_complement_decode(bits) : bits.join('').to_i(2)
+
+        case command
+        when 'get'
+          output.push(val)
+        when 'set'
+          output.push(val)
+
+          set_bitfield(key, args.shift.to_i, is_signed, type_size, offset)
+        when 'incrby'
+          new_val = incr_bitfield(val, args.shift.to_i, is_signed, type_size, overflow_method)
+
+          set_bitfield(key, new_val, is_signed, type_size, offset) if new_val
+          output.push(new_val)
+        end
+      end
+
+      output
+    end
+
     def decr(key)
       decrby(key, 1)
     end
@@ -285,5 +350,49 @@ class MockRedis
         raise Redis::CommandError, message
       end
     end
+
+    def set_bitfield(key, value, is_signed, type_size, offset)
+      if is_signed
+        val_array = twos_complement_encode(value, type_size)
+      else
+        str = left_pad(value.to_i.abs.to_s(2), type_size)
+        val_array = str.split('').map(&:to_i)
+      end
+
+      val_array.each_with_index do |bit, i|
+        setbit(key, offset + i, bit)
+      end
+    end
+
+    def incr_bitfield(val, incrby, is_signed, type_size, overflow_method)
+      new_val = val + incrby
+
+      max = is_signed ? (2**(type_size - 1)) - 1 : (2**type_size) - 1
+      min = is_signed ? (-2**(type_size - 1)) : 0
+      size = 2**type_size
+
+      return new_val if (min..max).cover?(new_val)
+
+      case overflow_method
+      when 'fail'
+        new_val = nil
+      when 'sat'
+        new_val = new_val > max ? max : min
+      when 'wrap'
+        if is_signed
+          if new_val > max
+            remainder = new_val - (max + 1)
+            new_val = min + remainder.abs
+          else
+            remainder = new_val - (min - 1)
+            new_val = max - remainder.abs
+          end
+        else
+          new_val = new_val > max ? new_val % size : size - new_val.abs
+        end
+      end
+
+      new_val
+    end
   end
 end

data/lib/mock_redis/transaction_wrapper.rb

@@ -59,7 +59,7 @@ class MockRedis
           result = send(*future.command)
           future.store_result(result)
           result
-        rescue => e
+        rescue StandardError => e
           e
         end
       end

data/lib/mock_redis/utility_methods.rb

@@ -38,5 +38,36 @@ class MockRedis
 
       [next_cursor, filtered_values]
     end
+
+    def twos_complement_encode(n, size)
+      if n < 0
+        str = (n + 1).abs.to_s(2)
+
+        binary = left_pad(str, size - 1).chars.map { |c| c == '0' ? 1 : 0 }
+        binary.unshift(1)
+      else
+        binary = left_pad(n.abs.to_s(2), size - 1).chars.map(&:to_i)
+        binary.unshift(0)
+      end
+
+      binary
+    end
+
+    def twos_complement_decode(array)
+      total = 0
+
+      array.each.with_index do |bit, index|
+        total += 2**(array.length - index - 1) if bit == 1
+        total = -total if index == 0
+      end
+
+      total
+    end
+
+    def left_pad(str, size)
+      str = '0' + str while str.length < size
+
+      str
+    end
   end
 end

data/lib/mock_redis/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 class MockRedis
-  VERSION = '0.18.0'.freeze
+  VERSION = '0.19.0'.freeze
 end

data/mock_redis.gemspec

@@ -1,4 +1,4 @@
-$LOAD_PATH << File.expand_path('../lib', __FILE__)
+$LOAD_PATH << File.expand_path('lib', __dir__)
 require 'mock_redis/version'
 
 Gem::Specification.new do |s|
@@ -11,16 +11,18 @@ Gem::Specification.new do |s|
   s.homepage    = 'https://github.com/brigade/mock_redis'
   s.summary     = 'Redis mock that just lives in memory; useful for testing.'
 
-  s.description = <<-EOS.strip.gsub(/\s+/, ' ')
+  s.description = <<-MSG.strip.gsub(/\s+/, ' ')
    Instantiate one with `redis = MockRedis.new` and treat it like you would a
    normal Redis object. It supports all the usual Redis operations.
-  EOS
+  MSG
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ['lib']
 
+  s.required_ruby_version = '>= 2.2'
+
   s.add_development_dependency 'rake', '>= 10', '< 12'
   s.add_development_dependency 'redis', '~> 3.3.0'
   s.add_development_dependency 'rspec', '~> 3.0'

data/spec/commands/bitfield_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe '#bitfield(*args)' do
+  before :each do
+    @key = 'mock-redis-test:bitfield'
+    @redises.set(@key, '')
+
+    @redises.bitfield(@key, :set, 'i8', 0, 78)
+    @redises.bitfield(@key, :set, 'i8', 8, 104)
+    @redises.bitfield(@key, :set, 'i8', 16, -59)
+    @redises.bitfield(@key, :set, 'u8', 24, 78)
+    @redises.bitfield(@key, :set, 'u8', 32, 84)
+  end
+
+  context 'with a :get command' do
+    it 'gets a signed 8 bit value' do
+      @redises.bitfield(@key, :get, 'i8', 0).should == [78]
+      @redises.bitfield(@key, :get, 'i8', 8).should == [104]
+      @redises.bitfield(@key, :get, 'i8', 16).should == [-59]
+    end
+
+    it 'gets multiple values with multiple command args' do
+      @redises.bitfield(@key, :get, 'i8', 0,
+                              :get, 'i8', 8,
+                              :get, 'i8', 16).should == [78, 104, -59]
+    end
+
+    it 'gets multiple values using positional offsets' do
+      @redises.bitfield(@key, :get, 'i8', '#0',
+                              :get, 'i8', '#1',
+                              :get, 'i8', '#2').should == [78, 104, -59]
+    end
+
+    it 'shows an error with an invalid type' do
+      expect do
+        @redises.bitfield(@key, :get, 'u64', 0)
+      end.to raise_error(Redis::CommandError)
+      expect do
+        @redises.bitfield(@key, :get, 'i128', 0)
+      end.to raise_error(Redis::CommandError)
+    end
+
+    it 'does not throw an error with i64 type' do
+      expect do
+        @redises.bitfield(@key, :get, 'i64', 0)
+      end.to_not raise_error
+    end
+  end
+
+  context 'with a :set command' do
+    it 'sets the bit values for an 8 bit signed integer' do
+      @redises.bitfield(@key, :set, 'i8', 0, 63).should == [78]
+      @redises.bitfield(@key, :set, 'i8', 8, -1).should == [104]
+      @redises.bitfield(@key, :set, 'i8', 16, 123).should == [-59]
+
+      @redises.bitfield(@key, :get, 'i8', 0,
+                              :get, 'i8', 8,
+                              :get, 'i8', 16).should == [63, -1, 123]
+    end
+
+    it 'sets multiple values with multiple command args' do
+      @redises.bitfield(@key, :set, 'i8', 0, 63,
+                              :set, 'i8', 8, -1,
+                              :set, 'i8', 16, 123).should == [78, 104, -59]
+
+      @redises.bitfield(@key, :get, 'i8', 0,
+                              :get, 'i8', 8,
+                              :get, 'i8', 16).should == [63, -1, 123]
+    end
+  end
+
+  context 'with an :incrby command' do
+    it 'returns the incremented by value for an 8 bit signed integer' do
+      @redises.bitfield(@key, :incrby, 'i8', 0, 1).should == [79]
+      @redises.bitfield(@key, :incrby, 'i8', 8, -1).should == [103]
+      @redises.bitfield(@key, :incrby, 'i8', 16, 5).should == [-54]
+    end
+
+    context 'with an overflow of wrap (default)' do
+      context 'for a signed integer' do
+        it 'wraps the overflow to the minimum and increments from there' do
+          @redises.bitfield(@key, :get, 'i8', 24).should == [78]
+          @redises.bitfield(@key, :overflow, :wrap,
+                                  :incrby, 'i8', 0, 200).should == [22]
+        end
+
+        it 'wraps the underflow to the maximum value and decrements from there' do
+          @redises.bitfield(@key, :overflow, :wrap,
+                                  :incrby, 'i8', 16, -200).should == [-3]
+        end
+      end
+
+      context 'for an unsigned integer' do
+        it 'wraps the overflow back to zero and increments from there' do
+          @redises.bitfield(@key, :get, 'u8', 24).should == [78]
+          @redises.bitfield(@key, :overflow, :wrap,
+                                  :incrby, 'u8', 24, 233).should == [55]
+        end
+
+        it 'wraps the underflow to the maximum value and decrements from there' do
+          @redises.bitfield(@key, :get, 'u8', 32).should == [84]
+          @redises.bitfield(@key, :overflow, :wrap,
+                                  :incrby, 'u8', 32, -233).should == [107]
+        end
+      end
+    end
+
+    context 'with an overflow of sat' do
+      it 'sets the overflowed value to the maximum' do
+        @redises.bitfield(@key, :overflow, :sat,
+                                :incrby, 'i8', 0, 256).should == [127]
+      end
+
+      it 'sets the underflowed value to the minimum' do
+        @redises.bitfield(@key, :overflow, :sat,
+                                :incrby, 'i8', 16, -256).should == [-128]
+      end
+    end
+
+    context 'with an overflow of fail' do
+      it 'raises a redis error on an out of range value' do
+        @redises.bitfield(@key, :overflow, :fail,
+                                :incrby, 'i8', 0, 256).should == [nil]
+
+        @redises.bitfield(@key, :overflow, :fail,
+                                :incrby, 'i8', 16, -256).should == [nil]
+      end
+
+      it 'retains the original value after a failed increment' do
+        @redises.bitfield(@key, :get, 'i8', 0).should == [78]
+        @redises.bitfield(@key, :overflow, :fail,
+                                :incrby, 'i8', 0, 256).should == [nil]
+        @redises.bitfield(@key, :get, 'i8', 0).should == [78]
+      end
+    end
+
+    context 'with multiple overflow commands in one transaction' do
+      it 'handles the overflow values correctly' do
+        @redises.bitfield(@key, :overflow, :sat,
+                                :incrby, 'i8', 0, 256,
+                                :incrby, 'i8', 8, -256,
+                                :overflow, :wrap,
+                                :incrby, 'i8', 0, 200,
+                                :incrby, 'i8', 16, -200,
+                                :overflow, :fail,
+                                :incrby, 'i8', 0, 256,
+                                :incrby, 'i8', 16, -256).should == [127, -128, 71, -3, nil, nil]
+      end
+    end
+
+    context 'with an unsupported overflow value' do
+      it 'raises an error' do
+        expect do
+          @redises.bitfield(@key, :overflow, :foo,
+                                  :incrby, 'i8', 0, 256)
+        end.to raise_error(Redis::CommandError)
+      end
+    end
+  end
+
+  context 'with a mixed set of commands' do
+    it 'returns the correct outputs' do
+      @redises.bitfield(@key, :set, 'i8', 0, 38,
+                              :set, 'i8', 8, -99,
+                              :incrby, 'i8', 16, 1,
+                              :get, 'i8', 0).should == [78, 104, -58, 38]
+    end
+  end
+end

data/spec/commands/geoadd_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe '#geoadd' do
+  let(:key) { 'cities' }
+
+  context 'with valid points' do
+    let(:san_francisco) { [-122.5076404, 37.757815, 'SF'] }
+    let(:los_angeles) { [-118.6919259, 34.0207305, 'LA'] }
+    let(:expected_result) do
+      [['LA', 1.364461589564902e+15], ['SF', 1.367859319053696e+15]]
+    end
+
+    before { @redises.geoadd(key, *san_francisco, *los_angeles) }
+
+    after { @redises.zrem(key, %w[SF LA]) }
+
+    it 'adds members to ZSET' do
+      cities = @redises.zrange(key, 0, -1, with_scores: true)
+      expect(cities).to be == expected_result
+    end
+  end
+
+  context 'with invalud points' do
+    context 'when number of arguments wrong' do
+      let(:message) { "ERR wrong number of arguments for 'geoadd' command" }
+
+      it 'raises Redis::CommandError' do
+        expect { @redises.geoadd(key, 1, 1) }
+          .to raise_error(Redis::CommandError, message)
+      end
+    end
+
+    context 'when coordinates are not in allowed range' do
+      let(:coords) { [181, 86] }
+      let(:message) do
+        formatted_coords = coords.map { |c| format('%.6f', c) }
+        "ERR invalid longitude,latitude pair #{formatted_coords.join(',')}"
+      end
+
+      after { @redises.zrem(key, 'SF') }
+
+      it 'raises Redis::CommandError' do
+        expect { @redises.geoadd(key, *coords, 'SF') }
+          .to raise_error(Redis::CommandError, message)
+      end
+    end
+
+    context 'when coordinates are not valid floats' do
+      let(:coords) { ['x', 35] }
+      let(:message) { 'ERR value is not a valid float' }
+
+      it 'raises Redis::CommandError' do
+        expect { @redises.geoadd key, *coords, 'SF' }
+          .to raise_error(Redis::CommandError, message)
+      end
+    end
+  end
+end

data/spec/commands/geodist_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+shared_examples 'a distance calculator' do
+  it 'returns distance between two points in specified unit' do
+    dist = @redises.geodist(key, 'SF', 'LA', unit)
+    expect(dist).to be == expected_result
+  end
+end
+
+describe '#geodist' do
+  let(:key) { 'cities' }
+
+  context 'with existing key' do
+    let(:san_francisco) { [-122.5076404, 37.757815, 'SF'] }
+    let(:los_angeles) { [-118.6919259, 34.0207305, 'LA'] }
+
+    before { @redises.geoadd(key, *san_francisco, *los_angeles) }
+
+    after { @redises.zrem(key, %w[SF LA]) }
+
+    context 'with existing points only' do
+      context 'using m as unit' do
+        let(:unit) { 'm' }
+        let(:expected_result) { '539327.9659' }
+
+        it 'returns distance between two points in meters' do
+          dist = @redises.geodist(key, 'SF', 'LA')
+          expect(dist).to be == expected_result
+        end
+
+        it_behaves_like 'a distance calculator'
+      end
+
+      context 'using km as unit' do
+        let(:unit) { 'km' }
+        let(:expected_result) { '539.3280' }
+
+        it_behaves_like 'a distance calculator'
+      end
+
+      context 'using ft as unit' do
+        let(:unit) { 'ft' }
+        let(:expected_result) { '1769448.7069' }
+
+        it_behaves_like 'a distance calculator'
+      end
+
+      context 'using mi as unit' do
+        let(:unit) { 'mi' }
+        let(:expected_result) { '335.1237' }
+
+        it_behaves_like 'a distance calculator'
+      end
+
+      context 'with non-existing points only' do
+        it 'returns nil' do
+          dist = @redises.geodist(key, 'FF', 'FA')
+          expect(dist).to be_nil
+        end
+      end
+
+      context 'with both existing and non-existing points' do
+        it 'returns nil' do
+          dist = @redises.geodist(key, 'SF', 'FA')
+          expect(dist).to be_nil
+        end
+      end
+    end
+  end
+
+  context 'with non-existing key' do
+    it 'returns empty string' do
+      dist = @redises.geodist(key, 'SF', 'LA')
+      expect(dist).to be_nil
+    end
+  end
+
+  context 'with wrong number of arguments' do
+    let(:list) { [key, 'SF', 'LA', 'm', 'smth'] }
+
+    context 'with less than 3 arguments' do
+      [1, 2].each do |count|
+        let(:message) { "ERR wrong number of arguments for 'geodist' command" }
+
+        context "with #{count} arguments" do
+          it 'raises an error' do
+            args = list.slice(0, count)
+            expect { @redises.geodist(*args) }
+              .to raise_error(Redis::CommandError, message)
+          end
+        end
+      end
+    end
+
+    context 'with more than 3 arguments' do
+      let(:message) { 'ERR syntax error' }
+
+      it 'raises an error' do
+        args = list.slice(0, 5)
+        expect { @redises.geodist(*args) }
+          .to raise_error(Redis::CommandError, message)
+      end
+    end
+  end
+
+  context 'with wrong unit' do
+    let(:message) { 'ERR unsupported unit provided. please use m, km, ft, mi' }
+
+    it 'raises an error' do
+      expect { @redises.geodist(key, 'SF', 'LA', 'a') }
+        .to raise_error(Redis::CommandError, message)
+    end
+  end
+end

data/spec/commands/geohash_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe '#geohash' do
+  let(:key) { 'cities' }
+
+  context 'with existing key' do
+    let(:san_francisco) { [-122.5076404, 37.757815, 'SF'] }
+    let(:los_angeles) { [-118.6919259, 34.0207305, 'LA'] }
+
+    before { @redises.geoadd(key, *san_francisco, *los_angeles) }
+
+    after { @redises.zrem(key, %w[SF LA]) }
+
+    context 'with existing points only' do
+      let(:expected_result) do
+        %w[9q8yu38ejp0 9q59e171je0]
+      end
+
+      it 'returns decoded coordinates pairs for each point' do
+        results = @redises.geohash(key, 'SF', 'LA')
+        expect(results).to be == expected_result
+      end
+
+      context 'with non-existing points only' do
+        it 'returns array filled with nils' do
+          results = @redises.geohash(key, 'FF', 'FA')
+          expect(results).to be == [nil, nil]
+        end
+      end
+
+      context 'with both existing and non-existing points' do
+        let(:expected_result) do
+          ['9q8yu38ejp0', nil]
+        end
+
+        it 'returns mixture of nil and coordinates pair' do
+          results = @redises.geohash(key, 'SF', 'FA')
+          expect(results).to be == expected_result
+        end
+      end
+    end
+  end
+
+  context 'with non-existing key' do
+    before { @redises.del(key) }
+
+    it 'returns empty array' do
+      results = @redises.geohash(key, 'SF', 'LA')
+      expect(results).to be == [nil, nil]
+    end
+  end
+end

data/spec/commands/geopos_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe '#geopos' do
+  let(:key) { 'cities' }
+
+  context 'with existing key' do
+    let(:san_francisco) { [-122.5076404, 37.757815, 'SF'] }
+    let(:los_angeles) { [-118.6919259, 34.0207305, 'LA'] }
+
+    before { @redises.geoadd(key, *san_francisco, *los_angeles) }
+
+    after { @redises.zrem(key, %w[SF LA]) }
+
+    context 'with existing points only' do
+      let(:expected_result) do
+        [
+          %w[-122.5076410174369812 37.75781598995183685],
+          %w[-118.69192510843276978 34.020729570911179]
+        ]
+      end
+
+      it 'returns decoded coordinates pairs for each point' do
+        coords = @redises.geopos(key, 'SF', 'LA')
+        expect(coords).to be == expected_result
+      end
+
+      context 'with non-existing points only' do
+        it 'returns array filled with nils' do
+          coords = @redises.geopos(key, 'FF', 'FA')
+          expect(coords).to be == [nil, nil]
+        end
+      end
+
+      context 'with both existing and non-existing points' do
+        let(:expected_result) do
+          [%w[-122.5076410174369812 37.75781598995183685], nil]
+        end
+
+        it 'returns mixture of nil and coordinates pair' do
+          coords = @redises.geopos(key, 'SF', 'FA')
+          expect(coords).to be == expected_result
+        end
+      end
+    end
+  end
+
+  context 'with non-existing key' do
+    before { @redises.del(key) }
+
+    it 'returns empty array' do
+      coords = @redises.geopos(key, 'SF', 'LA')
+      expect(coords).to be == [nil, nil]
+    end
+  end
+end

data/spec/commands/setbit_spec.rb

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 require 'spec_helper'
 
 describe '#setbit(key, offset)' do

data/spec/commands/strlen_spec.rb

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 require 'spec_helper'
 
 describe '#strlen(key)' do

data/spec/transactions_spec.rb

@@ -67,6 +67,18 @@ describe 'transactions (multi/exec/discard)' do
       @redises.get('counter').should == '6'
       @redises.get('test').should == '1'
     end
+
+    it 'allows multi blocks within pipelined blocks' do
+      @redises.set('counter', 5)
+      @redises.pipelined do |pr|
+        pr.multi do |r|
+          r.set('test', 1)
+          r.incr('counter')
+        end
+      end
+      @redises.get('counter').should == '6'
+      @redises.get('test').should == '1'
+    end
   end
 
   context '#discard' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mock_redis
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Brigade Engineering
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-22 00:00:00.000000000 Z
+date: 2018-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -86,6 +86,7 @@ files:
 - ".overcommit.yml"
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
 - ".simplecov"
 - ".travis.yml"
 - CHANGELOG.md
@@ -99,6 +100,7 @@ files:
 - lib/mock_redis/exceptions.rb
 - lib/mock_redis/expire_wrapper.rb
 - lib/mock_redis/future.rb
+- lib/mock_redis/geospatial_methods.rb
 - lib/mock_redis/hash_methods.rb
 - lib/mock_redis/indifferent_hash.rb
 - lib/mock_redis/info_method.rb
@@ -122,6 +124,7 @@ files:
 - spec/commands/bgrewriteaof_spec.rb
 - spec/commands/bgsave_spec.rb
 - spec/commands/bitcount_spec.rb
+- spec/commands/bitfield_spec.rb
 - spec/commands/blpop_spec.rb
 - spec/commands/brpop_spec.rb
 - spec/commands/brpoplpush_spec.rb
@@ -140,6 +143,10 @@ files:
 - spec/commands/flushall_spec.rb
 - spec/commands/flushdb_spec.rb
 - spec/commands/future_spec.rb
+- spec/commands/geoadd_spec.rb
+- spec/commands/geodist_spec.rb
+- spec/commands/geohash_spec.rb
+- spec/commands/geopos_spec.rb
 - spec/commands/get_spec.rb
 - spec/commands/getbit_spec.rb
 - spec/commands/getrange_spec.rb
@@ -273,7 +280,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -293,6 +300,7 @@ test_files:
 - spec/commands/bgrewriteaof_spec.rb
 - spec/commands/bgsave_spec.rb
 - spec/commands/bitcount_spec.rb
+- spec/commands/bitfield_spec.rb
 - spec/commands/blpop_spec.rb
 - spec/commands/brpop_spec.rb
 - spec/commands/brpoplpush_spec.rb
@@ -311,6 +319,10 @@ test_files:
 - spec/commands/flushall_spec.rb
 - spec/commands/flushdb_spec.rb
 - spec/commands/future_spec.rb
+- spec/commands/geoadd_spec.rb
+- spec/commands/geodist_spec.rb
+- spec/commands/geohash_spec.rb
+- spec/commands/geopos_spec.rb
 - spec/commands/get_spec.rb
 - spec/commands/getbit_spec.rb
 - spec/commands/getrange_spec.rb