fakeredis 0.7.0 → 0.9.0

data/lib/redis/connection/memory.rb

@@ -9,16 +9,20 @@ 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
@@ -51,7 +55,7 @@ class Redis
       end
 
       def initialize(options = {})
-        self.options = options
+        self.options = self.options ? self.options.merge(options) : options
       end
 
       def database_id
@@ -82,20 +86,20 @@ class Redis
       attr_writer :replies
 
       def connected?
-        true
+        defined?(@disconnected) ? false : true
       end
 
       def connect_unix(path, timeout)
       end
 
       def disconnect
+        @disconnected = true
       end
 
       def client(command, _options = {})
         case command
-        when :setname then true
+        when :setname then "OK"
         when :getname then nil
-        when :client then true
         else
           raise Redis::CommandError, "ERR unknown command '#{command}'"
         end
@@ -130,7 +134,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",
@@ -147,9 +151,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
@@ -161,7 +169,7 @@ class Redis
       end
 
       def dump(key)
-        return nil unless exists(key)
+        return nil if exists(key).zero?
 
         value = data[key]
 
@@ -172,7 +180,7 @@ class Redis
       end
 
       def restore(key, ttl, serialized_value)
-        raise Redis::CommandError, "ERR Target key name is busy." if exists(key)
+        raise Redis::CommandError, "ERR Target key name is busy." if exists(key) > 0
 
         raise Redis::CommandError, "ERR DUMP payload version or checksum are wrong" if serialized_value.nil?
 
@@ -214,6 +222,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]
@@ -228,9 +241,9 @@ class Redis
       end
 
       def mget(*keys)
+        keys = keys[0] if flatten?(keys)
         raise_argument_error('mget') if keys.empty?
-        # We work with either an array, or list of arguments
-        keys = keys.first if keys.size == 1
+        keys.each { |key| data_type_check(key, String) }
         data.values_at(*keys)
       end
 
@@ -346,7 +359,11 @@ class Redis
         data.keys.count
       end
 
-      def exists(key)
+      def exists(*keys)
+        keys.count { |key| data.key?(key) }
+      end
+
+      def exists?(key)
         data.key?(key)
       end
 
@@ -493,9 +510,9 @@ class Redis
 
       def brpoplpush(key1, key2, opts={})
         data_type_check(key1, Array)
-        brpop(key1).tap do |elem|
-          lpush(key2, elem) unless elem.nil?
-        end
+        _key, elem = brpop(key1)
+        lpush(key2, elem) unless elem.nil?
+        elem
       end
 
       def lpop(key)
@@ -530,6 +547,8 @@ class Redis
 
       def sadd(key, value)
         data_type_check(key, ::Set)
+        should_return_int = value.is_a? Array
+
         value = Array(value)
         raise_argument_error('sadd') if value.empty?
 
@@ -542,13 +561,15 @@ class Redis
           data[key].size
         end
 
-        # 0 = false, 1 = true, 2+ untouched
-        return result == 1 if result < 2
+        # 0 = false, 1 = true unless an array was passed in
+        return result == 1 unless should_return_int
+
         result
       end
 
       def srem(key, value)
         data_type_check(key, ::Set)
+        raise_argument_error('srem') if Array(value).empty?
         return false unless data[key]
 
         if value.is_a?(Array)
@@ -575,7 +596,7 @@ class Redis
         data_type_check(key, ::Set)
         results = (count || 1).times.map do
           elem = srandmember(key)
-          srem(key, elem)
+          srem(key, elem) if elem
           elem
         end.compact
         count.nil? ? results.first : results
@@ -635,6 +656,8 @@ class Redis
         data_type_check(destination, ::Set)
         result = sdiff(key1, *keys)
         data[destination] = ::Set.new(result)
+
+        result.size
       end
 
       def srandmember(key, number=nil)
@@ -680,18 +703,15 @@ class Redis
       end
 
       def del(*keys)
-        keys = keys.flatten(1)
-        raise_argument_error('del') if keys.empty?
+        delete_keys(keys, 'del')
+      end
 
-        old_count = data.keys.size
-        keys.each do |key|
-          data.delete(key)
-        end
-        old_count - data.keys.size
+      def unlink(*keys)
+        delete_keys(keys, 'unlink')
       end
 
       def setnx(key, value)
-        if exists(key)
+        if exists(key) > 0
           0
         else
           set(key, value)
@@ -707,7 +727,7 @@ class Redis
       end
 
       def renamenx(key, new_key)
-        if exists(new_key)
+        if exists(new_key) > 0
           false
         else
           rename(key, new_key)
