mock_redis 0.5.4 → 0.31.0

data/spec/commands/zrevrange_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#zrevrange(key, start, stop [, :with_scores => true])" do
+describe '#zrevrange(key, start, stop [, :with_scores => true])' do
   before do
     @key = 'mock-redis-test:zrevrange'
     @redises.zadd(@key, 1, 'Washington')
@@ -9,23 +9,48 @@ describe "#zrevrange(key, start, stop [, :with_scores => true])" do
     @redises.zadd(@key, 4, 'Madison')
   end
 
-  it "returns the elements in order by score" do
-    @redises.zrevrange(@key, 0, 1).should == ['Madison', 'Jefferson']
+  context 'when the zset is empty' do
+    before do
+      @redises.del(@key)
+    end
+
+    it 'should return an empty array' do
+      @redises.exists?(@key).should == false
+      @redises.zrevrange(@key, 0, 4).should == []
+    end
+  end
+
+  it 'returns the elements in order by score' do
+    @redises.zrevrange(@key, 0, 1).should == %w[Madison Jefferson]
+  end
+
+  context 'when a subset of elements have the same score' do
+    before do
+      @redises.zadd(@key, 1, 'Martha')
+    end
+
+    it 'returns the elements in descending lexicographical order' do
+      @redises.zrevrange(@key, 3, 4).should == %w[Washington Martha]
+    end
+  end
+
+  it 'returns the elements in order by score (negative indices)' do
+    @redises.zrevrange(@key, -2, -1).should == %w[Adams Washington]
   end
 
-  it "returns the elements in order by score (negative indices)" do
-    @redises.zrevrange(@key, -2, -1).should == ['Adams', 'Washington']
+  it 'returns empty list when start is too large' do
+    @redises.zrevrange(@key, 5, -1).should == []
   end
 
-  it "returns the scores when :with_scores is specified" do
+  it 'returns the scores when :with_scores is specified' do
     @redises.zrevrange(@key, 2, 3, :with_scores => true).
-      should == [["Adams", 2.0], ["Washington", 1.0]]
+      should == [['Adams', 2.0], ['Washington', 1.0]]
   end
 
-  it "returns the scores when :withscores is specified" do
+  it 'returns the scores when :withscores is specified' do
     @redises.zrevrange(@key, 2, 3, :withscores => true).
-      should == [["Adams", 2.0], ["Washington", 1.0]]
+      should == [['Adams', 2.0], ['Washington', 1.0]]
   end
 
-  it_should_behave_like "a zset-only command"
+  it_should_behave_like 'a zset-only command'
 end

data/spec/commands/zrevrangebyscore_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#zrevrangebyscore(key, start, stop [:with_scores => true] [:limit => [offset count]])" do
+describe '#zrevrangebyscore(key, start, stop [:with_scores => true] [:limit => [offset count]])' do
   before do
     @key = 'mock-redis-test:zrevrangebyscore'
     @redises.zadd(@key, 1, 'Washington')
@@ -9,39 +9,50 @@ describe "#zrevrangebyscore(key, start, stop [:with_scores => true] [:limit => [
     @redises.zadd(@key, 4, 'Madison')
   end
 
-  it "returns the elements in order by score" do
-    @redises.zrevrangebyscore(@key, 4, 3).should == ['Madison', 'Jefferson']
+  context 'when the zset is empty' do
+    before do
+      @redises.del(@key)
+    end
+
+    it 'should return an empty array' do
+      @redises.exists?(@key).should == false
+      @redises.zrevrangebyscore(@key, 0, 4).should == []
+    end
+  end
+
+  it 'returns the elements in order by score' do
+    @redises.zrevrangebyscore(@key, 4, 3).should == %w[Madison Jefferson]
   end
 
-  it "returns the scores when :with_scores is specified" do
+  it 'returns the scores when :with_scores is specified' do
     @redises.zrevrangebyscore(@key, 4, 3, :with_scores => true).
-      should == [["Madison", 4.0], ["Jefferson", 3.0]]
+      should == [['Madison', 4.0], ['Jefferson', 3.0]]
   end
 
-  it "returns the scores when :withscores is specified" do
+  it 'returns the scores when :withscores is specified' do
     @redises.zrevrangebyscore(@key, 4, 3, :withscores => true).
-      should == [["Madison", 4.0], ["Jefferson", 3.0]]
+      should == [['Madison', 4.0], ['Jefferson', 3.0]]
   end
 
