ryansch-mock_redis 0.2.0.1

data/lib/mock_redis/string_methods.rb

@@ -0,0 +1,195 @@
+require 'mock_redis/assertions'
+
+class MockRedis
+  module StringMethods
+    include Assertions
+
+    def append(key, value)
+      assert_stringy(key)
+      data[key] ||= ""
+      data[key] << value
+      data[key].length
+    end
+
+    def decr(key)
+      decrby(key, 1)
+    end
+
+    def decrby(key, n)
+      incrby(key, -n)
+    end
+
+    def get(key)
+      assert_stringy(key)
+      data[key]
+    end
+
+    def getbit(key, offset)
+      assert_stringy(key)
+
+      offset_of_byte = offset / 8
+      offset_within_byte = offset % 8
+
+      # String#getbyte would be lovely, but it's not in 1.8.7.
+      byte = (data[key] || "").each_byte.drop(offset_of_byte).first
+
+      if byte
+        (byte & (2**7 >> offset_within_byte)) > 0 ? 1 : 0
+      else
+        0
+      end
+    end
+
+    def getrange(key, start, stop)
+      assert_stringy(key)
+      (data[key] || "")[start..stop]
+    end
+
+    def getset(key, value)
+      retval = get(key)
+      set(key, value)
+      retval
+    end
+
+    def incr(key)
+      incrby(key, 1)
+    end
+
+    def incrby(key, n)
+      assert_stringy(key)
+      unless can_incr?(data[key])
+        raise RuntimeError, "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"
+      end
+
+      new_value = data[key].to_i + n.to_i
+      data[key] = new_value.to_s
+      # for some reason, redis-rb doesn't return this as a string.
+      new_value
+    end
+
+    def mget(*keys)
+      assert_has_args(keys, 'mget')
+
+      keys.map do |key|
+        get(key) if stringy?(key)
+      end
+    end
+
+    def mset(*kvpairs)
+      assert_has_args(kvpairs, 'mset')
+      if kvpairs.length.odd?
+        raise RuntimeError, "ERR wrong number of arguments for MSET"
+      end
+
+      kvpairs.each_slice(2) do |(k,v)|
+        set(k,v)
+      end
+
+      "OK"
+    end
+
+    def msetnx(*kvpairs)
+      assert_has_args(kvpairs, 'msetnx')
+
+      if kvpairs.each_slice(2).any? {|(k,v)| exists(k)}
+        0
+      else
+        mset(*kvpairs)
+        1
+      end
+    end
+
+    def set(key, value)
+      data[key] = value.to_s
+      'OK'
+    end
+
+    def setbit(key, offset, value)
+      assert_stringy(key, "ERR bit is not an integer or out of range")
+      retval = getbit(key, offset)
+
+      str = data[key] || ""
+
+      offset_of_byte = offset / 8
+      offset_within_byte = offset % 8
+
+      if offset_of_byte >= str.bytesize
+        str = zero_pad(str, offset_of_byte+1)
+      end
+
+      char_index = byte_index = offset_within_char = 0
+      str.each_char do |c|
+        if byte_index < offset_of_byte
+          char_index += 1
+          byte_index += c.bytesize
+        else
+          offset_within_char = byte_index - offset_of_byte
+          break
+        end
+      end
+
+      char = str[char_index]
+      char = char.chr if char.respond_to?(:chr)  # ruby 1.8 vs 1.9
+      char_as_number = char.each_byte.reduce(0) do |a, byte|
+        (a << 8) + byte
+      end
+      char_as_number |=
+        (2**((char.bytesize * 8)-1) >>
+        (offset_within_char * 8 + offset_within_byte))
+      str[char_index] = char_as_number.chr
+
+      data[key] = str
+      retval
+    end
+
+    def setex(key, seconds, value)
+      set(key, value)
+      expire(key, seconds)
+      'OK'
+    end
+
+    def setnx(key, value)
+      if exists(key)
+        false
+      else
+        set(key, value)
+        true
+      end
+    end
+
+    def setrange(key, offset, value)
+      assert_stringy(key)
+      value = value.to_s
+      old_value = (data[key] || "")
+
+      prefix = zero_pad(old_value[0...offset], offset)
+      data[key] = prefix + value + (old_value[(offset + value.length)..-1] || "")
+      data[key].length
+    end
+
+    def strlen(key)
+      assert_stringy(key)
+      (data[key] || "").bytesize
+    end
+
+
+
+
+    private
+    def stringy?(key)
+      data[key].nil? || data[key].kind_of?(String)
+    end
+
+    def assert_stringy(key,
+        message="ERR Operation against a key holding the wrong kind of value")
+      unless stringy?(key)
+        raise RuntimeError, message
+      end
+    end
+
+  end
+end

