ryansch-mock_redis 0.2.0.1

data/spec/commands/zrevrank_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "#zrevrank(key, member)" do
+  before do
+    @key = 'mock-redis-test:zrevrank'
+
+    @redises.zadd(@key, 1, 'one')
+    @redises.zadd(@key, 2, 'two')
+    @redises.zadd(@key, 3, 'three')
+  end
+
+  it "returns nil if member wasn't present in the set" do
+    @redises.zrevrank(@key, 'foo').should be_nil
+  end
+
+  it "returns the index of the member in the set (ordered by -score)" do
+    @redises.zrevrank(@key, 'one').should == 2
+    @redises.zrevrank(@key, 'two').should == 1
+    @redises.zrevrank(@key, 'three').should == 0
+  end
+
+  it_should_behave_like "a zset-only command"
+end

data/spec/commands/zscore_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "#zscore(key, member)" do
+  before { @key = 'mock-redis-test:zscore' }
+
+  it "returns the score as a string" do
+    @redises.zadd(@key, 0.25, 'foo').should be_true
+    @redises.zscore(@key, 'foo').should == "0.25"
+  end
+
+  it "returns nil if member is not present in the set" do
+    @redises.zscore(@key, 'foo').should be_nil
+  end
+
+  it_should_behave_like "a zset-only command"
+end

