mock_redis 0.20.0 → 0.25.0

data/spec/commands/setbit_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe '#setbit(key, offset)' do
   before do
+    Encoding.default_external = 'UTF-8'
     @key = 'mock-redis-test:setbit'
     @redises.set(@key, 'h') # ASCII 0x68
   end

data/spec/commands/setex_spec.rb

@@ -19,4 +19,20 @@ describe '#setex(key, seconds, value)' do
     @redises.real.ttl(@key).should > 0
     @redises.mock.ttl(@key).should > 0
   end
+
+  context 'when expiration time is zero' do
+    it 'raises Redis::CommandError' do
+      expect do
+        @redises.setex(@key, 0, 'value')
+      end.to raise_error(Redis::CommandError, 'ERR invalid expire time in setex')
+    end
+  end
+
+  context 'when expiration time is negative' do
+    it 'raises Redis::CommandError' do
+      expect do
+        @redises.setex(@key, -2, 'value')
+      end.to raise_error(Redis::CommandError, 'ERR invalid expire time in setex')
+    end
+  end
 end

data/spec/commands/srandmember_spec.rb

@@ -37,7 +37,7 @@ describe '#srandmember(key)' do
       @redises.send_without_checking(:srandmember, @key, 2).size.should == 2
     end
 
-    it 'returns random members up to count from the set when count is negative even if count.abs is greater than the set size' do # rubocop:disable Metrics/LineLength
+    it 'returns random members up to count from the set when count is negative even if count.abs is greater than the set size' do # rubocop:disable Layout/LineLength
       @redises.send_without_checking(:srandmember, @key, -5).size.should == 5
     end
 

data/spec/commands/srem_spec.rb

@@ -36,5 +36,10 @@ describe '#srem(key, member)' do
     @redises.get(@key).should be_nil
   end
 
+  it 'allow passing an array of integers as argument' do
+    @redises.sadd(@key, %w[1 2])
+    @redises.srem(@key, [1, 2]).should == 2
+  end
+
   it_should_behave_like 'a set-only command'
 end

data/spec/commands/xadd_spec.rb

@@ -54,6 +54,8 @@ describe '#xadd("mystream", { f1: "v1", f2: "v2" }, id: "0-0", maxlen: 1000, app
         Redis::CommandError,
         'ERR The ID specified in XADD is equal or smaller than the target ' \
         'stream top item'
+        # TOOD: Redis version 6.0.4, w redis 4.2.1 generates the following error message:
+        # 'ERR The ID specified in XADD must be greater than 0-0'
       )
   end
 
@@ -99,4 +101,22 @@ describe '#xadd("mystream", { f1: "v1", f2: "v2" }, id: "0-0", maxlen: 1000, app
       ]
     )
   end
+
+  it 'supports a maxlen greater than the current size' do
+    @redises.xadd(@key, { key1: 'value1' }, id: '1234567891234-0')
+    @redises.xadd(@key, { key2: 'value2' }, id: '1234567891245-0', maxlen: 1000)
+    expect(@redises.xrange(@key, '-', '+')).to eq(
+      [
+        ['1234567891234-0', { 'key1' => 'value1' }],
+        ['1234567891245-0', { 'key2' => 'value2' }],
+      ]
+    )
+  end
+
+  it 'creates an empty stream with maxlen of 0' do
+    @redises.xadd(@key, { key: 'value' }, maxlen: 0)
+    expect(@redises.xlen(@key)).to eq 0
+    expect(@redises.xrange(@key, '-', '+')).to eq([])
+    expect(@redises.exists?(@key)).to eq true
+  end
 end

data/spec/commands/xrange_spec.rb

@@ -54,6 +54,19 @@ describe '#xrange("mystream", first: "0-1", last: "0-3", count: 10)' do
       )
     end
 
