ryansch-mock_redis 0.2.0.1

data/lib/mock_redis/exceptions.rb

@@ -0,0 +1,3 @@
+class MockRedis
+  WouldBlock = Class.new(StandardError)
+end

data/lib/mock_redis/expire_wrapper.rb

@@ -0,0 +1,25 @@
+require 'mock_redis/undef_redis_methods'
+
+class MockRedis
+  class ExpireWrapper
+    include UndefRedisMethods
+
+    def respond_to?(method, include_private=false)
+      super || @db.respond_to?(method)
+    end
+
+    def initialize(db)
+      @db = db
+    end
+
+    def method_missing(method, *args)
+      @db.expire_keys
+      @db.send(method, *args)
+    end
+
+    def initialize_copy(source)
+      super
+      @db = @db.clone
+    end
+  end
+end

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,86 @@
+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 move(key, db_index)
+      src = current_db
+      dest = db(db_index)
+
+      if !src.exists(key) || dest.exists(key)
+        false
+      else
+        case current_db.type(key)
+        when 'hash'
+          dest.hmset(key, *(src.hgetall(key).map{|k,v| [k,v]}.flatten))
+        when 'list'
+          while value = src.rpop(key)
+            dest.lpush(key, value)
+          end
+        when 'set'
+          while value = src.spop(key)
+            dest.sadd(key, value)
+          end
+        when 'string'
+          dest.set(key, src.get(key))
+        when 'zset'
+          src.zrange(key, 0, -1, :with_scores => true).each_slice(2) do |(m,s)|
+            dest.zadd(key, s, m)
+          end
+        else
+          raise ArgumentError,
+          "Can't move a key of type #{current_db.type(key).inspect}"
+        end
+
+        src.del(key)
+        true
+      end
+    end
+
+    def select(db_index)
+      @db_index = db_index.to_i
+      'OK'
+    end
+
+    private
+    def current_db
+      @databases[@db_index]
+    end
+
+    def db(index)
+      @databases[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.replace(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.replace(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.replace(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