fakeredis 0.5.0 → 0.8.0

data/lib/fakeredis/geo_set.rb

@@ -0,0 +1,84 @@
+module FakeRedis
+  class GeoSet
+    class Point
+      BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz" # (geohash-specific) Base32 map
+      EARTH_RADIUS_IN_M = 6_378_100.0
+
+      attr_reader :lon, :lat, :name
+
+      def initialize(lon, lat, name)
+        @lon = Float(lon)
+        @lat = Float(lat)
+        @name = name
+      end
+
+      def geohash(precision = 10)
+        latlon = [@lat, @lon]
+        ranges = [[-90.0, 90.0], [-180.0, 180.0]]
+        coordinate = 1
+
+        (0...precision).map do
+          index = 0 # index into base32 map
+
+          5.times do |bit|
+            mid = (ranges[coordinate][0] + ranges[coordinate][1]) / 2
+            if latlon[coordinate] >= mid
+              index = index * 2 + 1
+              ranges[coordinate][0] = mid
+            else
+              index *= 2
+              ranges[coordinate][1] = mid
+            end
+
+            coordinate ^= 1
+          end
+
+          BASE32[index]
+        end.join
+      end
+
+      def distance_to(other)
+        lat1 = deg_to_rad(@lat)
+        lon1 = deg_to_rad(@lon)
+        lat2 = deg_to_rad(other.lat)
+        lon2 = deg_to_rad(other.lon)
+        haversine_distance(lat1, lon1, lat2, lon2)
+      end
+
+      private
+
+      def deg_to_rad(deg)
+        deg * Math::PI / 180.0
+      end
+
+      def haversine_distance(lat1, lon1, lat2, lon2)
+        h = Math.sin((lat2 - lat1) / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) *
+              Math.sin((lon2 - lon1) / 2) ** 2
+
+        2 * EARTH_RADIUS_IN_M * Math.asin(Math.sqrt(h))
+      end
+    end
+
+    def initialize
+      @points = {}
+    end
+
+    def size
+      @points.size
+    end
+
+    def add(lon, lat, name)
+      @points[name] = Point.new(lon, lat, name)
+    end
+
+    def get(name)
+      @points[name]
+    end
+
+    def points_within_radius(center, radius)
+      @points.values.select do |point|
+        point.distance_to(center) <= radius
+      end
+    end
+  end
+end

data/lib/fakeredis/minitest.rb

@@ -0,0 +1,24 @@
+# Require this either in your Gemfile or in your minitest configuration.
+# Examples:
+#
+#   # Gemfile
+#   group :test do
+#     gem 'minitest'
+#     gem 'fakeredis', :require => 'fakeredis/minitest'
+#   end
+#
+#   # test/test_helper.rb (or test/minitest_config.rb)
+#   require 'fakeredis/minitest'
+
+require 'fakeredis'
+
+module FakeRedis
+  module Minitest
+    def setup
+      Redis::Connection::Memory.reset_all_databases
+      super
+    end
+
+    ::Minitest::Test.send(:include, self)
+  end
+end

data/lib/fakeredis/rspec.rb

@@ -18,6 +18,7 @@ RSpec.configure do |c|
 
   c.before do    
     Redis::Connection::Memory.reset_all_databases
+    Redis::Connection::Memory.reset_all_channels
   end
 
 end

data/lib/fakeredis/sort_method.rb

@@ -3,9 +3,9 @@ module FakeRedis
   module SortMethod
     def sort(key, *redis_options_array)
       return [] unless key
+      return [] if type(key) == 'none'
 
       unless %w(list set zset).include? type(key)
-        warn "Operation against a key holding the wrong kind of value: Expected list, set or zset at #{key}."
         raise Redis::CommandError.new("WRONGTYPE Operation against a key holding the wrong kind of value")
       end
 
@@ -21,7 +21,7 @@ module FakeRedis
       # We have to flatten it down as redis-rb adds back the array to the return value
       result = sliced.flatten(1)
 
-      options[:store] ? rpush(options[:store], sliced) : sliced.flatten(1)
+      options[:store] ? rpush(options[:store], sliced) : result
     end
 
     private
@@ -100,7 +100,7 @@ module FakeRedis
       skip = limit.first || 0
       take = limit.last || sorted.length
 
-      sorted[skip...(skip + take)] || sorted
+      sorted[skip...(skip + take)] || []
     end
 
     def lookup_from_pattern(pattern, element)

data/lib/fakeredis/sorted_set_store.rb

@@ -68,7 +68,7 @@ module FakeRedis
 
   class SortedSetIntersectStore < SortedSetStore
     def selected_keys
-      @values ||= hashes.inject([]) { |r, h| r.empty? ? h.keys : (r & h.keys) }
+      @values ||= hashes.map(&:keys).reduce(:&)
     end
   end
 

data/lib/fakeredis/transaction_commands.rb