data/lib/mock_redis/transaction_wrapper.rb

@@ -0,0 +1,80 @@
+require 'mock_redis/undef_redis_methods'
+
+class MockRedis
+  class TransactionWrapper
+    include UndefRedisMethods
+
+    def respond_to?(method, include_private=false)
+      super || @db.respond_to?(method)
+    end
+
+    def initialize(db)
+      @db = db
+      @queued_commands = []
+      @in_multi = false
+    end
+
+    def method_missing(method, *args)
+      if @in_multi
+        @queued_commands << [method, *args]
+        'QUEUED'
+      else
+        @db.expire_keys
+        @db.send(method, *args)
+      end
+    end
+
+    def initialize_copy(source)
+      super
+      @db = @db.clone
+      @queued_commands = @queued_commands.clone
+    end
+
+    def discard
+      unless @in_multi
+        raise RuntimeError, "ERR DISCARD without MULTI"
+      end
+      @in_multi = false
+      @queued_commands = []
+      'OK'
+    end
+
+    def exec
+      unless @in_multi
+        raise RuntimeError, "ERR EXEC without MULTI"
+      end
+      @in_multi = false
+      responses = @queued_commands.map do |cmd|
+        begin
+          send(*cmd)
+        rescue => e
+          e
+        end
+      end
+      @queued_commands = []
+      responses
+    end
+
+    def multi
+      if @in_multi
+        raise RuntimeError, "ERR MULTI calls can not be nested"
+      end
+      @in_multi = true
+      if block_given?
+        yield(self)
+        self.exec
+      else
+        'OK'
+      end
+    end
+
+    def unwatch
+      'OK'
+    end
+
+    def watch(_)
+      'OK'
+    end
+
+  end
+end

data/lib/mock_redis/undef_redis_methods.rb

@@ -0,0 +1,11 @@
+class MockRedis
+  module UndefRedisMethods
+    def self.included(klass)
+      if klass.instance_methods.map(&:to_s).include?('type')
+        klass.send(:undef_method, 'type')
+      end
+      klass.send(:undef_method, 'exec')
+      klass.send(:undef_method, 'select')
+    end
+  end
+end

data/lib/mock_redis/utility_methods.rb

@@ -0,0 +1,22 @@
+class MockRedis
+  module UtilityMethods
+    private
+
+    def with_thing_at(key, assertion, empty_thing_generator)
+      begin
+        send(assertion, key)
+        data[key] ||= empty_thing_generator.call
+        yield data[key]
+      ensure
+        clean_up_empties_at(key)
+      end
+    end
+
+    def clean_up_empties_at(key)
+      if data[key] && data[key].empty?
+        del(key)
+      end
+    end
+
+  end
+end

data/lib/mock_redis/version.rb

@@ -0,0 +1,3 @@
+class MockRedis
+  VERSION = "0.2.0.1"
+end

data/lib/mock_redis/zset.rb

