mock_redis 0.5.4 → 0.31.0

data/spec/support/redis_multiplexer.rb

@@ -1,5 +1,7 @@
 class BlankSlate
-  instance_methods.each {|m| undef_method(m) unless m =~ /^__/ || ['inspect', 'object_id'].include?(m.to_s)}
+  instance_methods.each do |m|
+    undef_method(m) unless m =~ /^__/ || %w[inspect object_id].include?(m.to_s)
+  end
 end
 
 class RedisMultiplexer < BlankSlate
@@ -7,54 +9,69 @@ class RedisMultiplexer < BlankSlate
 
   def initialize(*a)
     @mock_redis = MockRedis.new(*a)
+    Redis.exists_returns_integer = true
     @real_redis = Redis.new(*a)
+    _gsub_clear
   end
 
-  def method_missing(method, *args, &blk)
-    # if we're in a Redis command that accepts a block, and we execute more redis commands, ONLY execute them
-    # on the Redis implementation that the block came from.
-    # e.g. if a pipelined command is started on a MockRedis object, DON'T send commands inside the pipelined block
-    # to the real Redis object, as that one WON'T be inside a pipelined command, and we'll see weird behaviour
-    if blk
-      @in_mock_block  = true
-      @in_redis_block = false
-    end
-    mock_retval, mock_error = catch_errors { @in_redis_block ? :no_op : @mock_redis.send(method, *args, &blk) }
+  def _gsub(from, to)
+    @gsub_from = from
+    @gsub_to = to
+  end
+
+  def _gsub_clear
+    @gsub_from = @gsub_to = ''
+  end
 
+  ruby2_keywords def method_missing(method, *args, &blk)
+    # If we're in a Redis command that accepts a block, and we execute more
+    # redis commands, ONLY execute them on the Redis implementation that the
+    # block came from.
+    # e.g. if a pipelined command is started on a MockRedis object, DON'T send
+    # commands inside the pipelined block to the real Redis object, as that one
+    # WON'T be inside a pipelined command, and we'll see weird behaviour
     if blk
       @in_mock_block  = false
       @in_redis_block = true
     end
-    real_retval, real_error = catch_errors { @in_mock_block ? :no_op : @real_redis.send(method, *args, &blk) }
+    real_retval, real_error =
+      catch_errors { @in_mock_block ? :no_op : @real_redis.send(method, *args, &blk) }
+
+    if blk
+      @in_mock_block  = true
+      @in_redis_block = false
+    end
+    mock_retval, mock_error =
+      catch_errors { @in_redis_block ? :no_op : @mock_redis.send(method, *args, &blk) }
 
     if blk
       @in_mock_block  = false
       @in_redis_block = false
     end
 
-    if (mock_retval == :no_op || real_retval == :no_op)
-        # ignore, we were inside a block (like pipelined)
-    elsif (!equalish?(mock_retval, real_retval) && !mock_error && !real_error)
+    if mock_retval == :no_op || real_retval == :no_op
+      # ignore, we were inside a block (like pipelined)
+    elsif !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" +
+        "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)
+    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 " +
+        "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)
+    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" +
+        "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))
+    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" +
+        "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
 
@@ -65,8 +82,10 @@ class RedisMultiplexer < BlankSlate
   def equalish?(a, b)
     if a == b
       true
+    elsif a.is_a?(String) && b.is_a?(String)
+      masked(a) == masked(b)
     elsif a.is_a?(Array) && b.is_a?(Array)
-      a.collect(&:to_s).sort == b.collect(&:to_s).sort
+      a.collect { |c| masked(c.to_s) }.sort == b.collect { |c| masked(c.to_s) }.sort
     elsif a.is_a?(Exception) && b.is_a?(Exception)
       a.class == b.class && a.message == b.message
     elsif a.is_a?(Float) && b.is_a?(Float)
@@ -77,8 +96,17 @@ class RedisMultiplexer < BlankSlate
     end
   end
 
-  def mock() @mock_redis end
-  def real() @real_redis end
+  def masked(str)
+    str.gsub(@gsub_from, @gsub_to)
+  end
+
+  def mock
+    @mock_redis
+  end
+
+  def real
+    @real_redis
+  end
 
   # Used in cleanup before() blocks.
   def send_without_checking(method, *args)