@@ -1,5 +1,5 @@
 module FakeRedis
-  TRANSACTION_COMMANDS = [:discard, :exec, :multi, :watch, :unwatch]
+  TRANSACTION_COMMANDS = [:discard, :exec, :multi, :watch, :unwatch, :client]
 
   module TransactionCommands
     def self.included(klass)
@@ -72,7 +72,7 @@ module FakeRedis
       "OK"
     end
 
-    def watch(_)
+    def watch(*_)
       "OK"
     end
 

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.5.0"
+  VERSION = "0.8.0"
 end

data/lib/fakeredis/zset.rb

@@ -5,6 +5,10 @@ module FakeRedis
       super(key, _floatify(val))
     end
 
+    def identical_scores?
+      values.uniq.size == 1
+    end
+
     # Increments the value of key by val
     def increment(key, val)
       self[key] += _floatify(val)
@@ -13,7 +17,7 @@ module FakeRedis
     def select_by_score min, max
       min = _floatify(min, true)
       max = _floatify(max, false)
-      reject {|_,v| v < min || v > max }
+      select {|_,v| v >= min && v <= max }
     end
 
     private
@@ -25,8 +29,10 @@ module FakeRedis
       elsif (( number = str.to_s.match(/^\((\d+)/i) ))
         number[1].to_i + (increment ? 1 : -1)
       else
-        Float str
+        Float str.to_s
       end
+    rescue ArgumentError
+      raise Redis::CommandError, "ERR value is not a valid float"
     end
 
   end

data/lib/redis/connection/memory.rb

@@ -8,14 +8,21 @@ require "fakeredis/sorted_set_argument_handler"
 require "fakeredis/sorted_set_store"
 require "fakeredis/transaction_commands"
 require "fakeredis/zset"
+require "fakeredis/bitop_command"
+require "fakeredis/geo_commands"
+require "fakeredis/version"
 
 class Redis
   module Connection
+    DEFAULT_REDIS_VERSION = '3.3.5'
+
     class Memory
       include Redis::Connection::CommandHelper
       include FakeRedis
       include SortMethod
       include TransactionCommands
+      include BitopCommand
+      include GeoCommands
       include CommandExecutor
 
       attr_accessor :options
@@ -35,17 +42,26 @@ class Redis
         @databases = nil
       end
 
+      def self.channels
+        @channels ||= Hash.new {|h,k| h[k] = [] }
+      end
+
+      def self.reset_all_channels
+        @channels = nil
+      end
+
       def self.connect(options = {})
         new(options)
       end
 
       def initialize(options = {})
-        self.options = options
+        self.options = self.options ? self.options.merge(options) : options
       end
 
       def database_id
         @database_id ||= 0
       end
+
       attr_writer :database_id
 
       def database_instance_key
@@ -79,6 +95,15 @@ class Redis
       def disconnect
       end
 
+      def client(command, _options = {})
+        case command
+        when :setname then "OK"
+        when :getname then nil
+        else
+          raise Redis::CommandError, "ERR unknown command '#{command}'"
+        end
+      end
+
       def timeout=(usecs)
       end
 
@@ -86,14 +111,6 @@ class Redis
         replies.shift
       end
 
-      # NOT IMPLEMENTED:
-      # * blpop
-      # * brpop
-      # * brpoplpush
-      # * subscribe
-      # * psubscribe
-      # * publish
-
       def flushdb
         databases.delete_at(database_id)
         "OK"
@@ -116,7 +133,7 @@ class Redis
 
       def info
         {
-          "redis_version" => "2.6.16",
+          "redis_version" => options[:version] || DEFAULT_REDIS_VERSION,
           "connected_clients" => "1",
           "connected_slaves" => "0",
           "used_memory" => "3187",
@@ -133,9 +150,13 @@ class Redis
 
       def save; end
 
-      def bgsave ; end
+      def bgsave; end
+
+      def bgrewriteaof; end
+
+      def evalsha; end
 
-      def bgrewriteaof ; end
+      def eval; end
 
       def move key, destination_id
         raise Redis::CommandError, "ERR source and destination objects are the same" if destination_id == database_id
@@ -146,6 +167,45 @@ class Redis
         true
       end
 
+      def dump(key)
+        return nil unless exists(key)
+
+        value = data[key]
+
+        Marshal.dump(
+          value: value,
+          version: FakeRedis::VERSION, # Redis includes the version, so we might as well
+        )
+      end
+
+      def restore(key, ttl, serialized_value)
+        raise Redis::CommandError, "ERR Target key name is busy." if exists(key)
+
+        raise Redis::CommandError, "ERR DUMP payload version or checksum are wrong" if serialized_value.nil?
+
+        parsed_value = begin
+          Marshal.load(serialized_value)
+        rescue TypeError
+          raise Redis::CommandError, "ERR DUMP payload version or checksum are wrong"
+        end
+
+        if parsed_value[:version] != FakeRedis::VERSION
+          raise Redis::CommandError, "ERR DUMP payload version or checksum are wrong"
+        end
+
+        # We could figure out what type the key was and set it with the public API here,
+        # or we could just assign the value. If we presume the serialized_value is only ever
+        # a return value from `dump` then we've only been given something that was in
+        # the internal data structure anyway.
+        data[key] = parsed_value[:value]
+
+        # Set a TTL if one has been passed
+        ttl = ttl.to_i # Makes nil into 0
+        expire(key, ttl / 1000) unless ttl.zero?
+
+        "OK"
+      end
+
       def get(key)
         data_type_check(key, String)
         data[key]
@@ -161,6 +221,11 @@ class Redis
         data[key][start_index..end_index].unpack('B*')[0].count("1")
       end
 
+      def bitpos(key, bit, start_index = 0, end_index = -1)
+        value = data[key] || ""
+        value[0..end_index].unpack('B*')[0].index(bit.to_s, start_index * 8) || -1
+      end
+
       def getrange(key, start, ending)
         return unless data[key]
         data[key][start..ending]
@@ -202,11 +267,22 @@ class Redis
       end
 
       def hdel(key, field)
-        field = field.to_s
         data_type_check(key, Hash)
-        deleted = data[key] && data[key].delete(field)
+        return 0 unless data[key]
+
+        if field.is_a?(Array)
+          old_keys_count = data[key].size
+          fields = field.map(&:to_s)
+
+          data[key].delete_if { |k, v| fields.include? k }
+          deleted = old_keys_count - data[key].size
+        else
+          field = field.to_s
+          deleted = data[key].delete(field) ? 1 : 0
+        end
+
         remove_key_for_empty_collection(key)
-        deleted ? 1 : 0
+        deleted
       end
 
       def hkeys(key)
@@ -215,6 +291,44 @@ class Redis
         data[key].keys
       end
 
+      def hscan(key, start_cursor, *args)
+        data_type_check(key, Hash)
+        return ["0", []] unless data[key]
+
+        match = "*"
+        count = 10
+
+        if args.size.odd?
+          raise_argument_error('hscan')
+        end
+
+        if idx = args.index("MATCH")
+          match = args[idx + 1]
+        end
+
+        if idx = args.index("COUNT")
+          count = args[idx + 1]
+        end
+
+        start_cursor = start_cursor.to_i
+
+        cursor = start_cursor
+        next_keys = []
+
+        if start_cursor + count >= data[key].length
+          next_keys = (data[key].to_a)[start_cursor..-1]
+          cursor = 0
+        else
+          cursor = start_cursor + count
+          next_keys = (data[key].to_a)[start_cursor..cursor-1]
+        end
+
+        filtered_next_keys = next_keys.select{|k,v| File.fnmatch(match, k)}
+        result = filtered_next_keys.flatten.map(&:to_s)
+
+        return ["#{cursor}", result]
+      end
+
       def keys(pattern = "*")
         data.keys.select { |key| File.fnmatch(pattern, key) }
       end
@@ -256,7 +370,14 @@ class Redis
 
       def lrange(key, startidx, endidx)
         data_type_check(key, Array)
-        (data[key] && data[key][startidx..endidx]) || []
+        if data[key]
+          # In Ruby when negative start index is out of range Array#slice returns
+          # nil which is not the case for lrange in Redis.
+          startidx = 0 if startidx < 0 && startidx.abs > data[key].size
+          data[key][startidx..endidx] || []
+        else
+          []
+        end
       end
 
       def ltrim(key, start, stop)
@@ -284,10 +405,14 @@ class Redis
       def linsert(key, where, pivot, value)
         data_type_check(key, Array)
         return unless data[key]
-        index = data[key].index(pivot)
-        case where
-          when :before then data[key].insert(index, value)
-          when :after  then data[key].insert(index + 1, value)
+
+        value = value.to_s
+        index = data[key].index(pivot.to_s)
+        return -1 if index.nil?
+
+        case where.to_s
+          when /\Abefore\z/i then data[key].insert(index, value)
+          when /\Aafter\z/i  then data[key].insert(index + 1, value)
           else raise_syntax_error
         end
       end
@@ -296,12 +421,14 @@ class Redis
         data_type_check(key, Array)
         return unless data[key]
         raise Redis::CommandError, "ERR index out of range" if index >= data[key].size
-        data[key][index] = value
+        data[key][index] = value.to_s
       end
 
       def lrem(key, count, value)
         data_type_check(key, Array)
-        return unless data[key]
+        return 0 unless data[key]
+
+        value = value.to_s
         old_size = data[key].size
         diff =
           if count == 0
@@ -318,6 +445,7 @@ class Redis
       end
 
       def rpush(key, value)
+        raise_argument_error('rpush') if value.respond_to?(:each) && value.empty?
         data_type_check(key, Array)
         data[key] ||= []
         [value].flatten.each do |val|
@@ -327,12 +455,14 @@ class Redis
       end
 
       def rpushx(key, value)
+        raise_argument_error('rpushx') if value.respond_to?(:each) && value.empty?
         data_type_check(key, Array)
         return unless data[key]
         rpush(key, value)
       end
 
       def lpush(key, value)
+        raise_argument_error('lpush') if value.respond_to?(:each) && value.empty?
         data_type_check(key, Array)
         data[key] ||= []
         [value].flatten.each do |val|
@@ -342,6 +472,7 @@ class Redis
       end
 
       def lpushx(key, value)
+        raise_argument_error('lpushx') if value.respond_to?(:each) && value.empty?
         data_type_check(key, Array)
         return unless data[key]
         lpush(key, value)
@@ -353,6 +484,18 @@ class Redis
         data[key].pop
       end
 
+      def brpop(keys, timeout=0)
+        #todo threaded mode
+        keys = Array(keys)
+        keys.each do |key|
+          if data[key] && data[key].size > 0
+            return [key, data[key].pop]
+          end
+        end
+        sleep(timeout.to_f)
+        nil
+      end
+
       def rpoplpush(key1, key2)
         data_type_check(key1, Array)
         rpop(key1).tap do |elem|
@@ -360,12 +503,31 @@ class Redis
         end
       end
 
+      def brpoplpush(key1, key2, opts={})
+        data_type_check(key1, Array)
+        _key, elem = brpop(key1)
+        lpush(key2, elem) unless elem.nil?
+        elem
+      end
+
       def lpop(key)
         data_type_check(key, Array)
         return unless data[key]
         data[key].shift
       end
 
+      def blpop(keys, timeout=0)
+        #todo threaded mode
+        keys = Array(keys)
+        keys.each do |key|
+          if data[key] && data[key].size > 0
+            return [key, data[key].shift]
+          end
+        end
+        sleep(timeout.to_f)
+        nil
+      end
+
       def smembers(key)
         data_type_check(key, ::Set)
         return [] unless data[key]
@@ -399,12 +561,14 @@ class Redis
 
       def srem(key, value)
         data_type_check(key, ::Set)
+        value = Array(value)
+        raise_argument_error('srem') if value.empty?
         return false unless data[key]
 
         if value.is_a?(Array)
           old_size = data[key].size
           values = value.map(&:to_s)
-          values.each { |value| data[key].delete(value) }
+          values.each { |v| data[key].delete(v) }
           deleted = old_size - data[key].size
         else
           deleted = !!data[key].delete?(value.to_s)
@@ -421,11 +585,14 @@ class Redis
         result
       end
 
-      def spop(key)
+      def spop(key, count = nil)
         data_type_check(key, ::Set)
-        elem = srandmember(key)
-        srem(key, elem)
-        elem
+        results = (count || 1).times.map do
+          elem = srandmember(key)
+          srem(key, elem) if elem
+          elem
+        end.compact
+        count.nil? ? results.first : results
       end
 
       def scard(key)
@@ -435,6 +602,7 @@ class Redis
       end
 
       def sinter(*keys)
+        keys = keys[0] if flatten?(keys)
         raise_argument_error('sinter') if keys.empty?
 
         keys.each { |k| data_type_check(k, ::Set) }
@@ -452,6 +620,9 @@ class Redis
       end
 
       def sunion(*keys)
+        keys = keys[0] if flatten?(keys)
+        raise_argument_error('sunion') if keys.empty?
+
         keys.each { |k| data_type_check(k, ::Set) }
         keys = keys.map { |k| data[k] || ::Set.new }
         keys.inject(::Set.new) do |set, key|
@@ -466,6 +637,7 @@ class Redis
       end
 
       def sdiff(key1, *keys)
+        keys = keys[0] if flatten?(keys)
         [key1, *keys].each { |k| data_type_check(k, ::Set) }
         keys = keys.map { |k| data[k] || ::Set.new }
         keys.inject(data[key1] || Set.new) do |memo, set|
@@ -483,23 +655,58 @@ class Redis
         number.nil? ? srandmember_single(key) : srandmember_multiple(key, number)
       end
 
-      def del(*keys)
-        keys = keys.flatten(1)
-        raise_argument_error('del') if keys.empty?
+      def sscan(key, start_cursor, *args)
+        data_type_check(key, ::Set)
+        return ["0", []] unless data[key]
 
-        old_count = data.keys.size
-        keys.each do |key|
-          data.delete(key)
+        match = "*"
+        count = 10
+
+        if args.size.odd?
+          raise_argument_error('sscan')
         end
-        old_count - data.keys.size
+
+        if idx = args.index("MATCH")
+          match = args[idx + 1]
+        end
+
+        if idx = args.index("COUNT")
+          count = args[idx + 1]
+        end
+
+        start_cursor = start_cursor.to_i
+
+        cursor = start_cursor
+        next_keys = []
+
+        if start_cursor + count >= data[key].length
+          next_keys = (data[key].to_a)[start_cursor..-1]
+          cursor = 0
+        else
+          cursor = start_cursor + count
+          next_keys = (data[key].to_a)[start_cursor..cursor-1]
+        end
+
+        filtered_next_keys = next_keys.select{ |k,v| File.fnmatch(match, k)}
+        result = filtered_next_keys.flatten.map(&:to_s)
+
+        return ["#{cursor}", result]
+      end
+
+      def del(*keys)
+        delete_keys(keys, 'del')
+      end
+
+      def unlink(*keys)
+        delete_keys(keys, 'unlink')
       end
 
       def setnx(key, value)
         if exists(key)
-          false
+          0
         else
           set(key, value)
-          true
+          1
         end
       end
 
@@ -525,6 +732,12 @@ class Redis
         1
       end
 
+      def pexpire(key, ttl)
+        return 0 unless data[key]
+        data.expires[key] = Time.now + (ttl / 1000.0)
+        1
+      end
+
       def ttl(key)
         if data.expires.include?(key) && (ttl = data.expires[key].to_i - Time.now.to_i) > 0
           ttl
@@ -533,6 +746,14 @@ class Redis
         end
       end
 
+      def pttl(key)
+        if data.expires.include?(key) && (ttl = data.expires[key].to_f - Time.now.to_f) > 0
+          ttl * 1000
+        else
+          exists(key) ? -1 : -2
+        end
+      end
+
       def expireat(key, timestamp)
         data.expires[key] = Time.at(timestamp)
         true
@@ -548,10 +769,10 @@ class Redis
         if data[key]
           result = !data[key].include?(field)
           data[key][field] = value.to_s
-          result
+          result ? 1 : 0
         else
           data[key] = { field => value.to_s }
-          true
+          1
         end
       end
 
@@ -584,10 +805,11 @@ class Redis
             data[key][field[0].to_s] = field[1].to_s
           end
         end
+        "OK"
       end
 
       def hmget(key, *fields)
-        raise_argument_error('hmget')  if fields.empty?
+        raise_argument_error('hmget')  if fields.empty? || fields.flatten.empty?
 
         data_type_check(key, Hash)
         fields.flatten.map do |field|
@@ -606,6 +828,12 @@ class Redis
         data[key].size
       end
 
+      def hstrlen(key, field)
+        data_type_check(key, Hash)
+        return 0 if data[key].nil? || data[key][field].nil?
+        data[key][field].size
+      end
+
       def hvals(key)
         data_type_check(key, Hash)
         return [] unless data[key]
@@ -642,22 +870,14 @@ class Redis
 
       def sync ; end
 
-      def [](key)
-        get(key)
-      end
-
-      def []=(key, value)
-        set(key, value)
-      end
-
       def set(key, value, *array_options)
         option_nx = array_options.delete("NX")
         option_xx = array_options.delete("XX")
 
-        return false if option_nx && option_xx
+        return nil if option_nx && option_xx
 
-        return false if option_nx && exists(key)
-        return false if option_xx && !exists(key)
+        return nil if option_nx && exists(key)
+        return nil if option_xx && !exists(key)
 
         data[key] = value.to_s
 
@@ -688,6 +908,10 @@ class Redis
         "OK"
       end
 
+      def psetex(key, milliseconds, value)
+        setex(key, milliseconds / 1000.0, value)
+      end
+
       def setrange(key, offset, value)
         return unless data[key]
         s = data[key][offset,value.size]
@@ -727,6 +951,11 @@ class Redis
         data[key].to_i
       end
 
+      def incrbyfloat(key, by)
+        data.merge!({ key => (data[key].to_f + by.to_f).to_s || by })
+        data[key]
+      end
+
       def decr(key)
         data.merge!({ key => (data[key].to_i - 1).to_s || "-1"})
         data[key].to_i
@@ -758,10 +987,6 @@ class Redis
         match = "*"
         count = 10
 
-        if args.size.odd?
-          raise_argument_error('scan')
-        end
-
         if idx = args.index("MATCH")
           match = args[idx + 1]
         end
@@ -771,23 +996,41 @@ class Redis
         end
 
         start_cursor = start_cursor.to_i
-        data_type_check(start_cursor, Fixnum)
+        data_type_check(start_cursor, Integer)
 
         cursor = start_cursor
-        next_keys = []
+        returned_keys = []
+        final_page = start_cursor + count >= keys(match).length
+
+        if final_page
+          previous_keys_been_deleted = (count >= keys(match).length)
+          start_index = previous_keys_been_deleted ? 0 : cursor
 
-        if start_cursor + count >= data.length
-          next_keys = keys(match)[start_cursor..-1]
+          returned_keys = keys(match)[start_index..-1]
           cursor = 0
         else
-          cursor = start_cursor + 10
-          next_keys = keys(match)[start_cursor..cursor]
+          end_index = start_cursor + (count - 1)
+          returned_keys = keys(match)[start_cursor..end_index]
+          cursor = start_cursor + count
         end
 
-        return "#{cursor}", next_keys
+        return "#{cursor}", returned_keys
       end
 
       def zadd(key, *args)
+        option_xx = args.delete("XX")
+        option_nx = args.delete("NX")
+        option_ch = args.delete("CH")
+        option_incr = args.delete("INCR")
+
+        if option_xx && option_nx
+          raise_options_error("XX", "NX")
+        end
+
+        if option_incr && args.size > 2
+          raise_options_error("INCR")
+        end
+
         if !args.first.is_a?(Array)
           if args.size < 2
             raise_argument_error('zadd')
@@ -803,18 +1046,39 @@ class Redis
         data_type_check(key, ZSet)
         data[key] ||= ZSet.new
 
-        if args.size == 2 && !(Array === args.first)
-          score, value = args
-          exists = !data[key].key?(value.to_s)
+        # Turn [1, 2, 3, 4] into [[1, 2], [3, 4]] unless it is already
+        args = args.each_slice(2).to_a unless args.first.is_a?(Array)
+
+        changed = 0
+        exists = args.map(&:last).count { |el| !hexists(key, el.to_s) }
+
+        args.each do |score, value|
+          if option_nx && hexists(key, value.to_s)
+            next
+          end
+
+          if option_xx && !hexists(key, value.to_s)
+            exists -= 1
+            next
+          end
+
+          if option_incr
+            data[key][value.to_s] ||= 0
+            return data[key].increment(value, score).to_s
+          end
+
+          if option_ch && data[key][value.to_s] != score
+            changed += 1
+          end
           data[key][value.to_s] = score
-        else
-          # Turn [1, 2, 3, 4] into [[1, 2], [3, 4]] unless it is already
-          args = args.each_slice(2).to_a unless args.first.is_a?(Array)
-          exists = args.map(&:last).map { |el| data[key].key?(el.to_s) }.count(false)
-          args.each { |s, v| data[key][v.to_s] = s }
         end
 
-        exists
+        if option_incr
+          changed = changed.zero? ? nil : changed
+          exists = exists.zero? ? nil : exists
+        end
+
+        option_ch ? changed : exists
       end
 
       def zrem(key, value)
@@ -830,6 +1094,36 @@ class Redis
         response
       end
 
+      def zpopmax(key, count = nil)
+        data_type_check(key, ZSet)
+        return [] unless data[key]
+        sorted_members = sort_keys(data[key])
+        results = sorted_members.last(count || 1).reverse!
+        results.each do |member|
+          zrem(key, member.first)
+        end
+        count.nil? ? results.first : results.flatten
+      end
+
+      def zpopmin(key, count = nil)
+        data_type_check(key, ZSet)
+        return [] unless data[key]
+        sorted_members = sort_keys(data[key])
+        results = sorted_members.first(count || 1)
+        results.each do |member|
+          zrem(key, member.first)
+        end
+        count.nil? ? results.first : results.flatten
+      end
+
+      def bzpopmax(*args)
+        bzpop(:bzpopmax, args)
+      end
+
+      def bzpopmin(*args)
+        bzpop(:bzpopmin, args)
+      end
+
       def zcard(key)
         data_type_check(key, ZSet)
         data[key] ? data[key].size : 0
@@ -838,7 +1132,13 @@ class Redis
       def zscore(key, value)
         data_type_check(key, ZSet)
         value = data[key] && data[key][value.to_s]
-        value && value.to_s
+        if value == Float::INFINITY
+          "inf"
+        elsif value == -Float::INFINITY
+          "-inf"
+        elsif value
+          value.to_s
+        end
       end
 
       def zcount(key, min, max)
@@ -852,7 +1152,14 @@ class Redis
         data[key] ||= ZSet.new
         data[key][value.to_s] ||= 0
         data[key].increment(value.to_s, num)
-        data[key][value.to_s].to_s
+
+        if num =~ /^\+?inf/
+          "inf"
+        elsif num == "-inf"
+          "-inf"
+        else
+          data[key][value.to_s].to_s
+        end
       end
 
       def zrank(key, value)
@@ -873,17 +1180,43 @@ class Redis
         data_type_check(key, ZSet)
         return [] unless data[key]
 
-        # Sort by score, or if scores are equal, key alphanum
-        results = data[key].sort do |(k1, v1), (k2, v2)|
-          if v1 == v2
-            k1 <=> k2
-          else
-            v1 <=> v2
-          end
-        end
+        results = sort_keys(data[key])
         # Select just the keys unless we want scores
         results = results.map(&:first) unless with_scores
-        results[start..stop].flatten.map(&:to_s)
+        start = [start, -results.size].max
+        (results[start..stop] || []).flatten.map(&:to_s)
+      end
+
+      def zrangebylex(key, start, stop, *opts)
+        data_type_check(key, ZSet)
+        return [] unless data[key]
+        zset = data[key]
+
+        sorted = if zset.identical_scores?
+          zset.keys.sort { |x, y| x.to_s <=> y.to_s }
+        else
+          zset.keys
+        end
+
+        range = get_range start, stop, sorted.first, sorted.last
+
+        filtered = []
+        sorted.each do |element|
+          filtered << element if (range[0][:value]..range[1][:value]).cover?(element)
+        end
+        filtered.shift if filtered[0] == range[0][:value] && !range[0][:inclusive]
+        filtered.pop if filtered.last == range[1][:value] && !range[1][:inclusive]
+
+        limit = get_limit(opts, filtered)
+        if limit
+          filtered = filtered[limit[0]..-1].take(limit[1])
+        end
+
+        filtered
+      end
+
+      def zrevrangebylex(key, start, stop, *args)
+        zrangebylex(key, stop, start, args).reverse
       end
 
       def zrevrange(key, start, stop, with_scores = nil)
@@ -966,6 +1299,158 @@ class Redis
         data[out].size
       end
 
+      def pfadd(key, member)
+        data_type_check(key, Set)
+        data[key] ||= Set.new
+        previous_size = data[key].size
+        data[key] |= Array(member)
+        data[key].size != previous_size
+      end
+
+      def pfcount(*keys)
+        keys = keys.flatten
+        raise_argument_error("pfcount") if keys.empty?
+        keys.each { |key| data_type_check(key, Set) }
+        if keys.count == 1
+          (data[keys.first] || Set.new).size
+        else
+          union = keys.map { |key| data[key] }.compact.reduce(&:|)
+          union.size
+        end
+      end
+
+      def pfmerge(destination, *sources)
+        sources.each { |source| data_type_check(source, Set) }
+        union = sources.map { |source| data[source] || Set.new }.reduce(&:|)
+        data[destination] = union
+        "OK"
+      end
+
+      def subscribe(*channels)
+        raise_argument_error('subscribe') if channels.empty?()
+
+        #Create messages for all data from the channels
+        channel_replies = channels.map do |channel|
+          self.class.channels[channel].slice!(0..-1).map!{|v| ["message", channel, v]}
+        end
+        channel_replies.flatten!(1)
+        channel_replies.compact!()
+
+        #Put messages into the replies for the future
+        channels.each_with_index do |channel,index|
+          replies << ["subscribe", channel, index+1]
+        end
+        replies.push(*channel_replies)
+
+        #Add unsubscribe message to stop blocking (see https://github.com/redis/redis-rb/blob/v3.2.1/lib/redis/subscribe.rb#L38)
+        replies.push(self.unsubscribe())
+
+        replies.pop() #Last reply will be pushed back on
+      end
+
+      def psubscribe(*patterns)
+        raise_argument_error('psubscribe') if patterns.empty?()
+
+        #Create messages for all data from the channels
+        channel_replies = self.class.channels.keys.map do |channel|
+          pattern = patterns.find{|p| File.fnmatch(p, channel) }
+          unless pattern.nil?()
+            self.class.channels[channel].slice!(0..-1).map!{|v| ["pmessage", pattern, channel, v]}
+          end
+        end
+        channel_replies.flatten!(1)
+        channel_replies.compact!()
+
+        #Put messages into the replies for the future
+        patterns.each_with_index do |pattern,index|
+          replies << ["psubscribe", pattern, index+1]
+        end
+        replies.push(*channel_replies)
+
+        #Add unsubscribe to stop blocking
+        replies.push(self.punsubscribe())
+
+        replies.pop() #Last reply will be pushed back on
+      end
+
+      def publish(channel, message)
+        self.class.channels[channel] << message
+        0 #Just fake number of subscribers
+      end
+
+      def unsubscribe(*channels)
+        if channels.empty?()
+          replies << ["unsubscribe", nil, 0]
+        else
+          channels.each do |channel|
+            replies << ["unsubscribe", channel, 0]
+          end
+        end
+        replies.pop() #Last reply will be pushed back on
+      end
+
+      def punsubscribe(*patterns)
+        if patterns.empty?()
+          replies << ["punsubscribe", nil, 0]
+        else
+          patterns.each do |pattern|
+            replies << ["punsubscribe", pattern, 0]
+          end
+        end
+        replies.pop() #Last reply will be pushed back on
+      end
+
+      def zscan(key, start_cursor, *args)
+        data_type_check(key, ZSet)
+        return [] unless data[key]
+
+        match = "*"
+        count = 10
+
+        if args.size.odd?
+          raise_argument_error('zscan')
+        end
+
+        if idx = args.index("MATCH")
+          match = args[idx + 1]
+        end
+
+        if idx = args.index("COUNT")
+          count = args[idx + 1]
+        end
+
+        start_cursor = start_cursor.to_i
+        data_type_check(start_cursor, Integer)
+
+        cursor = start_cursor
+        next_keys = []
+
+        sorted_keys = sort_keys(data[key])
+
+        if start_cursor + count >= sorted_keys.length
+          next_keys = sorted_keys.to_a.select { |k| File.fnmatch(match, k[0]) } [start_cursor..-1]
+          cursor = 0
+        else
+          cursor = start_cursor + count
+          next_keys = sorted_keys.to_a.select { |k| File.fnmatch(match, k[0]) } [start_cursor..cursor-1]
+        end
+        return "#{cursor}", next_keys.flatten.map(&:to_s)
+      end
+
+      # Originally from redis-rb
+      def zscan_each(key, *args, &block)
+        data_type_check(key, ZSet)
+        return [] unless data[key]
+
+        return to_enum(:zscan_each, key, options) unless block_given?
+        cursor = 0
+        loop do
+          cursor, values = zscan(key, cursor, options)
+          values.each(&block)
+          break if cursor == "0"
+        end
+      end
+
       private
         def raise_argument_error(command, match_string=command)
           error_message = if %w(hmset mset_odd).include?(match_string.downcase)
@@ -981,17 +1466,61 @@ class Redis
           raise Redis::CommandError, "ERR syntax error"
         end
 
+        def raise_options_error(*options)
+          if options.detect { |opt| opt.match(/incr/i) }
+            error_message = "ERR INCR option supports a single increment-element pair"
+          else
+            error_message = "ERR #{options.join(" and ")} options at the same time are not compatible"
+          end
+          raise Redis::CommandError, error_message
+        end
+
+        def raise_command_error(message)
+          raise Redis::CommandError, message
+        end
+
+        def delete_keys(keys, command)
+          keys = keys.flatten(1)
+          raise_argument_error(command) if keys.empty?
+
+          old_count = data.keys.size
+          keys.each do |key|
+            data.delete(key)
+          end
+          old_count - data.keys.size
+        end
+
         def remove_key_for_empty_collection(key)
           del(key) if data[key] && data[key].empty?
         end
 
         def data_type_check(key, klass)
           if data[key] && !data[key].is_a?(klass)
-            warn "Operation against a key holding the wrong kind of value: Expected #{klass} at #{key}."
             raise Redis::CommandError.new("WRONGTYPE Operation against a key holding the wrong kind of value")
           end
         end
 
+        def get_range(start, stop, min = -Float::INFINITY, max = Float::INFINITY)
+          range_options = []
+
+          [start, stop].each do |value|
+            case value[0]
+            when "-"
+              range_options << { value: min, inclusive: true }
+            when "+"
+              range_options << { value: max, inclusive: true }
+            when "["
+              range_options << { value: value[1..-1], inclusive: true }
+            when "("
+              range_options << { value: value[1..-1], inclusive: false }
+            else
+              raise Redis::CommandError, "ERR min or max not valid string range item"
+            end
+          end
+
+          range_options
+        end
+
         def get_limit(opts, vals)
           index = opts.index('LIMIT')
 
@@ -1008,6 +1537,9 @@ class Redis
         def mapped_param? param
           param.size == 1 && param[0].is_a?(Array)
         end
+        # NOTE : Redis-rb 3.x will flatten *args, so method(["a", "b", "c"])
+        #        should be handled the same way as method("a", "b", "c")
+        alias_method :flatten?, :mapped_param?
 
         def srandmember_single(key)
           data_type_check(key, ::Set)
@@ -1027,8 +1559,44 @@ class Redis
             (1..-number).map { data[key].to_a[rand(data[key].size)] }.flatten
           end
         end
+
+        def bzpop(command, args)
+          timeout =
+            if args.last.is_a?(Hash)
+              args.pop[:timeout]
+            elsif args.last.respond_to?(:to_int)
+              args.pop.to_int
+            end
+
+          timeout ||= 0
+          single_pop_command = command.to_s[1..-1]
+          keys = args.flatten
+          keys.each do |key|
+            if data[key]
+              data_type_check(data[key], ZSet)
+              if data[key].size > 0
+                result = public_send(single_pop_command, key)
+                return result.unshift(key)
+              end
+            end
+          end
+          sleep(timeout.to_f)
+          nil
+        end
+
+        def sort_keys(arr)
+          # Sort by score, or if scores are equal, key alphanum
+          arr.sort do |(k1, v1), (k2, v2)|
+            if v1 == v2
+              k1 <=> k2
+            else
+              v1 <=> v2
+            end
+          end
+        end
     end
   end
 end
 
+# FIXME this line should be deleted as explicit enabling is better
 Redis::Connection.drivers << Redis::Connection::Memory