mock_redis 0.20.0 → 0.25.0

data/spec/client_spec.rb

@@ -14,4 +14,16 @@ describe 'client' do
       redis.connect.should == redis
     end
   end
+
+  context '#disconnect!' do
+    it 'responds to disconnect!' do
+      expect(MockRedis.new).to respond_to(:disconnect!)
+    end
+  end
+
+  context '#close' do
+    it 'responds to close' do
+      expect(MockRedis.new).to respond_to(:close)
+    end
+  end
 end

data/spec/commands/blpop_spec.rb

@@ -27,12 +27,6 @@ describe '#blpop(key [, key, ...,], timeout)' do
       [@list1, 'one']
   end
 
-  it 'raises an error on subsecond timeouts' do
-    lambda do
-      @redises.blpop(@list1, @list2, :timeout => 0.5)
-    end.should raise_error(Redis::CommandError)
-  end
-
   it 'raises an error on negative timeout' do
     lambda do
       @redises.blpop(@list1, @list2, :timeout => -1)

data/spec/commands/brpop_spec.rb

@@ -26,11 +26,12 @@ describe '#brpop(key [, key, ...,], timeout)' do
       [@list1, 'two']
   end
 
-  it 'raises an error on subsecond timeouts' do
-    lambda do
-      @redises.brpop(@list1, @list2, :timeout => 0.5)
-    end.should raise_error(Redis::CommandError)
-  end
+  # TODO: Not sure how redis-rb is handling this but they're not raising an error
+  # it 'raises an error on subsecond timeouts' do
+  #   lambda do
+  #     @redises.brpop(@list1, @list2, :timeout => 0.5)
+  #   end.should raise_error(Redis::CommandError)
+  # end
 
   it 'raises an error on negative timeout' do
     lambda do

data/spec/commands/del_spec.rb

@@ -1,6 +1,14 @@
 require 'spec_helper'
 
 describe '#del(key [, key, ...])' do
+  before :all do
+    sleep 1 - (Time.now.to_f % 1)
+  end
+
+  before :each do
+    @redises._gsub(/\d{3}-\d/, '...-.')
+  end
+
   it 'returns the number of keys deleted' do
     @redises.set('mock-redis-test:1', 1)
     @redises.set('mock-redis-test:2', 1)
@@ -32,4 +40,11 @@ describe '#del(key [, key, ...])' do
   it 'raises an error if an empty array is given' do
     expect { @redises.del [] }.to raise_error Redis::CommandError
   end
+
+  it 'removes a stream key' do
+    @redises.xadd('mock-redis-stream', { key: 'value' }, maxlen: 0)
+    expect(@redises.exists?('mock-redis-stream')).to eq true
+    @redises.del('mock-redis-stream')
+    expect(@redises.exists?('mock-redis-stream')).to eq false
+  end
 end

data/spec/commands/dump_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe '#dump(key)' do
+  before do
+    @key = 'mock-redis-test:45794'
+    # These are mock-only, since our dump/restore implementations
+    # aren't compatible with real redis.
+    @mock = @redises.mock
+  end
+
+  it 'returns nil for keys that do not exist' do
+    @mock.dump(@key).should be_nil
+  end
+
+  it 'returns a serialized value for keys that do exist' do
+    @mock.set(@key, '2')
+    @mock.dump(@key).should == Marshal.dump('2')
+  end
+end

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/hdel_spec.rb

@@ -50,5 +50,21 @@ describe '#hdel(key, field)' do
     @redises.hget(@key, field).should be_nil
   end
 
+  it 'supports a variable number of fields as array' do
+    @redises.hdel(@key, %w[k1 k2]).should == 2
+
+    @redises.hget(@key, 'k1').should be_nil
+    @redises.hget(@key, 'k2').should be_nil
+    @redises.get(@key).should be_nil
+  end
+
+  it 'supports a list of fields in various way' do
+    @redises.hdel(@key, ['k1'], 'k2').should == 2
+
+    @redises.hget(@key, 'k1').should be_nil
+    @redises.hget(@key, 'k2').should be_nil
+    @redises.get(@key).should be_nil
+  end
+
   it_should_behave_like 'a hash-only command'
 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,6 +33,14 @@ describe '#set(key, value)' do
       @redises.set(key, 1, xx: true).should == true
     end
 
+    it 'raises on unknown options' do
+      key = 'mock-redis-test'
+      @redises.del(key)
+      expect do
+        @redises.set(key, 1, logger: :something)
+      end.to raise_error(ArgumentError, 'unknown keyword: logger')
+    end
+
     context '[mock only]' do
       before(:all) do
         @mock = @redises.mock
@@ -53,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