@@ -87,12 +115,9 @@ class RedisMultiplexer < BlankSlate
   end
 
   def catch_errors
-    begin
-      retval = yield
-      [retval, nil]
-    rescue StandardError => e
-      [nil, e]
-    end
+    retval = yield
+    [retval, nil]
+  rescue StandardError => e
+    [nil, e]
   end
 end
-

data/spec/support/shared_examples/does_not_cleanup_empty_strings.rb

@@ -0,0 +1,14 @@
+shared_examples_for 'does not remove empty strings on error' do
+  it 'does not remove empty strings on error' do |example|
+    key = 'mock-redis-test:not-a-string'
+
+    method = method_from_description(example)
+    args = args_for_method(method).unshift(key)
+
+    @redises.set(key, '')
+    lambda do
+      @redises.send(method, *args)
+    end.should raise_error(RuntimeError)
+    @redises.get(key).should == ''
+  end
+end

data/spec/support/shared_examples/only_operates_on_hashes.rb

@@ -1,8 +1,8 @@
-shared_examples_for "a hash-only command" do
-  it "raises an error for non-hash values" do
+shared_examples_for 'a hash-only command' do
+  it 'raises an error for non-hash values' do |example|
     key = 'mock-redis-test:hash-only'
 
-    method = method_from_description
+    method = method_from_description(example)
     args = args_for_method(method).unshift(key)
 
     @redises.set(key, 1)
@@ -10,4 +10,6 @@ shared_examples_for "a hash-only command" do
       @redises.send(method, *args)
     end.should raise_error(RuntimeError)
   end
+
+  it_should_behave_like 'does not remove empty strings on error'
 end

data/spec/support/shared_examples/only_operates_on_lists.rb

@@ -1,8 +1,8 @@
-shared_examples_for "a list-only command" do
-  it "raises an error for non-list values" do
+shared_examples_for 'a list-only command' do
+  it 'raises an error for non-list values' do |example|
     key = 'mock-redis-test:list-only'
 
-    method = method_from_description
+    method = method_from_description(example)
     args = args_for_method(method).unshift(key)
 
     @redises.set(key, 1)
@@ -10,4 +10,6 @@ shared_examples_for "a list-only command" do
       @redises.send(method, *args)
     end.should raise_error(RuntimeError)
   end
+
+  it_should_behave_like 'does not remove empty strings on error'
 end

data/spec/support/shared_examples/only_operates_on_sets.rb

@@ -1,8 +1,8 @@
-shared_examples_for "a set-only command" do
-  it "raises an error for non-set values" do
+shared_examples_for 'a set-only command' do
+  it 'raises an error for non-set values' do |example|
     key = 'mock-redis-test:set-only'
 
-    method = method_from_description
+    method = method_from_description(example)
     args = args_for_method(method).unshift(key)
 
     @redises.set(key, 1)
@@ -10,4 +10,6 @@ shared_examples_for "a set-only command" do
       @redises.send(method, *args)
     end.should raise_error(RuntimeError)
   end
+
+  it_should_behave_like 'does not remove empty strings on error'
 end

data/spec/support/shared_examples/only_operates_on_strings.rb

@@ -1,8 +1,8 @@
-shared_examples_for "a string-only command" do
-  it "raises an error for non-string values" do
-    key = "mock-redis-test:string-only-command"
+shared_examples_for 'a string-only command' do
+  it 'raises an error for non-string values' do |example|
+    key = 'mock-redis-test:string-only-command'
 
-    method = method_from_description
+    method = method_from_description(example)
     args = args_for_method(method).unshift(key)
 
     @redises.lpush(key, 1)

data/spec/support/shared_examples/only_operates_on_zsets.rb

@@ -1,8 +1,8 @@
-shared_examples_for "a zset-only command" do
-  it "raises an error for non-zset values" do
+shared_examples_for 'a zset-only command' do
+  it 'raises an error for non-zset values' do |example|
     key = 'mock-redis-test:zset-only'
 
-    method = method_from_description
+    method = method_from_description(example)
     args = args_for_method(method).unshift(key)
 
     @redises.set(key, 1)
@@ -10,47 +10,49 @@ shared_examples_for "a zset-only command" do
       @redises.send(method, *args)
     end.should raise_error(RuntimeError)
   end
