mock_redis 0.21.0 → 0.26.0

data/spec/commands/exists_spec.rb

@@ -1,14 +1,43 @@
 require 'spec_helper'
 
-describe '#exists(key)' do
-  before { @key = 'mock-redis-test:45794' }
+describe '#exists(*keys)' do
+  before { @key1 = 'mock-redis-test:exists1' }
+  before { @key2 = 'mock-redis-test:exists2' }
+
+  it 'returns 0 for keys that do not exist' do
+    @redises.exists(@key1).should == 0
+    @redises.exists(@key1, @key2).should == 0
+  end
+
+  it 'returns 1 for keys that do exist' do
+    @redises.set(@key1, 1)
+    @redises.exists(@key1).should == 1
+  end
+
+  it 'returns the count of all keys that exist' do
+    @redises.set(@key1, 1)
+    @redises.set(@key2, 1)
+    @redises.exists(@key1, @key2).should == 2
+    @redises.exists(@key1, @key2, 'does-not-exist').should == 2
+  end
+end
+
+describe '#exists?(*keys)' do
+  before { @key1 = 'mock-redis-test:exists1' }
+  before { @key2 = 'mock-redis-test:exists2' }
 
   it 'returns false for keys that do not exist' do
-    @redises.exists(@key).should == false
+    @redises.exists?(@key1).should == false
+    @redises.exists?(@key1, @key2).should == false
   end
 
   it 'returns true for keys that do exist' do
-    @redises.set(@key, 1)
-    @redises.exists(@key).should == true
+    @redises.set(@key1, 1)
+    @redises.exists?(@key1).should == true
+  end
+
+  it 'returns true if any keys exist' do
+    @redises.set(@key2, 1)
+    @redises.exists?(@key1, @key2).should == true
   end
 end

data/spec/commands/future_spec.rb

@@ -3,7 +3,12 @@ require 'spec_helper'
 describe MockRedis::Future do
   let(:command) { [:get, 'foo'] }
   let(:result)  { 'bar' }
-  before        { @future = MockRedis::Future.new(command) }
+  let(:block)   { ->(value) { value.upcase } }
+
+  before do
+    @future = MockRedis::Future.new(command)
+    @future2 = MockRedis::Future.new(command, block)
+  end
 
   it 'remembers the command' do
     @future.command.should eq(command)
@@ -17,4 +22,9 @@ describe MockRedis::Future do
     @future.store_result(result)
     @future.value.should eq(result)
   end
+
+  it 'executes the block on the value if block is passed in' do
+    @future2.store_result(result)
+    @future2.value.should eq('BAR')
+  end
 end

data/spec/commands/geoadd_spec.rb

@@ -33,7 +33,7 @@ describe '#geoadd' do
     context 'when coordinates are not in allowed range' do
       let(:coords) { [181, 86] }
       let(:message) do
-        formatted_coords = coords.map { |c| format('%.6f', c) }
+        formatted_coords = coords.map { |c| format('%<coords>.6f', coords: c) }
         "ERR invalid longitude,latitude pair #{formatted_coords.join(',')}"
       end
 

data/spec/commands/hmset_spec.rb

@@ -39,5 +39,31 @@ describe '#hmset(key, field, value [, field, value ...])' do
     end.should raise_error(Redis::CommandError)
   end
 
+  # The following tests address https://github.com/sds/mock_redis/issues/170
+  context 'keys are stored as strings' do
+    before do
+      @redises.hmset(1, :foo, :bar)
+      @redises.hmset(:a_sym, :boo, :bas)
+    end
+
+    it { expect(@redises.hgetall('1')).to eq @redises.hgetall(1) }
+    it { expect(@redises.hgetall('a_sym')).to eq @redises.hgetall(:a_sym) }
+    it { expect(@redises.del('1')).to eq 1 }
+    it { expect(@redises.del(1)).to eq 1 }
+    it { expect(@redises.del('a_sym')).to eq 1 }
+    it { expect(@redises.del(:a_sym)).to eq 1 }
+
+    after do
+      @redises.del(1)
+      @redises.del(:a_sym)
+    end
+  end
+
+  # The following tests address https://github.com/sds/mock_redis/issues/134
+  context 'hmset accepts an array as its only argument' do
+    it { expect(@redises.hmset([@key, :bar, :bas])).to eq 'OK' }
+    it { lambda { @redises.hmset([:foo, :bar]) }.should raise_error(Redis::CommandError) }
+  end
+
   it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hset_spec.rb