-  it "treats +inf as positive infinity" do
-    @redises.zrevrangebyscore(@key, "+inf", 3).
+  it 'treats +inf as positive infinity' do
+    @redises.zrevrangebyscore(@key, '+inf', 3).
       should == %w[Madison Jefferson]
   end
 
-  it "honors the :limit => [offset count] argument" do
+  it 'honors the :limit => [offset count] argument' do
     @redises.zrevrangebyscore(@key, 100, -100, :limit => [1, 2]).
-      should == ["Jefferson", "Adams"]
+      should == %w[Jefferson Adams]
   end
 
   it "raises an error if :limit isn't a 2-tuple" do
     lambda do
       @redises.zrevrangebyscore(@key, 100, -100, :limit => [1, 2, 3])
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
 
     lambda do
-      @redises.zrevrangebyscore(@key, 100, -100, :limit => "1, 2")
-    end.should raise_error
+      @redises.zrevrangebyscore(@key, 100, -100, :limit => '1, 2')
+    end.should raise_error(RedisMultiplexer::MismatchedResponse)
   end
 
-  it_should_behave_like "a zset-only command"
+  it_should_behave_like 'a zset-only command'
 end

data/spec/commands/zrevrank_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#zrevrank(key, member)" do
+describe '#zrevrank(key, member)' do
   before do
     @key = 'mock-redis-test:zrevrank'
 
@@ -13,17 +13,17 @@ describe "#zrevrank(key, member)" do
     @redises.zrevrank(@key, 'foo').should be_nil
   end
 
-  it "returns the index of the member in the set (ordered by -score)" do
+  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 "handles integer members correctly" do
+  it 'handles integer members correctly' do
     member = 11
     @redises.zadd(@key, 4, member)
     @redises.zrevrank(@key, member).should == 0
   end
 
-  it_should_behave_like "a zset-only command"
+  it_should_behave_like 'a zset-only command'
 end

data/spec/commands/zscan_each_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe '#zscan_each' do
+  subject { MockRedis::Database.new(self) }
+
+  let(:key) { 'mock-redis-test:zscan_each' }
+
+  before do
+    allow(subject).to receive(:zrange).and_return(collection)
+  end
+
+  context 'when no keys are found' do
+    let(:collection) { [] }
+
+    it 'does not iterate over any elements' do
+      results = subject.zscan_each(key).map do |m, s|
+        [m, s]
+      end
+      expect(results).to match_array(collection)
+    end
+  end
+
+  context 'when keys are found' do
+    context 'when no match filter is supplied' do
+      let(:collection) { Array.new(20) { |i| ["m#{i}", i] } }
+
+      it 'iterates over each item in the collection' do
+        results = subject.zscan_each(key).map do |m, s|
+          [m, s]
+        end
+        expect(results).to match_array(collection)
+      end
+    end
+
+    context 'when giving a custom match filter' do
+      let(:match) { 'm1*' }
+      let(:collection) { Array.new(12) { |i| ["m#{i}", i] } }
+      let(:expected) { [['m1', 1], ['m10', 10], ['m11', 11]] }
+
+      it 'iterates over each item in the filtered collection' do
+        results = subject.zscan_each(key, match: match).map do |m, s|
+          [m, s]
+        end
+        expect(results).to match_array(expected)
+      end
+    end
+  end
+end

data/spec/commands/zscan_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe '#zscan' do
+  let(:count) { 10 }
+  let(:match) { '*' }
+  let(:key) { 'mock-redis-test:zscan' }
+
+  context 'when the zset does not exist' do
+    it 'returns a 0 cursor and an empty collection' do
+      expect(@redises.zscan(key, 0, count: count, match: match)).to eq(['0', []])
+    end
+  end
+
+  context 'when the zset exists' do
+    before do
+      @redises.zadd(key, 1.0, 'member1')
+      @redises.zadd(key, 2.0, 'member2')
+    end
+
+    it 'returns a 0 cursor and the collection' do
+      result = @redises.zscan(key, 0)
+      expect(result[0]).to eq('0')
+      expect(result[1]).to match_array([['member1', 1.0], ['member2', 2.0]])
+    end
+  end
+end

data/spec/commands/zscore_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
-describe "#zscore(key, member)" do
+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
+  it 'returns the score as a string' do
+    @redises.zadd(@key, 0.25, 'foo').should == true
     @redises.zscore(@key, 'foo').should == 0.25
   end
 