data/spec/commands/zunionstore_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe "#zunionstore(destination, keys, [:weights => [w,w,], [:aggregate => :sum|:min|:max])" do
+  before do
+    @set1 = 'mock-redis-test:zunionstore1'
+    @set2 = 'mock-redis-test:zunionstore2'
+    @set3 = 'mock-redis-test:zunionstore3'
+    @dest = 'mock-redis-test:zunionstoredest'
+
+    @redises.zadd(@set1, 1, 'one')
+
+    @redises.zadd(@set2, 1, 'one')
+    @redises.zadd(@set2, 2, 'two')
+
+    @redises.zadd(@set3, 1, 'one')
+    @redises.zadd(@set3, 2, 'two')
+    @redises.zadd(@set3, 3, 'three')
+  end
+
+  it "returns the number of elements in the new set" do
+    @redises.zunionstore(@dest, [@set1, @set2, @set3]).should == 3
+  end
+
+  it "sums the members' scores by default" do
+    @redises.zunionstore(@dest, [@set1, @set2, @set3])
+    @redises.zrange(@dest, 0, -1, :with_scores => true).should ==
+      %w[one 3 three 3 two 4]
+  end
+
+  it "removes existing elements in destination" do
+    @redises.zadd(@dest, 10, 'ten')
+
+    @redises.zunionstore(@dest, [@set1])
+    @redises.zrange(@dest, 0, -1, :with_scores => true).should ==
+      %w[one 1]
+  end
+
+  it "raises an error if keys is empty" do
+    lambda do
+      @redises.zunionstore(@dest, [])
+    end.should raise_error(RuntimeError)
+  end
+
+  context "the :weights argument" do
+    it "multiplies the scores by the weights while aggregating" do
+      @redises.zunionstore(@dest, [@set1, @set2, @set3], :weights => [2, 3, 5])
+      @redises.zrange(@dest, 0, -1, :with_scores => true).should ==
+        %w[one 10 three 15 two 16]
+    end
+
+    it "raises an error if the number of weights != the number of keys" do
+      lambda do
+        @redises.zunionstore(@dest, [@set1, @set2, @set3], :weights => [1,2])
+      end.should raise_error(RuntimeError)
+    end
+  end
+
+  context "the :aggregate argument" do
+    before do
+      @smalls = 'mock-redis-test:zunionstore:smalls'
+      @bigs   = 'mock-redis-test:zunionstore:bigs'
+
+      @redises.zadd(@smalls, 1, 'bert')
+      @redises.zadd(@smalls, 2, 'ernie')
+      @redises.zadd(@bigs, 100, 'bert')
+      @redises.zadd(@bigs, 200, 'ernie')
+    end
+
+    it "aggregates scores with min when :aggregate => :min is specified" do
+      @redises.zunionstore(@dest, [@bigs, @smalls], :aggregate => :min)
+      @redises.zrange(@dest, 0, -1, :with_scores => true).should ==
+        %w[bert 1 ernie 2]
+    end
+
+    it "aggregates scores with max when :aggregate => :max is specified" do
+      @redises.zunionstore(@dest, [@bigs, @smalls], :aggregate => :max)
+      @redises.zrange(@dest, 0, -1, :with_scores => true).should ==
+        %w[bert 100 ernie 200]
+    end
+
+    it "ignores scores for missing members" do
+      @redises.zadd(@smalls, 3, 'grover')
+      @redises.zunionstore(@dest, [@bigs, @smalls], :aggregate => :min)
+      @redises.zscore(@dest, 'grover').should == '3'
+
+      @redises.zunionstore(@dest, [@bigs, @smalls], :aggregate => :max)
+      @redises.zscore(@dest, 'grover').should == '3'
+    end
+
+    it "allows 'min', 'MIN', etc. as aliases for :min" do
+      @redises.zunionstore(@dest, [@bigs, @smalls], :aggregate => 'min')
+      @redises.zscore(@dest, 'bert').should == '1'
+
+      @redises.zunionstore(@dest, [@bigs, @smalls], :aggregate => 'MIN')
+      @redises.zscore(@dest, 'bert').should == '1'
+    end
+
+    it "raises an error for unknown aggregation function" do
+      lambda do
+        @redises.zunionstore(@dest, [@bigs, @smalls], :aggregate => :mix)
+      end.should raise_error(RuntimeError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,44 @@
+require 'rspec'
+require 'redis'
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "..", "..", "lib")))
+require 'mock_redis'
+
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
+Dir["spec/support/**/*.rb"].each {|x| require x}
+
+module TypeCheckingHelper
+  def method_from_description
+    # extracting this from the RSpec description string may or may not
+    # be a good idea. On the one hand, it enforces the convention of
+    # putting the method name in the right place; on the other hand,
+    # it's pretty magic-looking.
+    self.example.full_description.match(/#(\w+)/).captures.first
+  end
+
+  def args_for_method(method)
+    method_arity = @redises.real.method(method).arity
+    if method_arity < 0   # -1 comes from def foo(*args)
+      [1, 2]    # probably good enough
+    else
+      1.upto(method_arity - 1).to_a
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(TypeCheckingHelper)
+
+  config.before(:all) do
+    @redises = RedisMultiplexer.new
+  end
+
+  config.before(:each) do
+    # databases mentioned in our tests
+    [1, 0].each do |db|
+      @redises.send_without_checking(:select, db)
+      @redises.send_without_checking(:keys, "mock-redis-test:*").each do |key|
+        @redises.send_without_checking(:del, key)
+      end
+    end
+  end
+end

data/spec/support/redis_multiplexer.rb

@@ -0,0 +1,91 @@
+class BlankSlate
+  instance_methods.each {|m| undef_method(m) unless m =~ /^__/ || ['inspect', 'object_id'].include?(m.to_s)}
+end
+
+class RedisMultiplexer < BlankSlate
+  MismatchedResponse = Class.new(StandardError)
+
+  def initialize(*a)
+    @mock_redis = MockRedis.new(*a)
+    @real_redis = Redis.new(*a)
+  end
+
+  def method_missing(method, *args, &blk)
+    mock_retval, mock_error = catch_errors { @mock_redis.send(method, *args, &blk) }
+    real_retval, real_error = catch_errors { @real_redis.send(method, *args, &blk) }
+
+    mock_retval = handle_special_cases(method, mock_retval)
+    real_retval = handle_special_cases(method, real_retval)
+
+    if (!equalish?(mock_retval, real_retval) && !mock_error && !real_error)
+      # no exceptions, just different behavior
+      raise MismatchedResponse,
+        "Mock failure: responses not equal.\n" +
+        "Redis.#{method}(#{args.inspect}) returned #{real_retval.inspect}\n" +
+        "MockRedis.#{method}(#{args.inspect}) returned #{mock_retval.inspect}\n"
+    elsif (!mock_error && real_error)
+      raise MismatchedResponse,
+        "Mock failure: didn't raise an error when it should have.\n" +
+        "Redis.#{method}(#{args.inspect}) raised #{real_error.inspect}\n" +
+        "MockRedis.#{method}(#{args.inspect}) raised nothing " +
+        "and returned #{mock_retval.inspect}"
+    elsif (!real_error && mock_error)
+      raise MismatchedResponse,
+        "Mock failure: raised an error when it shouldn't have.\n" +
+        "Redis.#{method}(#{args.inspect}) returned #{real_retval.inspect}\n" +
+        "MockRedis.#{method}(#{args.inspect}) raised #{mock_error.inspect}"
+    elsif (mock_error && real_error && !equalish?(mock_error, real_error))
+      raise MismatchedResponse,
+        "Mock failure: raised the wrong error.\n" +
+        "Redis.#{method}(#{args.inspect}) raised #{real_error.inspect}\n" +
+        "MockRedis.#{method}(#{args.inspect}) raised #{mock_error.inspect}"
+    end
+
+    raise mock_error if mock_error
+    mock_retval
+  end
+
+  def equalish?(a, b)
+    if a == b
+      true
+    elsif a.is_a?(Array) && b.is_a?(Array)
+      a.zip(b).all? {|(x,y)| equalish?(x,y)}
+    elsif a.is_a?(Exception) && b.is_a?(Exception)
+      a.class == b.class && a.message == b.message
+    else
+      false
+    end
+  end
+
+  def mock() @mock_redis end
+  def real() @real_redis end
+
+  # Some commands require special handling due to nondeterminism in
+  # the returned values.
+  def handle_special_cases(method, value)
+    case method.to_s
+    when 'keys', 'hkeys', 'sdiff', 'sinter', 'smembers', 'sunion'
+      # The order is irrelevant, but [a,b] != [b,a] in Ruby, so we
+      # sort the returned values so we can ignore the order.
+      value.sort if value
+    else
+      value
+    end
+  end
+
+  # Used in cleanup before() blocks.
+  def send_without_checking(method, *args)
+    @mock_redis.send(method, *args)
+    @real_redis.send(method, *args)
+  end
+
+  def catch_errors
+    begin
+      retval = yield
+      [retval, nil]
+    rescue StandardError => e
+      [nil, e]
+    end
+  end
+end
+

data/spec/support/shared_examples/only_operates_on_hashes.rb

@@ -0,0 +1,13 @@
+shared_examples_for "a hash-only command" do
+  it "raises an error for non-hash values" do
+    key = 'mock-redis-test:hash-only'
+
+    method = method_from_description
+    args = args_for_method(method).unshift(key)
+
+    @redises.set(key, 1)
+    lambda do
+      @redises.send(method, *args)
+    end.should raise_error(RuntimeError)
+  end
+end

data/spec/support/shared_examples/only_operates_on_lists.rb

@@ -0,0 +1,13 @@
+shared_examples_for "a list-only command" do
+  it "raises an error for non-list values" do
+    key = 'mock-redis-test:list-only'
+
+    method = method_from_description
+    args = args_for_method(method).unshift(key)
+
+    @redises.set(key, 1)
+    lambda do
+      @redises.send(method, *args)
+    end.should raise_error(RuntimeError)
+  end
+end

data/spec/support/shared_examples/only_operates_on_sets.rb

@@ -0,0 +1,13 @@
+shared_examples_for "a set-only command" do
+  it "raises an error for non-set values" do
+    key = 'mock-redis-test:set-only'
+
+    method = method_from_description
+    args = args_for_method(method).unshift(key)
+
+    @redises.set(key, 1)
+    lambda do
+      @redises.send(method, *args)
+    end.should raise_error(RuntimeError)
+  end
+end

data/spec/support/shared_examples/only_operates_on_strings.rb

@@ -0,0 +1,13 @@
+shared_examples_for "a string-only command" do
+  it "raises an error for non-string values" do
+    key = "mock-redis-test:string-only-command"
+
+    method = method_from_description
+    args = args_for_method(method).unshift(key)
+
+    @redises.lpush(key, 1)
+    lambda do
+      @redises.send(method, *args)
+    end.should raise_error(RuntimeError)
+  end
+end

data/spec/support/shared_examples/only_operates_on_zsets.rb

@@ -0,0 +1,57 @@
+shared_examples_for "a zset-only command" do
+  it "raises an error for non-zset values" do
+    key = 'mock-redis-test:zset-only'
+
+    method = method_from_description
+    args = args_for_method(method).unshift(key)
+
+    @redises.set(key, 1)
+    lambda do
+      @redises.send(method, *args)
+    end.should raise_error(RuntimeError)
+  end
+end
+
+shared_examples_for "arg 1 is a score" do
+  before { @_arg_index = 1 }
+  it_should_behave_like "arg N is a score"
+end
+
+shared_examples_for "arg 2 is a score" do
+  before { @_arg_index = 2 }
+  it_should_behave_like "arg N is a score"
+end
+
+shared_examples_for "arg N is a score" do
+  before do
+    key = 'mock-redis-test:zset-only'
+
+    @method = method_from_description
+    @args = args_for_method(@method).unshift(key)
+  end
+
+  it "is okay with positive ints" do
+    @args[@_arg_index] = 1
+    lambda { @redises.send(@method, *@args) }.should_not raise_error
+  end
+
+  it "is okay with negative ints" do
+    @args[@_arg_index] = -1
+    lambda { @redises.send(@method, *@args) }.should_not raise_error
+  end
+
+  it "is okay with positive floats" do
+    @args[@_arg_index] = 1.5
+    lambda { @redises.send(@method, *@args) }.should_not raise_error
+  end
+
+  it "is okay with negative floats" do
+    @args[@_arg_index] = 1.5
+    lambda { @redises.send(@method, *@args) }.should_not raise_error
+  end
+
+  it "rejects non-numbers" do
+    @args[@_arg_index] = 'foo'
+    lambda { @redises.send(@method, *@args) }.should raise_error(RuntimeError)
+  end
+end

data/spec/transactions_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe 'transactions (multi/exec/discard)' do
+  before(:each) do
+    @redises.discard rescue nil
+  end
+
+  context "#multi" do
+    it "responds with 'OK'" do
+      @redises.multi.should == 'OK'
+    end
+
+    it "forbids nesting" do
+      @redises.multi
+      lambda do
+        @redises.multi
+      end.should raise_error(RuntimeError)
+    end
+  end
+
+  context "#blocks" do
+    it "implicitly runs exec when finished" do
+      @redises.set("counter", 5)
+      @redises.multi do |r|
+        r.set("test", 1)
+        r.incr("counter")
+      end
+      @redises.get("counter").should == "6"
+      @redises.get("test").should == "1"
+    end
+
+    it "forbids nesting via blocks" do
+      # Have to use only the mock here. redis-rb has a bug in it where
+      # nested #multi calls raise NoMethodError because it gets a nil
+      # where it's not expecting one.
+      @redises.mock.multi do |r|
+        lambda do
+          r.multi {}
+        end.should raise_error(RuntimeError)
+      end
+    end
+  end
+
+  context "#discard" do
+    it "responds with 'OK' after #multi" do
+      @redises.multi
+      @redises.discard.should == 'OK'
+    end
+
+    it "can't be run outside of #multi/#exec" do
+      lambda do
+        @redises.discard
+      end.should raise_error(RuntimeError)
+    end
+  end
+
+  context "#exec" do
+    it "raises an error outside of #multi" do
+      lambda do
+        @redises.exec.should raise_error
+      end
+    end
+  end
+
+  context "saving up commands for later" do
+    before(:each) do
+      @redises.multi
+      @string = 'mock-redis-test:string'
+      @list = 'mock-redis-test:list'
+    end
+
+    it "makes commands respond with 'QUEUED'" do
+      @redises.set(@string, 'string').should == 'QUEUED'
+      @redises.lpush(@list, 'list').should == 'QUEUED'
+    end
+
+    it "gives you the commands' responses when you call #exec" do
+      @redises.set(@string, 'string')
+      @redises.lpush(@list, 'list')
+      @redises.lpush(@list, 'list')
+
+      @redises.exec.should == ['OK', 1, 2]
+    end
+
+    it "does not raise exceptions, but rather puts them in #exec's response" do
+      @redises.set(@string, 'string')
+      @redises.lpush(@string, 'oops!')
+      @redises.lpush(@list, 'list')
+
+      responses = @redises.exec
+      responses[0].should == 'OK'
+      responses[1].should be_a(RuntimeError)
+      responses[2].should == 1
+    end
+  end
+end