mock_redis 0.0.1

data/lib/mock_redis/hash_methods.rb

@@ -0,0 +1,102 @@
+require 'mock_redis/assertions'
+require 'mock_redis/utility_methods'
+
+class MockRedis
+  module HashMethods
+    include Assertions
+    include UtilityMethods
+
+    def hdel(key, field)
+      with_hash_at(key) do |hash|
+        hash.delete(field) ? 1 : 0
+      end
+    end
+
+    def hexists(key, field)
+      with_hash_at(key) {|h| h.has_key?(field)}
+    end
+
+    def hget(key, field)
+      with_hash_at(key) {|h| h[field]}
+    end
+
+    def hgetall(key)
+      with_hash_at(key) {|h| h}
+    end
+
+    def hincrby(key, field, increment)
+      with_hash_at(key) do |hash|
+        unless can_incr?(data[key][field])
+          raise RuntimeError, "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"
+        end
+
+        new_value = (hash[field] || "0").to_i + increment.to_i
+        hash[field] = new_value.to_s
+        new_value
+      end
+    end
+
+    def hkeys(key)
+      with_hash_at(key, &:keys)
+    end
+
+    def hlen(key)
+      hkeys(key).length
+    end
+
+    def hmget(key, *fields)
+      assert_has_args(fields, 'hmget')
+      fields.map{|f| hget(key, f)}
+    end
+
+    def hmset(key, *kvpairs)
+      assert_has_args(kvpairs, 'hmset')
+      if kvpairs.length.odd?
+        raise RuntimeError, "ERR wrong number of arguments for HMSET"
+      end
+
+      kvpairs.each_slice(2) do |(k,v)|
+        hset(key, k, v)
+      end
+      'OK'
+    end
+
+    def hset(key, field, value)
+      with_hash_at(key) {|h| h[field] = value.to_s}
+      true
+    end
+
+    def hsetnx(key, field, value)
+      if hget(key, field)
+        false
+      else
+        hset(key, field, value)
+        true
+      end
+    end
+
+    def hvals(key)
+      with_hash_at(key, &:values)
+    end
+
+    private
+
+    def with_hash_at(key, &blk)
+      with_thing_at(key, :assert_hashy, proc {{}}, &blk)
+    end
+
+    def hashy?(key)
+      data[key].nil? || data[key].kind_of?(Hash)
+    end
+
+    def assert_hashy(key)
+      unless hashy?(key)
+        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
+      end
+    end
+
+  end
+end

data/lib/mock_redis/list_methods.rb

@@ -0,0 +1,187 @@
+require 'mock_redis/assertions'
+require 'mock_redis/utility_methods'
+
+class MockRedis
+  module ListMethods
+    include Assertions
+    include UtilityMethods
+
+    def blpop(*args)
+      lists, timeout = extract_timeout(args)
+      nonempty_list = first_nonempty_list(lists)
+
+      if nonempty_list
+        [nonempty_list, lpop(nonempty_list)]
+      elsif timeout > 0
+        nil
+      else
+        raise MockRedis::WouldBlock, "Can't block forever"
+      end
+    end
+
+    def brpop(*args)
+      lists, timeout = extract_timeout(args)
+      nonempty_list = first_nonempty_list(lists)
+
+      if nonempty_list
+        [nonempty_list, rpop(nonempty_list)]
+      elsif timeout > 0
+        nil
+      else
+        raise MockRedis::WouldBlock, "Can't block forever"
+      end
+    end
+
+    def brpoplpush(source, destination, timeout)
+      assert_valid_timeout(timeout)
+
+      if llen(source) > 0
+        rpoplpush(source, destination)
+      elsif timeout > 0
+        nil
+      else
+        raise MockRedis::WouldBlock, "Can't block forever"
+      end
+    end
+
+    def lindex(key, index)
+      with_list_at(key) {|l| l[index]}
+    end
+
+    def linsert(key, position, pivot, value)
+      unless %w[before after].include?(position.to_s)
+        raise RuntimeError, "ERR syntax error"
+      end
+
+      assert_listy(key)
+      return 0 unless data[key]
+
+      pivot_position = (0..llen(key) - 1).find do |i|
+        data[key][i] == pivot.to_s
+      end
+
+      return -1 unless pivot_position
+
+      insertion_index = if position.to_s == 'before'
+                          pivot_position
+                        else
+                          pivot_position + 1
+                        end
+
+      data[key].insert(insertion_index, value.to_s)
+      llen(key)
+    end
+
+    def llen(key)
+      with_list_at(key, &:length)
+    end
+
+    def lpop(key)
+      with_list_at(key, &:shift)
+    end
+
+    def lpush(key, value)
+      with_list_at(key) {|l| l.unshift(value.to_s)}
+      llen(key)
+    end
+
+    def lpushx(key, value)
+      assert_listy(key)
+      return 0 unless list_at?(key)
+      lpush(key, value)
+    end
+
+    def lrange(key, start, stop)
+      with_list_at(key) {|l| l[start..stop]}
+    end
+
+    def lrem(key, count, value)
+      count = count.to_i
+      value = value.to_s
+
+      with_list_at(key) do |list|
+        indices_with_value = (0..(llen(key) - 1)).find_all do |i|
+          list[i] == value
+        end
+
+        indices_to_delete = if count == 0
+                              indices_with_value.reverse
+                            elsif count > 0
+                              indices_with_value.take(count).reverse
+                            else
+                              indices_with_value.reverse.take(-count)
+                            end
+
+        indices_to_delete.each {|i| list.delete_at(i)}.length
+      end
+    end
+
+    def lset(key, index, value)
+      assert_listy(key)
+
+      unless list_at?(key)
+        raise RuntimeError, "ERR no such key"
+      end
+
+      unless (0...llen(key)).include?(index)
+        raise RuntimeError, "ERR index out of range"
+      end
+
+      data[key][index] = value.to_s
+      'OK'
+    end
+
+    def ltrim(key, start, stop)
+      with_list_at(key) do |list|
+        list.replace(list[start..stop] || []) if list
+        'OK'
+      end
+    end
+
+    def rpop(key)
+      with_list_at(key) {|list| list.pop if list}
+    end
+
+    def rpoplpush(source, destination)
+      value = rpop(source)
+      lpush(destination, value)
+      value
+    end
+
+    def rpush(key, value)
+      with_list_at(key) {|l| l.push(value.to_s)}
+      llen(key)
+    end
+
+    def rpushx(key, value)
+      assert_listy(key)
+      return 0 unless list_at?(key)
+      rpush(key, value)
+    end
+
+    private
+    def list_at?(key)
+      data[key] && listy?(key)
+    end
+
+    def with_list_at(key, &blk)
+      with_thing_at(key, :assert_listy, proc {[]}, &blk)
+    end
+
+    def listy?(key)
+      data[key].nil? || data[key].kind_of?(Array)
+    end
+
+    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"
+      end
+    end
+
+    def first_nonempty_list(keys)
+      keys.find{|k| llen(k) > 0}
+    end
+
+  end
+end