-  it "handles integer members correctly" do
+  it 'handles integer members correctly' do
     member = 11
-    @redises.zadd(@key, 0.25, member).should be_true
+    @redises.zadd(@key, 0.25, member).should == true
     @redises.zscore(@key, member).should == 0.25
   end
 
-  it "returns nil if member is not present in the set" do
+  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"
+  it_should_behave_like 'a zset-only command'
 end

data/spec/commands/zunionstore_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#zunionstore(destination, keys, [:weights => [w,w,], [:aggregate => :sum|:min|:max])" do
+describe '#zunionstore(destination, keys, [:weights => [w,w,], [:aggregate => :sum|:min|:max])' do
   before do
     @set1 = 'mock-redis-test:zunionstore1'
     @set2 = 'mock-redis-test:zunionstore2'
@@ -17,45 +17,78 @@ describe "#zunionstore(destination, keys, [:weights => [w,w,], [:aggregate => :s
     @redises.zadd(@set3, 3, 'three')
   end
 
-  it "returns the number of elements in the new set" do
+  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 ==
-      [["one", 3.0], ["three", 3.0], ["two", 4.0]]
+      [['one', 3.0], ['three', 3.0], ['two', 4.0]]
   end
 
-  it "removes existing elements in destination" do
+  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 ==
-      [["one", 1.0]]
+      [['one', 1.0]]
   end
 
-  it "raises an error if keys is empty" do
+  it 'raises an error if keys is empty' do
     lambda do
       @redises.zunionstore(@dest, [])
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  context "the :weights argument" do
-    it "multiplies the scores by the weights while aggregating" do
+  context 'when used with a set' do
+    before do
+      @set4 = 'mock-redis-test:zunionstore4'
+
+      @redises.sadd(@set4, 'two')
+      @redises.sadd(@set4, 'three')
+      @redises.sadd(@set4, 'four')
+    end
+
+    it 'returns the number of elements in the new set' do
+      @redises.zunionstore(@dest, [@set3, @set4]).should == 4
+    end
+
+    it 'sums the scores, substituting 1.0 for set values' do
+      @redises.zunionstore(@dest, [@set3, @set4])
+      @redises.zrange(@dest, 0, -1, :with_scores => true).should ==
+        [['four', 1.0], ['one', 1.0], ['two', 3.0], ['three', 4.0]]
+    end
+  end
+
+  context 'when used with a non-coercible structure' do
+    before do
+      @non_set = 'mock-redis-test:zunionstore4'
+
+      @redises.set(@non_set, 'one')
+    end
+    it 'raises an error for wrong value type' do
+      lambda do
+        @redises.zunionstore(@dest, [@set1, @non_set])
+      end.should raise_error(Redis::CommandError)
+    end
+  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 ==
-        [["one", 10.0], ["three", 15.0], ["two", 16.0]]
+        [['one', 10.0], ['three', 15.0], ['two', 16.0]]
     end
 
-    it "raises an error if the number of weights != the number of keys" do
+    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)
+        @redises.zunionstore(@dest, [@set1, @set2, @set3], :weights => [1, 2])
+      end.should raise_error(Redis::CommandError)
     end
   end
 
-  context "the :aggregate argument" do
+  context 'the :aggregate argument' do
     before do
       @smalls = 'mock-redis-test:zunionstore:smalls'
       @bigs   = 'mock-redis-test:zunionstore:bigs'
@@ -66,19 +99,19 @@ describe "#zunionstore(destination, keys, [:weights => [w,w,], [:aggregate => :s
       @redises.zadd(@bigs, 200, 'ernie')
     end
 
-    it "aggregates scores with min when :aggregate => :min is specified" do
+    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 ==
-        [["bert", 1.0], ["ernie", 2.0]]
+        [['bert', 1.0], ['ernie', 2.0]]
     end
 
-    it "aggregates scores with max when :aggregate => :max is specified" do
+    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 ==
-        [["bert", 100.0], ["ernie", 200.0]]
+        [['bert', 100.0], ['ernie', 200.0]]
     end
 
-    it "ignores scores for missing members" do
+    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.0
@@ -95,10 +128,10 @@ describe "#zunionstore(destination, keys, [:weights => [w,w,], [:aggregate => :s
       @redises.zscore(@dest, 'bert').should == 1.0
     end
 