@@ -0,0 +1,110 @@
+require 'forwardable'
+require 'set'
+
+class MockRedis
+  class Zset
+    include Enumerable
+    extend Forwardable
+
+    attr_reader :members, :scores
+
+    def_delegators :members, :empty?, :include?, :size
+
+    def initialize
+      @members = Set.new
+      @scores  = Hash.new
+    end
+
+    def initialize_copy(source)
+      super
+      @members = @members.clone
+      @scores  = @scores.clone
+    end
+
+    def add(score, member)
+      members.add(member)
+      if score.to_f.to_i == score.to_f
+        scores[member] = score.to_f.to_i
+      else
+        scores[member] = score.to_f
+      end
+      self
+    end
+
+    def delete?(member)
+      scores.delete(member)
+      members.delete?(member) and self
+    end
+
+    def each
+      members.each {|m| yield score(m), m}
+    end
+
+    def in_range(min, max)
+      in_from_the_left = case min
+                         when "-inf"
+                             lambda {|_| true }
+                         when "+inf"
+                             lambda {|_| false }
+                         when /\((.*)$/
+                             val = $1.to_f
+                           lambda {|x| x.to_f > val }
+                         else
+                           lambda {|x| x.to_f >= min.to_f }
+                         end
+
+      in_from_the_right = case max
+                          when "-inf"
+                              lambda {|_| false }
+                          when "+inf"
+                              lambda {|_| true }
+                          when /\((.*)$/
+                              val = $1.to_f
+                            lambda {|x| x.to_f < val }
+                          else
+                            lambda {|x| x.to_f <= max.to_f }
+                          end
+
+      sorted.find_all do |(score, member)|
+        in_from_the_left[score] && in_from_the_right[score]
+      end
+    end
+
+    def intersection(other)
+      if !block_given?
+        intersection(other, &:+)
+      else
+        self.members.intersection(other.members).reduce(self.class.new) do |acc, m|
+          new_score = yield(self.score(m), other.score(m))
+          acc.add(new_score, m)
+        end
+      end
+    end
+
+    def score(member)
+      scores[member]
+    end
+
+    def sorted
+      members.map do |m|
+        [score(m), m]
+      end.sort_by(&:first)
+    end
+
+    def sorted_members
+      sorted.map(&:last)
+    end
+
+    def union(other)
+      if !block_given?
+        union(other, &:+)
+      else
+        self.members.union(other.members).reduce(self.class.new) do |acc, m|
+          new_score = yield(self.score(m), other.score(m))
+          acc.add(new_score, m)
+        end
+      end
+    end
+
+  end
+end

data/lib/mock_redis/zset_methods.rb

@@ -0,0 +1,209 @@
+require 'mock_redis/assertions'
+require 'mock_redis/utility_methods'
+require 'mock_redis/zset'
+
+class MockRedis
+  module ZsetMethods
+    include Assertions
+    include UtilityMethods
+
+    def zadd(key, score, member)
+      assert_scorey(score)
+
+      retval = !zscore(key, member)
+      with_zset_at(key) {|z| z.add(score, member)}
+      retval
+    end
+
+    def zcard(key)
+      with_zset_at(key, &:size)
+    end
+
+    def zcount(key, min, max)
+      assert_scorey(min, 'min or max')
+      assert_scorey(max, 'min or max')
+
+      with_zset_at(key) do |z|
+        z.count do |score, _|
+          score >= min && score <= max
+        end
+      end
+    end
+
+    def zincrby(key, increment, member)
+      assert_scorey(increment)
+      with_zset_at(key) do |z|
+        old_score = z.include?(member) ? z.score(member) : 0
+        new_score = old_score + increment
+        z.add(new_score, member)
+        new_score.to_s
+      end
+    end
+
+    def zinterstore(destination, keys, options={})
+      assert_has_args(keys, 'zinterstore')
+
+      data[destination] = combine_weighted_zsets(keys, options, :intersection)
+      zcard(destination)
+    end
+
+    def zrange(key, start, stop, options={})
+      with_zset_at(key) do |z|
+        to_response(z.sorted[start..stop], options)
+      end
+    end
+
+    def zrangebyscore(key, min, max, options={})
+      with_zset_at(key) do |zset|
+        all_results = zset.in_range(min, max)
+        to_response(apply_limit(all_results, options[:limit]), options)
+      end
+    end
+
+    def zrank(key, member)
+      with_zset_at(key) {|z| z.sorted_members.index(member) }
+    end
+
+    def zrem(key, member)
+      with_zset_at(key) {|z| !!z.delete?(member)}
+    end
+
+    def zrevrange(key, start, stop, options={})
+      with_zset_at(key) do |z|
+        to_response(z.sorted.reverse[start..stop], options)
+      end
+    end
+
+    def zremrangebyrank(key, start, stop)
+      zrange(key, start, stop).
+        each {|member| zrem(key, member)}.
+        size
+    end
+
+    def zremrangebyscore(key, min, max)
+      zrangebyscore(key, min, max).
+        each {|member| zrem(key, member)}.
+        size
+    end
+
+    def zrevrangebyscore(key, max, min, options={})
+      with_zset_at(key) do |zset|
+        to_response(
+          apply_limit(
+            zset.in_range(min, max).reverse,
+            options[:limit]),
+          options)
+      end
+    end
+
+    def zrevrank(key, member)
+      with_zset_at(key) {|z| z.sorted_members.reverse.index(member) }
+    end
+
+    def zscore(key, member)
+      with_zset_at(key) do |z|
+        score = z.score(member)
+        score.to_s if score
+      end
+    end
+
+    def zunionstore(destination, keys, options={})
+      assert_has_args(keys, 'zunionstore')
+
+      data[destination] = combine_weighted_zsets(keys, options, :union)
+      zcard(destination)
+    end
+
+    private
+    def apply_limit(collection, limit)
+      if limit
+        if limit.is_a?(Array) && limit.length == 2
+          offset, count = limit
+          collection.drop(offset).take(count)
+        else
+          raise RuntimeError, "ERR syntax error"
+        end
+      else
+        collection
+      end
+    end
+
+    def to_response(score_member_pairs, options)
+      score_member_pairs.map do |(score,member)|
+        if options[:with_scores] || options[:withscores]
+          [member, score.to_s]
+        else
+          member
+        end
+      end.flatten
+    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"
+      end
+
+      aggregator = case options.fetch(:aggregate, :sum).to_s.downcase.to_sym
+                   when :sum
+                     proc {|a,b| [a,b].compact.reduce(&:+)}
+                   when :min
+                     proc {|a,b| [a,b].compact.min}
+                   when :max
+                     proc {|a,b| [a,b].compact.max}
+                   else
+                     raise RuntimeError, "ERR syntax error"
+                   end
+
+      with_zsets_at(*keys) do |*zsets|
+        zsets.zip(weights).map do |(zset, weight)|
+          zset.reduce(Zset.new) do |acc, (score, member)|
+            acc.add(score * weight, member)
+          end
+        end.reduce do |za, zb|
+          za.send(how, zb, &aggregator)
+        end
+      end
+
+    end
+
+    def with_zset_at(key, &blk)
+      with_thing_at(key, :assert_zsety, proc {Zset.new}, &blk)
+    end
+
+    def with_zsets_at(*keys, &blk)
+      if keys.length == 1
+        with_zset_at(keys.first, &blk)
+      else
+        with_zset_at(keys.first) do |set|
+          with_zsets_at(*(keys[1..-1])) do |*sets|
+            blk.call(*([set] + sets))
+          end
+        end
+      end
+    end
+
+    def zsety?(key)
+      data[key].nil? || data[key].kind_of?(Zset)
+    end
+
+    def assert_zsety(key)
+      unless zsety?(key)
+        raise RuntimeError,
+        "ERR Operation against a key holding the wrong kind of value"
+      end
+    end
+
+    def looks_like_float?(x)
+      # ugh, exceptions for flow control.
+      !!Float(x) rescue false
+    end
+
+    def assert_scorey(value, what='value')
+      unless looks_like_float?(value)
+        raise RuntimeError, "ERR #{what} is not a double"
+      end
+    end
+
+  end
+end