mock_redis 0.0.1

data/lib/mock_redis/transaction_wrapper.rb

@@ -0,0 +1,75 @@
+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
+      'OK'
+    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.0.1"
+end

data/lib/mock_redis/zset.rb

@@ -0,0 +1,80 @@
+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 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,210 @@
+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|
+        in_range = zset.sorted.find_all do |(score, member)|
+          min <= score && score <= max
+        end
+        to_response(apply_limit(in_range, 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|
+        in_range = zset.sorted.reverse.find_all do |(score, member)|
+          min <= score && score <= max
+        end
+        to_response(apply_limit(in_range, 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

data/lib/mock_redis.rb

@@ -0,0 +1,32 @@
+require 'set'
+
+require 'mock_redis/assertions'
+require 'mock_redis/database'
+require 'mock_redis/expire_wrapper'
+require 'mock_redis/multi_db_wrapper'
+require 'mock_redis/transaction_wrapper'
+require 'mock_redis/undef_redis_methods'
+
+class MockRedis
+  include UndefRedisMethods
+
+  def initialize(*args)
+    @db = TransactionWrapper.new(
+      ExpireWrapper.new(
+        MultiDbWrapper.new(
+          Database.new(*args))))
+  end
+
+  def respond_to?(method, include_private=false)
+    super || @db.respond_to?(method, include_private)
+  end
+
+  def method_missing(method, *args)
+    @db.send(method, *args)
+  end
+
+  def initialize_copy(source)
+    super
+    @db = @db.clone
+  end
+end

data/mock_redis.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mock_redis/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mock_redis"
+  s.version     = MockRedis::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Samuel Merritt"]
+  s.email       = ["spam@andcheese.org"]
+  s.homepage    = "https://github.com/smerritt/mock_redis"
+  s.summary     = %q{Redis mock that just lives in memory; useful for testing.}
+
+  s.description = %q{Instantiate one with `redis = MockRedis.new` and treat it like you would a normal Redis object. It supports all the usual Redis operations.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "redis", "~> 2.2.1"
+  s.add_development_dependency "rspec", "~> 2.6.0"
+  s.add_development_dependency "ZenTest"
+end

data/spec/cloning_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe "MockRedis#clone" do
+  before do
+    @mock = MockRedis.new
+  end
+
+  context "the stored data" do
+    before do
+      @mock.set('foo', 'bar')
+      @mock.hset('foohash', 'bar', 'baz')
+      @mock.lpush('foolist', 'bar')
+      @mock.sadd('fooset', 'bar')
+      @mock.zadd('foozset', 1, 'bar')
+
+      @clone = @mock.clone
+    end
+
+    it "copies the stored data to the clone" do
+      @clone.get('foo').should == 'bar'
+    end
+
+    it "performs a deep copy (string values)" do
+      @mock.del('foo')
+      @clone.get('foo').should == 'bar'
+    end
+
+    it "performs a deep copy (list values)" do
+      @mock.lpop('foolist')
+      @clone.lrange('foolist', 0, 1).should == ['bar']
+    end
+
+    it "performs a deep copy (hash values)" do
+      @mock.hset('foohash', 'bar', 'quux')
+      @clone.hgetall('foohash').should == {'bar' => 'baz'}
+    end
+
+    it "performs a deep copy (set values)" do
+      @mock.srem('fooset', 'bar')
+      @clone.smembers('fooset').should == ['bar']
+    end
+
+    it "performs a deep copy (zset values)" do
+      @mock.zadd('foozset', 2, 'bar')
+      @clone.zscore('foozset', 'bar').should == "1"
+    end
+  end
+
+  context "expiration times" do
+    before do
+      @mock.set('foo', 1)
+      @mock.expire('foo', 60026)
+
+      @clone = @mock.clone
+    end
+
+    it "copies the expiration times" do
+      @clone.ttl('foo').should > 0
+    end
+
+    it "deep-copies the expiration times" do
+      @mock.persist('foo')
+      @clone.ttl('foo').should > 0
+    end
+
+    it "deep-copies the expiration times" do
+      @clone.persist('foo')
+      @mock.ttl('foo').should > 0
+    end
+  end
+
+  context "transactional info" do
+    before do
+      @mock.multi
+      @mock.incr('foo')
+      @mock.incrby('foo', 2)
+      @mock.incrby('foo', 4)
+
+      @clone = @mock.clone
+    end
+
+    it "makes sure the clone is in a transaction" do
+      lambda do
+        @clone.exec
+      end.should_not raise_error
+    end
+
+    it "deep-copies the queued commands" do
+      @clone.incrby('foo', 8)
+      @clone.exec.should == [1, 3, 7, 15]
+
+      @mock.exec.should == [1, 3, 7]
+    end
+  end
+
+end

data/spec/commands/append_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe '#append(key, value)' do
+  before { @key = 'mock-redis-test:append' }
+
+  it "returns the new length of the string" do
+    @redises.set(@key, 'porkchop')
+    @redises.append(@key, 'sandwiches').should == 18
+  end
+
+  it "appends value to the previously-stored value" do
+    @redises.set(@key, 'porkchop')
+    @redises.append(@key, 'sandwiches')
+
+    @redises.get(@key).should == 'porkchopsandwiches'
+  end
+
+  it "treats a missing key as an empty string" do
+    @redises.append(@key, 'foo')
+    @redises.get(@key).should == 'foo'
+  end
+
+  it_should_behave_like "a string-only command"
+end

data/spec/commands/auth_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "#auth(password) [mock only]" do
+  it "just returns 'OK'" do
+    @redises.mock.auth('foo').should == 'OK'
+  end
+end

data/spec/commands/bgrewriteaof_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "#bgrewriteaof [mock only]" do
+  it "just returns a canned string" do
+    @redises.mock.bgrewriteaof.should =~ /append/
+  end
+end

data/spec/commands/bgsave_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "#bgsave [mock only]" do
+  it "just returns a canned string" do
+    @redises.mock.bgsave.should =~ /saving/
+  end
+end

data/spec/commands/blpop_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe '#blpop(key [, key, ...,], timeout)' do
+  before do
+    @list1 = 'mock-redis-test:blpop1'
+    @list2 = 'mock-redis-test:blpop2'
+
+    @redises.rpush(@list1, 'one')
+    @redises.rpush(@list1, 'two')
+    @redises.rpush(@list2, 'ten')
+    @redises.rpush(@list2, 'eleven')
+  end
+
+  it "returns [first-nonempty-list, popped-value]" do
+    @redises.blpop(@list1, @list2, 1).should == [@list1, 'one']
+  end
+
+  it "pops that value off the list" do
+    @redises.blpop(@list1, @list2, 1)
+    @redises.blpop(@list1, @list2, 1)
+
+    @redises.blpop(@list1, @list2, 1).should == [@list2, 'ten']
+  end
+
+  it "ignores empty keys" do
+    @redises.blpop('mock-redis-test:not-here', @list1, 1).should ==
+      [@list1, 'one']
+  end
+
+  it "raises an error on non-integer timeout" do
+    lambda do
+      @redises.blpop(@list1, @list2, 0.5)
+    end.should raise_error(RuntimeError)
+  end
+
+  it "raises an error on negative timeout" do
+    lambda do
+      @redises.blpop(@list1, @list2, -1)
+    end.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like "a list-only command"
+
+  context "[mock only]" do
+    it "ignores positive timeouts and returns nil" do
+      @redises.mock.blpop('mock-redis-test:not-here', 1).should be_nil
+    end
+
+    it "raises WouldBlock on zero timeout (no blocking in the mock)" do
+      lambda do
+        @redises.mock.blpop('mock-redis-test:not-here', 0)
+      end.should raise_error(MockRedis::WouldBlock)
+    end
+  end
+end