+    it 'returns all entries with a lower limit of 0-0' do
+      expect(@redises.xrange(@key, '0-0', '+')).to eq(
+        [
+          ['1234567891234-0', { 'key1' => 'value1' }],
+          ['1234567891245-0', { 'key2' => 'value2' }],
+          ['1234567891245-1', { 'key3' => 'value3' }],
+          ['1234567891278-0', { 'key4' => 'value4' }],
+          ['1234567891278-1', { 'key5' => 'value5' }],
+          ['1234567891299-0', { 'key6' => 'value6' }]
+        ]
+      )
+    end
+
     it 'returns entries with an upper limit' do
       expect(@redises.xrange(@key, '-', '1234567891285-0')).to eq(
         [

data/spec/commands/xread_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe '#xread(keys, ids)' do
+  before :all do
+    sleep 1 - (Time.now.to_f % 1)
+    @key = 'mock-redis-test:xread'
+    @key1 = 'mock-redis-test:xread1'
+  end
+
+  it 'reads a single entry' do
+    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-0')
+    expect(@redises.xread(@key, '0-0'))
+      .to eq({ @key => [['1234567891234-0', { 'key' => 'value' }]] })
+  end
+
+  it 'reads multiple entries from the beginning of the stream' do
+    @redises.xadd(@key, { key0: 'value0' }, id: '1234567891234-0')
+    @redises.xadd(@key, { key1: 'value1' }, id: '1234567891234-1')
+    expect(@redises.xread(@key, '0-0'))
+      .to eq({ @key => [['1234567891234-0', { 'key0' => 'value0' }],
+                        ['1234567891234-1', { 'key1' => 'value1' }]] })
+  end
+
+  it 'reads entries greater than the ID passed' do
+    @redises.xadd(@key, { key0: 'value0' }, id: '1234567891234-0')
+    @redises.xadd(@key, { key1: 'value1' }, id: '1234567891234-1')
+    expect(@redises.xread(@key, '1234567891234-0'))
+      .to eq({ @key => [['1234567891234-1', { 'key1' => 'value1' }]] })
+  end
+
+  it 'reads from multiple streams' do
+    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-0')
+    @redises.xadd(@key1, { key1: 'value1' }, id: '1234567891234-0')
+    expect(@redises.xread([@key, @key1], %w[0-0 0-0]))
+      .to eq({ @key => [['1234567891234-0', { 'key' => 'value' }]],
+               @key1 => [['1234567891234-0', { 'key1' => 'value1' }]] })
+  end
+
+  it 'reads from multiple streams at the given IDs' do
+    @redises.xadd(@key, { key: 'value0' }, id: '1234567891234-0')
+    @redises.xadd(@key, { key: 'value1' }, id: '1234567891234-1')
+    @redises.xadd(@key, { key: 'value2' }, id: '1234567891234-2')
+    @redises.xadd(@key1, { key1: 'value0' }, id: '1234567891234-0')
+    @redises.xadd(@key1, { key1: 'value1' }, id: '1234567891234-1')
+    @redises.xadd(@key1, { key1: 'value2' }, id: '1234567891234-2')
+    # The first stream won't return anything since we specify the last ID
+    expect(@redises.xread([@key, @key1], %w[1234567891234-2 1234567891234-1]))
+      .to eq({ @key1 => [['1234567891234-2', { 'key1' => 'value2' }]] })
+  end
+end

data/spec/commands/xtrim_spec.rb

@@ -16,6 +16,12 @@ describe '#xtrim("mystream", 1000, approximate: true)' do
     expect(@redises.xtrim(@key, 4)).to eq 2
   end
 
+  it 'returns 0 if count is greater than size' do
+    initial = @redises.xrange(@key, '-', '+')
+    expect(@redises.xtrim(@key, 1000)).to eq 0
+    expect(@redises.xrange(@key, '-', '+')).to eql(initial)
+  end
+
   it 'deletes the oldes elements' do
     @redises.xtrim(@key, 4)
     expect(@redises.xrange(@key, '-', '+')).to eq(

data/spec/commands/zinterstore_spec.rb

@@ -42,6 +42,40 @@ describe '#zinterstore(destination, keys, [:weights => [w,w,], [:aggregate => :s
     end.should raise_error(Redis::CommandError)
   end
 
+  context 'when used with a set' do
+    before do
+      @primes_text = 'mock-redis-test:zinterstore:primes-text'
+
+      @redises.sadd(@primes_text, 'two')
+      @redises.sadd(@primes_text, 'three')
+      @redises.sadd(@primes_text, 'five')
+      @redises.sadd(@primes_text, 'seven')
+    end
+
+    it 'returns the number of elements in the new set' do
+      @redises.zinterstore(@dest, [@odds, @primes_text]).should == 3
+    end
+
+    it 'sums the scores, substituting 1.0 for set values' do
+      @redises.zinterstore(@dest, [@odds, @primes_text])
+      @redises.zrange(@dest, 0, -1, :with_scores => true).should ==
+        [['three', 4.0], ['five', 6.0], ['seven', 8.0]]
+    end
+  end
+
+  context 'when used with a non-coercible structure' do
+    before do
+      @non_set = 'mock-redis-test:zinterstore:non-set'
+
+      @redises.set(@non_set, 'one')
+    end
+    it 'raises an error for wrong value type' do
+      lambda do
+        @redises.zinterstore(@dest, [@odds, @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.zinterstore(@dest, [@odds, @primes], :weights => [2, 3])

data/spec/commands/zpopmax_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe '#zpopmax(key, count)' do
+  before(:each) do
+    @key = 'mock-redis-test:zpopmax'
+    @redises.del(@key)
+    @redises.zadd(@key, 1, 'one')
+    @redises.zadd(@key, 2, 'two')
+    @redises.zadd(@key, 3, 'three')
+  end
+
+  context 'when count is unspecified' do
+    it 'returns nil if the set does not exist' do
+      @redises.zpopmax('does-not-exist').should nil
+    end
+
+    it 'returns the highest ranked element' do
+      @redises.zpopmax(@key).should == ['three', 3]
+      @redises.zcard(@key).should == 2
+    end
+  end
+
+  context 'when count is 1' do
+    let(:count) { 1 }
+
+    it 'returns nil if the set does not exist' do
+      @redises.zpopmax('does-not-exist', count).should nil
+    end
+
+    it 'returns the highest ranked element' do
+      @redises.zpopmax(@key, count).should == ['three', 3]
+      @redises.zcard(@key).should == 2
+    end
+  end
+
+  context 'when count is greater than 1' do
+    let(:count) { 2 }
+
+    it 'returns empty array if the set does not exist' do
+      @redises.zpopmax('does-not-exist', count).should == []
+    end
+
+    it 'returns the highest ranked elements' do
+      @redises.zpopmax(@key, count).should == [['three', 3], ['two', 2]]
+      @redises.zcard(@key).should == 1
+    end
+  end
+
+  context 'when count is greater than the size of the set' do
+    let(:count) { 4 }
+
+    it 'returns the entire set' do
+      before = @redises.zrange(@key, 0, count, with_scores: true).reverse
+      @redises.zpopmax(@key, count).should == before
+      @redises.zcard(@key).should == 0
+    end
+  end
+
+  it_should_behave_like 'a zset-only command'
+end

data/spec/commands/zpopmin_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe '#zpopmin(key, count)' do
+  before(:each) do
+    @key = 'mock-redis-test:zpopmin'
+    @redises.del(@key)
+    @redises.zadd(@key, 1, 'one')
+    @redises.zadd(@key, 2, 'two')
+    @redises.zadd(@key, 3, 'three')
+  end
+
+  context 'when count is unspecified' do
+    it 'returns nil if the set does not exist' do
+      @redises.zpopmin('does-not-exist').should nil
+    end
+
+    it 'returns the lowest ranked element' do
+      @redises.zpopmin(@key).should == ['one', 1]
+      @redises.zcard(@key).should == 2
+    end
+  end
+
+  context 'when count is 1' do
+    let(:count) { 1 }
+
+    it 'returns nil if the set does not exist' do
+      @redises.zpopmin('does-not-exist', count).should nil
+    end
+
+    it 'returns the lowest ranked element' do
+      @redises.zpopmin(@key, count).should == ['one', 1]
+      @redises.zcard(@key).should == 2
+    end
+  end
+
+  context 'when count is greater than 1' do
+    let(:count) { 2 }
+
+    it 'returns empty array if the set does not exist' do
+      @redises.zpopmin('does-not-exist', count).should == []
+    end
+
+    it 'returns the lowest ranked elements' do
+      @redises.zpopmin(@key, count).should == [['one', 1], ['two', 2]]
+      @redises.zcard(@key).should == 1
+    end
+  end
+
+  context 'when count is greater than the size of the set' do
+    let(:count) { 4 }
+
+    it 'returns the entire set' do
+      before = @redises.zrange(@key, 0, count, with_scores: true)
+      @redises.zpopmin(@key, count).should == before
+      @redises.zcard(@key).should == 0
+    end
+  end
+
+  it_should_behave_like 'a zset-only command'
+end

data/spec/commands/zrange_spec.rb

@@ -15,7 +15,7 @@ describe '#zrange(key, start, stop [, :with_scores => true])' do
     end
 
     it 'should return an empty array' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
       @redises.zrange(@key, 0, 4).should == []
     end
   end

data/spec/commands/zrangebyscore_spec.rb

@@ -15,7 +15,7 @@ describe '#zrangebyscore(key, start, stop [:with_scores => true] [:limit => [off
     end
 
     it 'should return an empty array' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
       @redises.zrangebyscore(@key, 0, 4).should == []
     end
   end

data/spec/commands/zrevrange_spec.rb

@@ -15,7 +15,7 @@ describe '#zrevrange(key, start, stop [, :with_scores => true])' do
     end
 
     it 'should return an empty array' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
       @redises.zrevrange(@key, 0, 4).should == []
     end
   end

data/spec/commands/zrevrangebyscore_spec.rb

@@ -15,7 +15,7 @@ describe '#zrevrangebyscore(key, start, stop [:with_scores => true] [:limit => [
     end
 
     it 'should return an empty array' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
       @redises.zrevrangebyscore(@key, 0, 4).should == []
     end
   end

data/spec/commands/zunionstore_spec.rb

@@ -41,6 +41,39 @@ describe '#zunionstore(destination, keys, [:weights => [w,w,], [:aggregate => :s
     end.should raise_error(Redis::CommandError)
   end
 
+  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])

data/spec/mock_redis_spec.rb

@@ -49,23 +49,21 @@ describe MockRedis do
     end
 
     describe '.now' do
-      let(:now)       { 'Now' }
-      let(:time_stub) { double 'Time', :now => now }
+      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 == now }
+      its(:now) { should == [1_546_398_246, 0] }
     end
 
     describe '.time' do
-      let(:now)       { 'Now' }
-      let(:time_stub) { double 'Time', :now => now }
+      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 == now }
+      its(:time) { should == [1_546_398_246, 0] }
     end
 
     describe '.expireat' do

data/spec/spec_helper.rb

@@ -15,7 +15,7 @@ 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(example)
@@ -27,7 +27,7 @@ module TypeCheckingHelper
   end
 
   def args_for_method(method)
-    return [] if method.to_s == 'spop'
+    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
@@ -40,6 +40,8 @@ end
 RSpec.configure do |config|
   config.expect_with :rspec do |c|
     c.syntax = [:expect, :should]
+    # Allow for a large output so we can debug error messages
+    c.max_formatted_output_length = 1_000_000
   end
 
   config.mock_with :rspec do |c|