@@ -731,7 +751,7 @@ class Redis
         if data.expires.include?(key) && (ttl = data.expires[key].to_i - Time.now.to_i) > 0
           ttl
         else
-          exists(key) ? -1 : -2
+          exists(key) > 0 ? -1 : -2
         end
       end
 
@@ -739,7 +759,7 @@ class Redis
         if data.expires.include?(key) && (ttl = data.expires[key].to_f - Time.now.to_f) > 0
           ttl * 1000
         else
-          exists(key) ? -1 : -2
+          exists(key) > 0 ? -1 : -2
         end
       end
 
@@ -752,17 +772,32 @@ class Redis
         !!data.expires.delete(key)
       end
 
-      def hset(key, field, value)
+      def hset(key, *fields)
+        fields = fields.first if fields.size == 1 && fields.first.is_a?(Hash)
+        raise_argument_error('hset') if fields.empty?
+    
+        is_list_of_arrays = fields.all?{|field| field.instance_of?(Array)}
+    
+        raise_argument_error('hmset') if fields.size.odd? and !is_list_of_arrays
+        raise_argument_error('hmset') if is_list_of_arrays and !fields.all?{|field| field.length == 2}
+        
         data_type_check(key, Hash)
-        field = field.to_s
-        if data[key]
-          result = !data[key].include?(field)
-          data[key][field] = value.to_s
-          result ? 1 : 0
+        insert_count = 0
+        data[key] ||= {}
+    
+        if fields.is_a?(Hash)
+          insert_count = fields.keys.size - (data[key].keys & fields.keys).size
+    
+          data[key].merge!(fields)
         else
-          data[key] = { field => value.to_s }
-          1
+          fields.each_slice(2) do |field|
+            insert_count += 1 if data[key][field[0].to_s].nil?
+    
+            data[key][field[0].to_s] = field[1].to_s
+          end
         end
+    
+        insert_count
       end
 
       def hsetnx(key, field, value)
@@ -798,7 +833,7 @@ class Redis
       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|
@@ -817,6 +852,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]
@@ -853,26 +894,19 @@ 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) > 0
+        return nil if option_xx && exists(key).zero?
 
         data[key] = value.to_s
 
         options = Hash[array_options.each_slice(2).to_a]
+        raise_command_error('ERR value is not an integer or out of range') if non_integer_expirations?(options)
         ttl_in_seconds = options["EX"] if options["EX"]
         ttl_in_seconds = options["PX"] / 1000.0 if options["PX"]
 
@@ -881,6 +915,11 @@ class Redis
         "OK"
       end
 
+      def non_integer_expirations?(options)
+        (options["EX"] && !options["EX"].is_a?(Integer)) ||
+          (options["PX"] && !options["PX"].is_a?(Integer))
+      end
+
       def setbit(key, offset, bit)
         old_val = data[key] ? data[key].unpack('B*')[0].split("") : []
         size_increment = [((offset/8)+1)*8-old_val.length, 0].max
@@ -894,11 +933,19 @@ class Redis
       end
 
       def setex(key, seconds, value)
+        raise_command_error('ERR value is not an integer or out of range') unless seconds.is_a?(Integer)
         data[key] = value.to_s
         expire(key, seconds)
         "OK"
       end
 
+      def psetex(key, milliseconds, value)
+        raise_command_error('ERR value is not an integer or out of range') unless milliseconds.is_a?(Integer)
+        data[key] = value.to_s
+        expire(key, milliseconds / 1000.0)
+        "OK"
+      end
+
       def setrange(key, offset, value)
         return unless data[key]
         s = data[key][offset,value.size]
@@ -1005,6 +1052,19 @@ class Redis
       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')
@@ -1020,18 +1080,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)
@@ -1047,6 +1128,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
@@ -1055,7 +1166,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)
@@ -1069,7 +1186,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.is_a?(String) && num =~ /^\+?inf/
+          "inf"
+        elsif num == "-inf"
+          "-inf"
+        else
+          data[key][value.to_s].to_s
+        end
       end
 
       def zrank(key, value)
@@ -1093,6 +1217,7 @@ class Redis
         results = sort_keys(data[key])
         # Select just the keys unless we want scores
         results = results.map(&:first) unless with_scores
+        start = [start, -results.size].max
         (results[start..stop] || []).flatten.map(&:to_s)
       end
 
@@ -1208,6 +1333,33 @@ 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?()
 
@@ -1348,13 +1500,36 @@ 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
@@ -1419,9 +1594,33 @@ class Redis
           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
-          sorted_keys = arr.sort do |(k1, v1), (k2, v2)|
+          arr.sort do |(k1, v1), (k2, v2)|
             if v1 == v2
               k1 <=> k2
             else