mock_redis 0.4.1 → 0.5.0

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+### 0.5.0
+* Support `redis-rb` >= 3.0
+* Support Redis::Distributed
+* Support ruby 1.9.3 in spec suite
+* Support subsecond timeouts
+* Support `-inf`, `+inf` in #zcount
+* Return array of results from pipelined calls
+* Use `debugger` instead of the deprecated `ruby-debug19`
+* Fix exception handling in transaction wrappers
+* Fix rename error behaviour for nonexistant keys
+
 ### 0.4.1
 * bugfixes: teach various methods to correctly handle non-string values
 

data/Gemfile

@@ -5,5 +5,5 @@ gemspec
 
 group :test do
   gem "ruby-debug", :platforms => :mri_18
-  gem "ruby-debug19", :platforms => :mri_19
+  gem "debugger", :platforms => :mri_19
 end

data/lib/mock_redis/assertions.rb

@@ -4,10 +4,10 @@ class MockRedis
 
     def assert_has_args(args, command)
       unless args.any?
-        raise RuntimeError,
+        raise Redis::CommandError,
         "ERR wrong number of arguments for '#{command}' command"
       end
     end
-      
+
   end
 end

data/lib/mock_redis/database.rb

@@ -57,7 +57,7 @@ class MockRedis
 
     def expireat(key, timestamp)
       unless looks_like_integer?(timestamp.to_s)
-        raise RuntimeError, "ERR value is not an integer or out of range"
+        raise Redis::CommandError, "ERR value is not an integer or out of range"
       end
 
       if exists(key)
@@ -304,16 +304,20 @@ class MockRedis
     end
 
     def rename(key, newkey)
-      if key == newkey
-        raise RuntimeError, "ERR source and destination objects are the same"
+      if !data.include?(key)
+        raise Redis::CommandError, "ERR no such key"
+      elsif key == newkey
+        raise Redis::CommandError, "ERR source and destination objects are the same"
       end
       data[newkey] = data.delete(key)
       'OK'
     end
 
     def renamenx(key, newkey)
-      if key == newkey
-        raise RuntimeError, "ERR source and destination objects are the same"
+      if !data.include?(key)
+        raise Redis::CommandError, "ERR no such key"
+      elsif key == newkey
+        raise Redis::CommandError, "ERR source and destination objects are the same"
       end
       if exists(newkey)
         false
@@ -356,10 +360,10 @@ class MockRedis
     private
 
     def assert_valid_timeout(timeout)
-      if !looks_like_integer?(timeout.to_s)
-        raise RuntimeError, "ERR timeout is not an integer or out of range"
+      if !looks_like_float?(timeout.to_s)
+        raise Redis::CommandError, "ERR timeout is not a float or out of range"
       elsif timeout < 0
-        raise RuntimeError, "ERR timeout is negative"
+        raise Redis::CommandError, "ERR timeout is negative"
       end
       timeout
     end
@@ -385,6 +389,10 @@ class MockRedis
       str =~ /^-?\d+$/
     end
 