@@ -5,18 +5,18 @@ describe '#hset(key, field)' do
     @key = 'mock-redis-test:hset'
   end
 
-  it 'returns true if the key does not exist' do
-    @redises.hset(@key, 'k1', 'v1').should == true
+  it 'returns 1 if the key does not exist' do
+    @redises.hset(@key, 'k1', 'v1').should == 1
   end
 
-  it 'returns true if the key exists but the field does not' do
+  it 'returns 1 if the key exists but the field does not' do
     @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k2', 'v2').should == true
+    @redises.hset(@key, 'k2', 'v2').should == 1
   end
 
-  it 'returns false if the field already exists' do
+  it 'returns 0 if the field already exists' do
     @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k1', 'v1').should == false
+    @redises.hset(@key, 'k1', 'v1').should == 0
   end
 
   it 'creates a hash there is no such field' do

data/spec/commands/keys_spec.rb

@@ -29,6 +29,7 @@ describe '#keys()' do
 
       @redises.set('mock-redis-test:special-key?', 'true')
       @redises.set('mock-redis-test:special-key*', 'true')
+      @redises.set('mock-redis-test:special-key-!?*', 'true')
     end
 
     describe 'the ? character' do
@@ -53,6 +54,22 @@ describe '#keys()' do
           'mock-redis-test:special-key?',
         ]
       end
+
+      context 'multiple ? characters' do
+        it "properly handles multiple consequtive '?' characters" do
+          @redises.keys('mock-redis-test:special-key-???').sort.should == [
+            'mock-redis-test:special-key-!?*',
+          ]
+        end
+
+        context '\\? as a literal ' do
+          it 'handles multiple ? as both literal and special character' do
+            @redises.keys('mock-redis-test:special-key-?\??').sort.should == [
+              'mock-redis-test:special-key-!?*',
+            ]
+          end
+        end
+      end
     end
 
     describe 'the * character' do

data/spec/commands/mget_spec.rb

@@ -49,5 +49,11 @@ describe '#mget(key [, key, ...])' do
         @redises.mget
       end.should raise_error(Redis::CommandError)
     end
+
+    it 'raises an error if you pass it empty array' do
+      lambda do
+        @redises.mget([])
+      end.should raise_error(Redis::CommandError)
+    end
   end
 end

data/spec/commands/move_spec.rb

@@ -64,7 +64,7 @@ describe '#move(key, db)' do
     end
 
     it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
     end
 
     it 'copies key to destdb' do
@@ -81,7 +81,7 @@ describe '#move(key, db)' do
     end
 
     it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
     end
 
     it 'copies key to destdb' do
@@ -99,7 +99,7 @@ describe '#move(key, db)' do
     end
 
     it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
     end
 
     it 'copies key to destdb' do
@@ -117,7 +117,7 @@ describe '#move(key, db)' do
     end
 
     it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
     end
 
     it 'copies key to destdb' do
@@ -135,7 +135,7 @@ describe '#move(key, db)' do
     end
 
     it 'removes key from srcdb' do
-      @redises.exists(@key).should == false
+      @redises.exists?(@key).should == false
     end
 
     it 'copies key to destdb' do

data/spec/commands/pipelined_spec.rb

@@ -66,6 +66,26 @@ describe '#pipelined' do
     end
   end
 
+  context 'with redis time return value' 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) }
+
+    it 'returns the time value' do
+      subject.set('foo', 'bar')
+
+      results = subject.pipelined do
+        subject.get('foo')
+        subject.host # defined on MockRedis, so not captured
+        subject.time
+        subject.echo('baz')
+      end
+
+      expect(results).to eq(['bar', [1_546_398_246, 0], 'baz'])
+    end
+  end
+
   context 'with nested pipelines' do
     let(:key1)   { 'hello' }
     let(:key2)   { 'world' }