+
+  it_should_behave_like 'does not remove empty strings on error'
 end
 
-shared_examples_for "arg 1 is a score" do
+shared_examples_for 'arg 1 is a score' do
   before { @_arg_index = 1 }
-  it_should_behave_like "arg N is a score"
+  it_should_behave_like 'arg N is a score'
 end
 
-shared_examples_for "arg 2 is a score" do
+shared_examples_for 'arg 2 is a score' do
   before { @_arg_index = 2 }
-  it_should_behave_like "arg N is a score"
+  it_should_behave_like 'arg N is a score'
 end
 
-shared_examples_for "arg N is a score" do
-  before do
+shared_examples_for 'arg N is a score' do
+  before do |example|
     key = 'mock-redis-test:zset-only'
 
-    @method = method_from_description
+    @method = method_from_description(example)
     @args = args_for_method(@method).unshift(key)
   end
 
-  it "is okay with positive ints" do
+  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
+  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
+  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
+  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
+  it 'rejects non-numbers' do
     @args[@_arg_index] = 'foo'
     lambda { @redises.send(@method, *@args) }.should raise_error(RuntimeError)
   end

data/spec/support/shared_examples/sorts_enumerables.rb

@@ -0,0 +1,56 @@
+shared_examples_for 'a sortable' do
+  it 'returns empty array on nil' do
+    @redises.sort(nil).should == []
+  end
+
+  context 'ordering' do
+    it 'orders ascending by default' do
+      @redises.sort(@key).should == %w[1 2]
+    end
+
+    it 'orders by descending when specified' do
+      @redises.sort(@key, :order => 'DESC').should == %w[2 1]
+    end
+  end
+
+  context 'projections' do
+    it 'projects element when :get is "#"' do
+      @redises.sort(@key, :get => '#').should == %w[1 2]
+    end
+
+    it 'projects through a key pattern' do
+      @redises.sort(@key, :get => 'mock-redis-test:values_*').should == %w[a b]
+    end
+
+    it 'projects through a key pattern and reflects element' do
+      @redises.sort(@key, :get => ['#', 'mock-redis-test:values_*']).should == [%w[1 a], %w[2 b]]
+    end
+
+    it 'projects through a hash key pattern' do
+      @redises.sort(@key, :get => 'mock-redis-test:hash_*->key').should == %w[x y]
+    end
+  end
+
+  context 'weights' do
+    it 'weights by projecting through a key pattern' do
+      @redises.sort(@key, :by => 'mock-redis-test:weight_*').should == %w[2 1]
+    end
+
+    it 'weights by projecting through a key pattern and a specific order' do
+      @redises.sort(@key, :order => 'DESC', :by => 'mock-redis-test:weight_*').should == %w[1 2]
+    end
+  end
+
+  context 'limit' do
+    it 'only returns requested window in the enumerable' do
+      @redises.sort(@key, :limit => [0, 1]).should == ['1']
+    end
+  end
+
+  context 'store' do
+    it 'stores into another key' do
+      @redises.sort(@key, :store => 'mock-redis-test:some_bucket').should == 2
+      @redises.lrange('mock-redis-test:some_bucket', 0, -1).should == %w[1 2]
+    end
+  end
+end

data/spec/transactions_spec.rb

@@ -5,21 +5,21 @@ describe 'transactions (multi/exec/discard)' do
     @redises.discard rescue nil
   end
 
-  context "#multi" do
+  context '#multi' do
     it "responds with 'OK'" do
       @redises.multi.should == 'OK'
     end
 
-    it "forbids nesting" do
+    it 'does not permit nesting' do
       @redises.multi
       lambda do
         @redises.multi
-      end.should raise_error(RuntimeError)
+      end.should raise_error(Redis::CommandError, 'ERR MULTI calls can not be nested')
     end
 
-    it "cleanup the state of tansaction wrapper if an exception occurs while a transaction is being processed" do
+    it 'cleans state of transaction wrapper if exception occurs during transaction' do
       lambda do
-        @redises.mock.multi do |r|
+        @redises.mock.multi do |_r|
           raise "i'm a command that fails"
         end
       end.should raise_error(RuntimeError)