+    def looks_like_float?(str)
+      !!Float(str) rescue false
+    end
+
     def redis_pattern_to_ruby_regex(pattern)
       Regexp.new(
         "^#{pattern}$".

data/lib/mock_redis/expire_wrapper.rb

@@ -12,9 +12,9 @@ class MockRedis
       @db = db
     end
 
-    def method_missing(method, *args)
+    def method_missing(method, *args, &block)
       @db.expire_keys
-      @db.send(method, *args)
+      @db.send(method, *args, &block)
     end
 
     def initialize_copy(source)

data/lib/mock_redis/hash_methods.rb

@@ -8,7 +8,13 @@ class MockRedis
 
     def hdel(key, field)
       with_hash_at(key) do |hash|
-        hash.delete(field.to_s) ? 1 : 0
+        if field.is_a?(Array)
+          orig_size = hash.size
+          hash.delete_if { |k,v| field.include?(k) }
+          orig_size - hash.size
+        else
+          hash.delete(field.to_s) ? 1 : 0
+        end
       end
     end
 
@@ -28,10 +34,10 @@ class MockRedis
       with_hash_at(key) do |hash|
         field = field.to_s
         unless can_incr?(data[key][field])
-          raise RuntimeError, "ERR hash value is not an integer"
+          raise Redis::CommandError, "ERR hash value is not an integer"
         end
         unless looks_like_integer?(increment.to_s)
-          raise RuntimeError, "ERR value is not an integer or out of range"
+          raise Redis::CommandError, "ERR value is not an integer or out of range"
         end
 
         new_value = (hash[field] || "0").to_i + increment.to_i
@@ -61,7 +67,7 @@ class MockRedis
     def hmset(key, *kvpairs)
       assert_has_args(kvpairs, 'hmset')
       if kvpairs.length.odd?
-        raise RuntimeError, "ERR wrong number of arguments for HMSET"
+        raise Redis::CommandError, "ERR wrong number of arguments for HMSET"
       end
 
       kvpairs.each_slice(2) do |(k,v)|
@@ -74,7 +80,7 @@ class MockRedis
       kvpairs = hash.to_a.flatten
       assert_has_args(kvpairs, 'hmset')
       if kvpairs.length.odd?
-        raise RuntimeError, "ERR wrong number of arguments for 'hmset' command"
+        raise Redis::CommandError, "ERR wrong number of arguments for 'hmset' command"
       end
 
       hmset(key, *kvpairs)
@@ -110,7 +116,7 @@ class MockRedis
 
     def assert_hashy(key)
       unless hashy?(key)
-        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
+        raise Redis::CommandError, "ERR Operation against a key holding the wrong kind of value"
       end
     end
 

data/lib/mock_redis/list_methods.rb

@@ -50,7 +50,7 @@ class MockRedis
 
     def linsert(key, position, pivot, value)
       unless %w[before after].include?(position.to_s)
-        raise RuntimeError, "ERR syntax error"
+        raise Redis::CommandError, "ERR syntax error"
       end
 
       assert_listy(key)
@@ -80,8 +80,9 @@ class MockRedis
       with_list_at(key, &:shift)
     end
 
-    def lpush(key, value)
-      with_list_at(key) {|l| l.unshift(value.to_s)}
+    def lpush(key, values)
+      values = [values] unless values.is_a?(Array)
+      with_list_at(key) {|l| values.each {|v| l.unshift(v.to_s)}}
       llen(key)
     end
 
@@ -120,11 +121,11 @@ class MockRedis
       assert_listy(key)
 
       unless list_at?(key)
-        raise RuntimeError, "ERR no such key"
+        raise Redis::CommandError, "ERR no such key"
       end
 
       unless (0...llen(key)).include?(index)
-        raise RuntimeError, "ERR index out of range"
+        raise Redis::CommandError, "ERR index out of range"
       end
 
       data[key][index] = value.to_s
@@ -148,8 +149,9 @@ class MockRedis
       value
     end
 
-    def rpush(key, value)
-      with_list_at(key) {|l| l.push(value.to_s)}
+    def rpush(key, values)
+      values = [values] unless values.is_a?(Array)
+      with_list_at(key) {|l| values.each {|v| l.push(v.to_s)}}
       llen(key)
     end
 
@@ -175,7 +177,7 @@ class MockRedis
     def assert_listy(key)
       unless listy?(key)
         # Not the most helpful error, but it's what redis-rb barfs up
-        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
+        raise Redis::CommandError, "ERR Operation against a key holding the wrong kind of value"
       end
     end
 

data/lib/mock_redis/multi_db_wrapper.rb

@@ -17,8 +17,8 @@ class MockRedis
       super || current_db.respond_to?(method, include_private)
     end
 
-    def method_missing(method, *args)
-      current_db.send(method, *args)
+    def method_missing(method, *args, &block)
+      current_db.send(method, *args, &block)
     end
 
     def initialize_copy(source)
@@ -56,7 +56,7 @@ class MockRedis
         when 'string'
           dest.set(key, src.get(key))
         when 'zset'
-          src.zrange(key, 0, -1, :with_scores => true).each_slice(2) do |(m,s)|
+          src.zrange(key, 0, -1, :with_scores => true).each do |(m,s)|
             dest.zadd(key, s, m)
           end
         else

data/lib/mock_redis/pipelined_wrapper.rb

@@ -0,0 +1,45 @@
+class MockRedis
+  class PipelinedWrapper
+    include UndefRedisMethods
+
+    def respond_to?(method, include_private=false)
+      super || @db.respond_to?(method)
+    end
+
+    def initialize(db)
+      @db = db
+      @pipelined_commands = []
+      @in_pipeline = false
+    end
+
+    def initialize_copy(source)
+      super
+      @db = @db.clone
+      @pipelined_commands = @pipelined_commands.clone
+    end
+
+    def method_missing(method, *args, &block)
+      if @in_pipeline
+        @pipelined_commands << [method, *args]
+        nil
+      else
+        @db.send(method, *args, &block)
+      end
+    end
+
+    def pipelined(options = {})
+      @in_pipeline = true
+      yield
+      @in_pipeline = false
+      responses = @pipelined_commands.map do |cmd|
+        begin
+          send(*cmd)
+        rescue => e
+          e
+        end
+      end
+      @pipelined_commands = []
+      responses
+    end
+  end
+end

data/lib/mock_redis/set_methods.rb

@@ -48,7 +48,7 @@ class MockRedis
     end
 
     def smembers(key)
-      with_set_at(key, &:to_a)
+      with_set_at(key, &:to_a).reverse
     end
 
     def smove(src, dest, member)
@@ -73,11 +73,20 @@ class MockRedis
     end
 
     def srandmember(key)
-      with_set_at(key, &:first)
+      members = with_set_at(key, &:to_a)
+      members[rand(members.length)]
     end
 
-    def srem(key, member)
-      with_set_at(key) {|s| !!s.delete?(member.to_s)}
+    def srem(key, members)
+      with_set_at(key) do |s|
+        if members.is_a?(Array)
+          orig_size = s.size
+          s.delete_if { |m| members.include?(m) }
+          orig_size - s.size
+        else
+          !!s.delete?(members.to_s)
+        end
+      end
     end
 
     def sunion(*keys)
@@ -117,7 +126,7 @@ class MockRedis
     def assert_sety(key)
       unless sety?(key)
         # Not the most helpful error, but it's what redis-rb barfs up
-        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
+        raise Redis::CommandError, "ERR Operation against a key holding the wrong kind of value"
       end
     end
 

data/lib/mock_redis/string_methods.rb

@@ -62,11 +62,11 @@ class MockRedis
     def incrby(key, n)
       assert_stringy(key)
       unless can_incr?(data[key])
-        raise RuntimeError, "ERR value is not an integer or out of range"
+        raise Redis::CommandError, "ERR value is not an integer or out of range"
       end
 
       unless looks_like_integer?(n.to_s)
-        raise RuntimeError, "ERR value is not an integer or out of range"
+        raise Redis::CommandError, "ERR value is not an integer or out of range"
       end
 
       new_value = data[key].to_i + n.to_i
@@ -86,7 +86,7 @@ class MockRedis
     def mset(*kvpairs)
       assert_has_args(kvpairs, 'mset')
       if kvpairs.length.odd?
-        raise RuntimeError, "ERR wrong number of arguments for MSET"
+        raise Redis::CommandError, "ERR wrong number of arguments for MSET"
       end
 
       kvpairs.each_slice(2) do |(k,v)|
@@ -100,10 +100,10 @@ class MockRedis
       assert_has_args(kvpairs, 'msetnx')
 
       if kvpairs.each_slice(2).any? {|(k,v)| exists(k)}
-        0
+        false
       else
         mset(*kvpairs)
-        1
+        true
       end
     end
 
@@ -195,7 +195,7 @@ class MockRedis
     def assert_stringy(key,
         message="ERR Operation against a key holding the wrong kind of value")
       unless stringy?(key)
-        raise RuntimeError, message
+        raise Redis::CommandError, message
       end
     end
 

data/lib/mock_redis/transaction_wrapper.rb

@@ -14,13 +14,13 @@ class MockRedis
       @in_multi = false
     end
 
-    def method_missing(method, *args)
+    def method_missing(method, *args, &block)
       if @in_multi
         @queued_commands << [method, *args]
         'QUEUED'
       else
         @db.expire_keys
-        @db.send(method, *args)
+        @db.send(method, *args, &block)
       end
     end
 
@@ -32,7 +32,7 @@ class MockRedis
 
     def discard
       unless @in_multi
-        raise RuntimeError, "ERR DISCARD without MULTI"
+        raise Redis::CommandError, "ERR DISCARD without MULTI"
       end
       @in_multi = false
       @queued_commands = []
@@ -41,7 +41,7 @@ class MockRedis
 
     def exec
       unless @in_multi
-        raise RuntimeError, "ERR EXEC without MULTI"
+        raise Redis::CommandError, "ERR EXEC without MULTI"
       end
       @in_multi = false
       responses = @queued_commands.map do |cmd|
@@ -57,12 +57,17 @@ class MockRedis
 
     def multi
       if @in_multi
-        raise RuntimeError, "ERR MULTI calls can not be nested"
+        raise Redis::CommandError, "ERR MULTI calls can not be nested"
       end
       @in_multi = true
       if block_given?
-        yield(self)
-        self.exec
+        begin
+          yield(self)
+          self.exec
+        rescue StandardError => e
+          self.discard
+          raise e
+        end
       else
         'OK'
       end
@@ -73,7 +78,7 @@ class MockRedis
     end
 
     def watch(_)
-      'OK'
+      nil
     end
 
   end

data/lib/mock_redis/version.rb

@@ -1,3 +1,3 @@
 class MockRedis
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 end

data/lib/mock_redis/zset_methods.rb

@@ -7,11 +7,33 @@ class MockRedis
     include Assertions
     include UtilityMethods
 
-    def zadd(key, score, member)
-      assert_scorey(score)
+    def zadd(key, *args)
+      if !args.first.is_a?(Array)
+        if args.size < 2
+          raise Redis::CommandError, "ERR wrong number of arguments for 'zadd' command"
+        elsif args.size.odd?
+          raise Redis::CommandError, "ERR syntax error"
+        end
+      else
+        unless args.all? {|pair| pair.size == 2 }
+          raise(Redis::CommandError, "ERR syntax error")
+        end
+      end
+
+      if args.size == 2
+        score, member = args
+        assert_scorey(score)
+        retval = !zscore(key, member)
+        with_zset_at(key) {|z| z.add(score, member.to_s)}
+      else
+        args = args.first
+        args = args.each_slice(2).to_a unless args.first.is_a?(Array)
+        retval = args.map(&:last).map { |member| !!zscore(key, member.to_s) }.count(false)
+        with_zset_at(key) do |z|
+          args.each { |score, member| z.add(score, member.to_s) }
+        end
+      end
 
-      retval = !zscore(key, member)
-      with_zset_at(key) {|z| z.add(score, member.to_s)}
       retval
     end
 
@@ -20,13 +42,11 @@ class MockRedis
     end
 
     def zcount(key, min, max)
-      assert_scorey(min, 'min or max')
-      assert_scorey(max, 'min or max')
+      assert_scorey(min, 'min or max') unless min == '-inf'
+      assert_scorey(max, 'min or max') unless max == '+inf'
 
-      with_zset_at(key) do |z|
-        z.count do |score, _|
-          score >= min && score <= max
-        end
+      with_zset_at(key) do |zset|
+        zset.in_range(min, max).size
       end
     end
 
@@ -37,7 +57,7 @@ class MockRedis
         old_score = z.include?(member) ? z.score(member) : 0
         new_score = old_score + increment
         z.add(new_score, member)
-        new_score.to_s
+        new_score.to_f
       end
     end
 
@@ -50,7 +70,7 @@ class MockRedis
 
     def zrange(key, start, stop, options={})
       with_zset_at(key) do |z|
-        to_response(z.sorted[start..stop] || [], options)
+        to_response(z.sorted[start.to_i..stop.to_i] || [], options)
       end
     end
 
@@ -65,8 +85,18 @@ class MockRedis
       with_zset_at(key) {|z| z.sorted_members.index(member.to_s) }
     end
 
-    def zrem(key, member)
-      with_zset_at(key) {|z| !!z.delete?(member.to_s)}
+    def zrem(key, *args)
+      if !args.first.is_a?(Array)
+        retval = with_zset_at(key) {|z| !!z.delete?(args.first.to_s)}
+      else
+        args = args.first
+        retval = args.map { |member| !!zscore(key, member.to_s) }.count(true)
+        with_zset_at(key) do |z|
+          args.each { |member| z.delete?(member) }
+        end
+      end
+
+      retval
     end
 
     def zrevrange(key, start, stop, options={})
@@ -104,7 +134,7 @@ class MockRedis
     def zscore(key, member)
       with_zset_at(key) do |z|
         score = z.score(member.to_s)
-        score.to_s if score
+        score.to_f if score
       end
     end
 
@@ -122,7 +152,7 @@ class MockRedis
           offset, count = limit
           collection.drop(offset).take(count)
         else
-          raise RuntimeError, "ERR syntax error"
+          raise Redis::CommandError, "ERR syntax error"
         end
       else
         collection
@@ -132,17 +162,17 @@ class MockRedis
     def to_response(score_member_pairs, options)
       score_member_pairs.map do |(score,member)|
         if options[:with_scores] || options[:withscores]
-          [member, score.to_s]
+          [member, score.to_f]
         else
           member
         end
-      end.flatten
+      end
     end
 
     def combine_weighted_zsets(keys, options, how)
       weights = options.fetch(:weights, keys.map { 1 })
       if weights.length != keys.length
-        raise RuntimeError, "ERR syntax error"
+        raise Redis::CommandError, "ERR syntax error"
       end
 
       aggregator = case options.fetch(:aggregate, :sum).to_s.downcase.to_sym
@@ -153,7 +183,7 @@ class MockRedis
                    when :max
                      proc {|a,b| [a,b].compact.max}
                    else
-                     raise RuntimeError, "ERR syntax error"
+                     raise Redis::CommandError, "ERR syntax error"
                    end
 
       with_zsets_at(*keys) do |*zsets|
@@ -190,7 +220,7 @@ class MockRedis
 
     def assert_zsety(key)
       unless zsety?(key)
-        raise RuntimeError,
+        raise Redis::CommandError,
         "ERR Operation against a key holding the wrong kind of value"
       end
     end
@@ -202,7 +232,7 @@ class MockRedis
 
     def assert_scorey(value, what='value')
       unless looks_like_float?(value)
-        raise RuntimeError, "ERR #{what} is not a double"
+        raise Redis::CommandError, "ERR #{what} is not a double"
       end
     end