data/spec/commands/restore_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe '#restore(key, ttl, value)' do
+  before do
+    @key = 'mock-redis-test:45794'
+    @src = MockRedis.new
+    @src.set(@key, '123')
+    @dumped_value = @src.dump(@key)
+    @dst = MockRedis.new
+    @now = Time.now.round
+    Time.stub(:now).and_return(@now)
+  end
+
+  it 'allows dump/restoring values between two redis instances' do
+    expect(@dst.restore(@key, 0, @dumped_value)).to eq('OK')
+    expect(@dst.get(@key)).to eq('123')
+    expect(@dst.pttl(@key)).to eq(-1)
+  end
+
+  context 'when the key being restored to already exists' do
+    before do
+      @dst.set(@key, '456')
+    end
+
+    it 'raises an error by default' do
+      expect { @dst.restore(@key, 0, @dumped_value) }.to raise_error(Redis::CommandError)
+      expect(@dst.get(@key)).to eq('456')
+    end
+
+    it 'allows replacing the key if replace==true' do
+      expect(@dst.restore(@key, 0, @dumped_value, replace: true)).to eq('OK')
+      expect(@dst.get(@key)).to eq('123')
+    end
+  end
+
+  it 'sets ttl in ms' do
+    @dst.restore(@key, 500, @dumped_value)
+    expect(@dst.pttl(@key)).to eq(500)
+  end
+
+  it 'can dump/restore more complex data types' do
+    key = 'a_hash'
+    @src.mapped_hmset(key, foo: 'bar')
+    @dst.restore(key, 0, @src.dump(key))
+    expect(@dst.hgetall(key)).to eq('foo' => 'bar')
+  end
+end

data/spec/commands/scan_spec.rb

@@ -42,6 +42,15 @@ describe '#scan' do
       end
     end
 
+    context 'when cursor is greater than collection size' do
+      let(:collection) { Array.new(count) { |i| "mock:key#{i}" } }
+      let(:expected) { ['0', []] }
+
+      it 'returns a 0 cursor and empty collection' do
+        expect(subject.scan(20, count: count, match: match)).to eq(expected)
+      end
+    end
+
     context 'when giving a custom match filter' do
       let(:match) { 'mock:key*' }
       let(:collection) { %w[mock:key mock:key2 mock:otherkey] }

data/spec/commands/set_spec.rb

@@ -33,10 +33,12 @@ describe '#set(key, value)' do
       @redises.set(key, 1, xx: true).should == true
     end
 
-    it 'ignores other options' do
+    it 'raises on unknown options' do
       key = 'mock-redis-test'
       @redises.del(key)
-      @redises.set(key, 1, logger: :something).should == 'OK'
+      expect do
+        @redises.set(key, 1, logger: :something)
+      end.to raise_error(ArgumentError, 'unknown keyword: logger')
     end
 
     context '[mock only]' do
@@ -59,9 +61,11 @@ describe '#set(key, value)' do
 
       it 'accepts PX milliseconds' do
         key = 'mock-redis-test'
-        @mock.set(key, 1, px: 1000).should == 'OK'
+        @mock.set(key, 1, px: 500).should == 'OK'
         @mock.get(key).should_not be_nil
-        Time.stub(:now).and_return(@now + 2)
+        Time.stub(:now).and_return(@now + 300 / 1000.to_f)
+        @mock.get(key).should_not be_nil
+        Time.stub(:now).and_return(@now + 600 / 1000.to_f)
         @mock.get(key).should be_nil
       end
     end

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/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,66 @@
+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
+
+  it 'supports the block parameter' do
+    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-0')
+    expect(@redises.xread(@key, '0-0', block: 1000))
+      .to eq({ @key => [['1234567891234-0', { 'key' => 'value' }]] })
+  end
+
+  it 'limits results with count' do
+    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-0')
+    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-1')
+    @redises.xadd(@key, { key: 'value' }, id: '1234567891234-2')
+    expect(@redises.xread(@key, '0-0', count: 1))
+      .to eq({ @key => [['1234567891234-0', { 'key' => 'value' }]] })
+    expect(@redises.xread(@key, '1234567891234-0', count: 1))
+      .to eq({ @key => [['1234567891234-1', { 'key' => 'value' }]] })
+  end
+end