data/lib/mock_redis/multi_db_wrapper.rb

@@ -0,0 +1,48 @@
+require 'mock_redis/undef_redis_methods'
+
+class MockRedis
+  class MultiDbWrapper
+    include UndefRedisMethods
+
+    def initialize(db)
+      @db_index = 0
+
+      @prototype_db = db.clone
+
+      @databases = Hash.new {|h,k| h[k] = @prototype_db.clone}
+      @databases[@db_index] = db
+    end
+
+    def respond_to?(method, include_private=false)
+      super || current_db.respond_to?(method, include_private)
+    end
+
+    def method_missing(method, *args)
+      current_db.send(method, *args)
+    end
+
+    def initialize_copy(source)
+      super
+      @databases = @databases.clone
+      @databases.keys.each do |k|
+        @databases[k] = @databases[k].clone
+      end
+    end
+
+    # Redis commands
+    def flushall
+      @databases.values.each(&:flushdb)
+      'OK'
+    end
+
+    def select(db_index)
+      @db_index = db_index.to_i
+      'OK'
+    end
+
+    private
+    def current_db
+      @databases[@db_index]
+    end
+  end
+end

data/lib/mock_redis/set_methods.rb

@@ -0,0 +1,125 @@
+require 'mock_redis/assertions'
+require 'mock_redis/utility_methods'
+
+class MockRedis
+  module SetMethods
+    include Assertions
+    include UtilityMethods
+
+    def sadd(key, member)
+      with_set_at(key) {|s| !!s.add?(member.to_s)}
+    end
+
+    def scard(key)
+      with_set_at(key) {|s| s.length}
+    end
+
+    def sdiff(*keys)
+      assert_has_args(keys, 'sdiff')
+      with_sets_at(*keys) {|*sets| sets.reduce(&:-)}.to_a
+    end
+
+    def sdiffstore(destination, *keys)
+      assert_has_args(keys, 'sdiffstore')
+      with_set_at(destination) do |set|
+        set.merge(sdiff(*keys))
+      end
+      scard(destination)
+    end
+
+    def sinter(*keys)
+      assert_has_args(keys, 'sinter')
+
+      with_sets_at(*keys) do |*sets|
+        sets.reduce(&:&).to_a
+      end
+    end
+
+    def sinterstore(destination, *keys)
+      assert_has_args(keys, 'sinterstore')
+      with_set_at(destination) do |set|
+        set.merge(sinter(*keys))
+      end
+      scard(destination)
+    end
+
+    def sismember(key, member)
+      with_set_at(key) {|s| s.include?(member.to_s)}
+    end
+
+    def smembers(key)
+      with_set_at(key, &:to_a)
+    end
+
+    def smove(src, dest, member)
+      member = member.to_s
+
+      with_sets_at(src, dest) do |src_set, dest_set|
+        if src_set.delete?(member)
+          dest_set.add(member)
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def spop(key)
+      with_set_at(key) do |set|
+        member = set.first
+        set.delete(member)
+        member
+      end
+    end
+
+    def srandmember(key)
+      with_set_at(key, &:first)
+    end
+
+    def srem(key, member)
+      with_set_at(key) {|s| !!s.delete?(member.to_s)}
+    end
+
+    def sunion(*keys)
+      assert_has_args(keys, 'sunion')
+      with_sets_at(*keys) {|*sets| sets.reduce(&:+).to_a}
+    end
+
+    def sunionstore(destination, *keys)
+      assert_has_args(keys, 'sunionstore')
+      with_set_at(destination) do |dest_set|
+        dest_set.merge(sunion(*keys))
+      end
+      scard(destination)
+    end
+
+    private
+    def with_set_at(key, &blk)
+      with_thing_at(key, :assert_sety, proc {Set.new}, &blk)
+    end
+
+    def with_sets_at(*keys, &blk)
+      if keys.length == 1
+        with_set_at(keys.first, &blk)
+      else
+        with_set_at(keys.first) do |set|
+          with_sets_at(*(keys[1..-1])) do |*sets|
+            blk.call(*([set] + sets))
+          end
+        end
+      end
+    end
+
+    def sety?(key)
+      data[key].nil? || data[key].kind_of?(Set)
+    end
+
+    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"
+      end
+    end
+
+  end
+end

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