@@ -28,58 +28,85 @@ describe 'transactions (multi/exec/discard)' do
       lambda do
         @redises.mock.multi do |r|
           # do stuff that succeed
-          s.set(nil, 'string')
+          r.set(nil, 'string')
         end
-      end.should_not raise_error(RuntimeError)
-
+      end.should_not raise_error
     end
   end
 
-  context "#blocks" do
-    it "implicitly runs exec when finished" do
-      @redises.set("counter", 5)
+  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")
+        r.set('test', 1)
+        r.incr('counter')
       end
-      @redises.get("counter").should == "6"
-      @redises.get("test").should == "1"
+      @redises.get('counter').should eq '6'
+      @redises.get('test').should eq '1'
     end
 
-    it "forbids nesting via blocks" do
+    it 'permits 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.should_not raise_error
+      end
+    end
+
+    it 'allows pipelined calls within multi blocks' do
+      @redises.set('counter', 5)
+      @redises.multi do |r|
+        r.pipelined do |pr|
+          pr.set('test', 1)
+          pr.incr('counter')
+        end
       end
+      @redises.get('counter').should eq '6'
+      @redises.get('test').should eq '1'
+    end
+
+    it 'allows blocks within multi blocks' do
+      @redises.set('foo', 'bar')
+      @redises.set('fuu', 'baz')
+
+      result = nil
+
+      @redises.multi do |r|
+        result = r.mget('foo', 'fuu') { |reply| reply.map(&:upcase) }
+        r.del('foo', 'fuu')
+      end
+
+      result.value.should eq %w[BAR BAZ]
+      @redises.get('foo').should eq nil
+      @redises.get('fuu').should eq nil
     end
   end
 
-  context "#discard" do
+  context '#discard' do
     it "responds with 'OK' after #multi" do
       @redises.multi
-      @redises.discard.should == 'OK'
+      @redises.discard.should eq 'OK'
     end
 
     it "can't be run outside of #multi/#exec" do
       lambda do
         @redises.discard
-      end.should raise_error(RuntimeError)
+      end.should raise_error(Redis::CommandError)
     end
   end
 
-  context "#exec" do
-    it "raises an error outside of #multi" do
+  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
+  context 'saving up commands for later' do
     before(:each) do
       @redises.multi
       @string = 'mock-redis-test:string'
@@ -87,8 +114,8 @@ describe 'transactions (multi/exec/discard)' do
     end
 
     it "makes commands respond with 'QUEUED'" do
-      @redises.set(@string, 'string').should == 'QUEUED'
-      @redises.lpush(@list, 'list').should == 'QUEUED'
+      @redises.set(@string, 'string').should eq 'QUEUED'
+      @redises.lpush(@list, 'list').should eq 'QUEUED'
     end
 
     it "gives you the commands' responses when you call #exec" do
@@ -96,7 +123,7 @@ describe 'transactions (multi/exec/discard)' do
       @redises.lpush(@list, 'list')
       @redises.lpush(@list, 'list')
 
-      @redises.exec.should == ['OK', 1, 2]
+      @redises.exec.should eq ['OK', 1, 2]
     end
 
     it "does not raise exceptions, but rather puts them in #exec's response" do
@@ -105,9 +132,32 @@ describe 'transactions (multi/exec/discard)' do
       @redises.lpush(@list, 'list')
 
       responses = @redises.exec
-      responses[0].should == 'OK'
-      responses[1].should be_a(RuntimeError)
-      responses[2].should == 1
+      responses[0].should eq 'OK'
+      responses[1].should be_a(Redis::CommandError)
+      responses[2].should eq 1
+    end
+  end
+
+  context 'saving commands with multi block' do
+    before(:each) do
+      @string = 'mock-redis-test:string'
+      @list = 'mock-redis-test:list'
+    end
+
+    it 'commands return response after exec is called' do
+      set_response = nil
+      lpush_response = nil
+      second_lpush_response = nil
+
+      @redises.multi do |mult|
+        set_response = mult.set(@string, 'string')
+        lpush_response = mult.lpush(@list, 'list')
+        second_lpush_response = mult.lpush(@list, 'list')
+      end
+
+      set_response.value.should eq 'OK'
+      lpush_response.value.should eq 1
+      second_lpush_response.value.should eq 2
     end
   end
 end