-    it "raises an error for unknown aggregation function" do
+    it 'raises an error for unknown aggregation function' do
       lambda do
         @redises.zunionstore(@dest, [@bigs, @smalls], :aggregate => :mix)
-      end.should raise_error(RuntimeError)
+      end.should raise_error(Redis::CommandError)
     end
   end
 end

data/spec/mock_redis_spec.rb

@@ -29,4 +29,65 @@ describe MockRedis do
 
     its(:id) { should == url }
   end
+
+  describe 'Injecting a time class' do
+    describe '.options' do
+      let(:time_stub) { double 'Time' }
+      let(:options)   { { :time_class => time_stub } }
+
+      it 'defaults to Time' do
+        mock_redis = MockRedis.new
+
+        mock_redis.options[:time_class].should == Time
+      end
+
+      it 'has a configurable Time class' do
+        mock_redis = MockRedis.new(options)
+
+        mock_redis.options[:time_class].should == time_stub
+      end
+    end
+
+    describe '.now' do
+      let(:time_stub) { double 'Time', :now => Time.new(2019, 1, 2, 3, 4, 6, '+00:00') }
+      let(:options)   { { :time_class => time_stub } }
+
+      subject { MockRedis.new(options) }
+
+      its(:now) { should == [1_546_398_246, 0] }
+    end
+
+    describe '.time' do
+      let(:time_stub) { double 'Time', :now => Time.new(2019, 1, 2, 3, 4, 6, '+00:00') }
+      let(:options)   { { :time_class => time_stub } }
+
+      subject { MockRedis.new(options) }
+
+      its(:time) { should == [1_546_398_246, 0] }
+    end
+
+    describe '.expireat' do
+      let(:time_at)   { 'expireat' }
+      let(:time_stub) { double 'Time' }
+      let(:options)   { { :time_class => time_stub } }
+      let(:timestamp) { 123_456 }
+
+      subject { MockRedis.new(options) }
+
+      it 'Forwards time_at to the time_class' do
+        time_stub.should_receive(:at).with(timestamp).and_return(time_at)
+
+        subject.time_at(timestamp).should == time_at
+      end
+    end
+  end
+
+  describe 'supplying a logger' do
+    it 'logs redis commands' do
+      logger = double('Logger', debug?: true, debug: nil)
+      mock_redis = MockRedis.new(logger: logger)
+      expect(logger).to receive(:debug).with(/command=HMGET args="hash" "key1" "key2"/)
+      mock_redis.hmget('hash', 'key1', 'key2')
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,24 +1,42 @@
-require 'rspec'
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec/'
+
+  if ENV['CI']
+    require 'simplecov-lcov'
+
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      c.single_report_path = 'coverage/lcov.info'
+    end
+
+    formatter SimpleCov::Formatter::LcovFormatter
+  end
+end
+
+require 'rspec/its'
 require 'redis'
-$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, "..", "..", "lib")))
+$LOAD_PATH.unshift(File.expand_path(File.join(__FILE__, '..', '..', 'lib')))
 require 'mock_redis'
+require 'timecop'
 
 $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
-Dir["spec/support/**/*.rb"].each {|x| require x}
+Dir['spec/support/**/*.rb'].sort.each { |x| require x }
 
 module TypeCheckingHelper
-  def method_from_description
+  def method_from_description(example)
     # 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
+    example.full_description.match(/#(\w+)/).captures.first
   end
 
   def args_for_method(method)
+    return [] if %w[spop zpopmin zpopmax].include?(method.to_s)
     method_arity = @redises.real.method(method).arity
-    if method_arity < 0   # -1 comes from def foo(*args)
-      [1, 2]    # probably good enough
+    if method_arity < 0 # -1 comes from def foo(*args)
+      [1, 2] # probably good enough
     else
       1.upto(method_arity - 1).to_a
     end
@@ -26,6 +44,14 @@ module TypeCheckingHelper
 end
 
 RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:expect, :should]
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = [:expect, :should]
+  end
+
   config.include(TypeCheckingHelper)
 
   config.before(:all) do
@@ -36,9 +62,10 @@ RSpec.configure do |config|
     # 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(:keys, 'mock-redis-test:*').each do |key|
         @redises.send_without_checking(:del, key)
       end
     end
+    @redises._gsub_clear
   end
 end