mock_redis 0.5.4 → 0.31.0

data/spec/commands/blpop_spec.rb

@@ -11,44 +11,42 @@ describe '#blpop(key [, key, ...,], timeout)' do
     @redises.rpush(@list2, 'eleven')
   end
 
-  it "returns [first-nonempty-list, popped-value]" do
-    @redises.blpop(@list1, @list2, 1).should == [@list1, 'one']
+  it 'returns [first-nonempty-list, popped-value]' do
+    @redises.blpop(@list1, @list2).should == [@list1, 'one']
   end
 
-  it "pops that value off the list" do
-    @redises.blpop(@list1, @list2, 1)
-    @redises.blpop(@list1, @list2, 1)
+  it 'pops that value off the list' do
+    @redises.blpop(@list1, @list2)
+    @redises.blpop(@list1, @list2)
 
-    @redises.blpop(@list1, @list2, 1).should == [@list2, 'ten']
+    @redises.blpop(@list1, @list2).should == [@list2, 'ten']
   end
 
-  it "ignores empty keys" do
-    @redises.blpop('mock-redis-test:not-here', @list1, 1).should ==
+  it 'ignores empty keys' do
+    @redises.blpop('mock-redis-test:not-here', @list1).should ==
       [@list1, 'one']
   end
 
-  it "allows subsecond timeouts" do
+  it 'raises an error on negative timeout' do
     lambda do
-      @redises.blpop(@list1, @list2, 0.5)
-    end.should_not raise_error(Redis::CommandError)
-  end
-
-  it "raises an error on negative timeout" do
-    lambda do
-      @redises.blpop(@list1, @list2, -1)
+      @redises.blpop(@list1, @list2, :timeout => -1)
     end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
+
+  context '[mock only]' do
+    it 'ignores positive timeouts and returns nil' do
+      @redises.mock.blpop('mock-redis-test:not-here', :timeout => 1).should be_nil
+    end
 
-  context "[mock only]" do
-    it "ignores positive timeouts and returns nil" do
+    it 'ignores positive legacy timeouts and returns nil' do
       @redises.mock.blpop('mock-redis-test:not-here', 1).should be_nil
     end
 
-    it "raises WouldBlock on zero timeout (no blocking in the mock)" do
+    it 'raises WouldBlock on zero timeout (no blocking in the mock)' do
       lambda do
-        @redises.mock.blpop('mock-redis-test:not-here', 0)
+        @redises.mock.blpop('mock-redis-test:not-here', :timeout => 0)
       end.should raise_error(MockRedis::WouldBlock)
     end
   end

data/spec/commands/brpop_spec.rb

@@ -11,43 +11,48 @@ describe '#brpop(key [, key, ...,], timeout)' do
     @redises.rpush(@list2, 'ten')
   end
 
-  it "returns [first-nonempty-list, popped-value]" do
-    @redises.brpop(@list1, @list2, 1).should == [@list1, 'two']
+  it 'returns [first-nonempty-list, popped-value]' do
+    @redises.brpop(@list1, @list2).should == [@list1, 'two']
   end
 
-  it "pops that value off the list" do
-    @redises.brpop(@list1, @list2, 1)
-    @redises.brpop(@list1, @list2, 1)
-    @redises.brpop(@list1, @list2, 1).should == [@list2, 'ten']
+  it 'pops that value off the list' do
+    @redises.brpop(@list1, @list2)
+    @redises.brpop(@list1, @list2)
+    @redises.brpop(@list1, @list2).should == [@list2, 'ten']
   end
 
-  it "ignores empty keys" do
-    @redises.brpop('mock-redis-test:not-here', @list1, 1).should ==
+  it 'ignores empty keys' do
+    @redises.brpop('mock-redis-test:not-here', @list1).should ==
       [@list1, 'two']
   end
 
-  it "allows subsecond timeouts" do
-    lambda do
-      @redises.brpop(@list1, @list2, 0.5)
-    end.should_not 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
+  it 'raises an error on negative timeout' do
     lambda do
-      @redises.brpop(@list1, @list2, -1)
+      @redises.brpop(@list1, @list2, :timeout => -1)
     end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
+
+  context '[mock only]' do
+    it 'ignores positive timeouts and returns nil' do
+      @redises.mock.brpop('mock-redis-test:not-here', :timeout => 1).should be_nil
+    end
 
-  context "[mock only]" do
-    it "ignores positive timeouts and returns nil" do
+    it 'ignores positive legacy timeouts and returns nil' do
       @redises.mock.brpop('mock-redis-test:not-here', 1).should be_nil
     end
 
-    it "raises WouldBlock on zero timeout (no blocking in the mock)" do
+    it 'raises WouldBlock on zero timeout (no blocking in the mock)' do
       lambda do
-        @redises.mock.brpop('mock-redis-test:not-here', 0)
+        @redises.mock.brpop('mock-redis-test:not-here', :timeout => 0)
       end.should raise_error(MockRedis::WouldBlock)
     end
   end

data/spec/commands/brpoplpush_spec.rb

@@ -14,39 +14,38 @@ describe '#brpoplpush(source, destination, timeout)' do
     @redises.rpush(@list2, 'beta')
   end
 
-  it "takes the last element of source and prepends it to destination" do
-    @redises.brpoplpush(@list1, @list2, 0)
+  it 'takes the last element of source and prepends it to destination' do
+    @redises.brpoplpush(@list1, @list2)
     @redises.lrange(@list1, 0, -1).should == %w[A]
     @redises.lrange(@list2, 0, -1).should == %w[B alpha beta]
   end
 
-  it "returns the moved element" do
-    @redises.brpoplpush(@list1, @list2, 0).should == "B"
+  it 'returns the moved element' do
+    @redises.brpoplpush(@list1, @list2).should == 'B'
   end
 
-  it "allows subsecond timeout" do
+  it 'raises an error on negative timeout' do
     lambda do
-      @redises.brpoplpush(@list1, @list2, 0.5)
-    end.should_not raise_error(Redis::CommandError)
-  end
-
-  it "raises an error on negative timeout" do
-    lambda do
-      @redises.brpoplpush(@list1, @list2, -1)
+      @redises.brpoplpush(@list1, @list2, :timeout => -1)
     end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
+
+  context '[mock only]' do
+    it 'ignores positive timeouts and returns nil' do
+      @redises.mock.brpoplpush('mock-redis-test:not-here', @list1, :timeout => 1).
+        should be_nil
+    end
 
-  context "[mock only]" do
-    it "ignores positive timeouts and returns nil" do
+    it 'ignores positive legacy timeouts and returns nil' do
       @redises.mock.brpoplpush('mock-redis-test:not-here', @list1, 1).
         should be_nil
     end
 
-    it "raises WouldBlock on zero timeout (no blocking in the mock)" do
+    it 'raises WouldBlock on zero timeout (no blocking in the mock)' do
       lambda do
-        @redises.mock.brpoplpush('mock-redis-test:not-here', @list1, 0)
+        @redises.mock.brpoplpush('mock-redis-test:not-here', @list1, :timeout => 0)
       end.should raise_error(MockRedis::WouldBlock)
     end
   end

data/spec/commands/connected_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe '#connected? [mock only]' do
+  it 'returns true' do
+    @redises.mock.connected?.should == true
+  end
+end

data/spec/commands/connection_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe '#connection' do
+  let(:redis) { @redises.mock }
+
+  it 'returns the correct values' do
+    redis.connection.should == {
+      :host => '127.0.0.1',
+      :port => 6379,
+      :db => 0,
+      :id => 'redis://127.0.0.1:6379/0',
+      :location => '127.0.0.1:6379'
+    }
+  end
+end

data/spec/commands/dbsize_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
-describe "#dbsize [mock only]" do
+describe '#dbsize [mock only]' do
   # mock only since we can't guarantee that the real Redis is empty
   before { @mock = @redises.mock }
 
-  it "returns 0 for an empty DB" do
+  it 'returns 0 for an empty DB' do
     @mock.dbsize.should == 0
   end
 
-  it "returns the number of keys in the DB" do
+  it 'returns the number of keys in the DB' do
     @mock.set('foo', 1)
     @mock.lpush('bar', 2)
     @mock.hset('baz', 3, 4)

data/spec/commands/decr_spec.rb

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe '#decr(key)' do
   before { @key = 'mock-redis-test:46895' }
 
-  it "returns the value after the decrement" do
+  it 'returns the value after the decrement' do
     @redises.set(@key, 2)
     @redises.decr(@key).should == 1
   end
 
-  it "treats a missing key like 0" do
+  it 'treats a missing key like 0' do
     @redises.decr(@key).should == -1
   end
 
-  it "decrements negative numbers" do
+  it 'decrements negative numbers' do
     @redises.set(@key, -10)
     @redises.decr(@key).should == -11
   end
 
-  it "works multiple times" do
+  it 'works multiple times' do
     @redises.decr(@key).should == -1
     @redises.decr(@key).should == -2
     @redises.decr(@key).should == -3
   end
 
-  it "raises an error if the value does not look like an integer" do
-    @redises.set(@key, "minus one")
+  it 'raises an error if the value does not look like an integer' do
+    @redises.set(@key, 'minus one')
     lambda do
       @redises.decr(@key)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a string-only command"
+  it_should_behave_like 'a string-only command'
 end

data/spec/commands/decrby_spec.rb

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe '#decrby(key, decrement)' do
   before { @key = 'mock-redis-test:43650' }
 
-  it "returns the value after the decrement" do
+  it 'returns the value after the decrement' do
     @redises.set(@key, 4)
     @redises.decrby(@key, 2).should == 2
   end
 
-  it "treats a missing key like 0" do
+  it 'treats a missing key like 0' do
     @redises.decrby(@key, 2).should == -2
   end
 
-  it "decrements negative numbers" do
+  it 'decrements negative numbers' do
     @redises.set(@key, -10)
     @redises.decrby(@key, 2).should == -12
   end
 
-  it "works multiple times" do
+  it 'works multiple times' do
     @redises.decrby(@key, 2).should == -2
     @redises.decrby(@key, 2).should == -4
     @redises.decrby(@key, 2).should == -6
   end
 
-  it "raises an error if the value does not look like an integer" do
-    @redises.set(@key, "one")
+  it 'raises an error if the value does not look like an integer' do
+    @redises.set(@key, 'one')
     lambda do
       @redises.decrby(@key, 1)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a string-only command"
+  it_should_behave_like 'a string-only command'
 end

data/spec/commands/del_spec.rb

@@ -1,20 +1,52 @@
 require 'spec_helper'
 
 describe '#del(key [, key, ...])' do
-  it "returns the number of keys deleted" do
+  before :all do
+    sleep 1 - (Time.now.to_f % 1)
+  end
+
+  before :each do
+    # TODO: Redis appears to be returning a timestamp a few seconds in the future
+    # so we're ignoring the last 5 digits (time in milliseconds)
+    @redises._gsub(/\d{5}-\d/, '...-.')
+  end
+
+  it 'returns the number of keys deleted' do
     @redises.set('mock-redis-test:1', 1)
     @redises.set('mock-redis-test:2', 1)
 
     @redises.del(
       'mock-redis-test:1',
       'mock-redis-test:2',
-      'mock-redis-test:other').should == 2
+      'mock-redis-test:other'
+    ).should == 2
   end
 
-  it "actually removes the key" do
+  it 'actually removes the key' do
     @redises.set('mock-redis-test:1', 1)
     @redises.del('mock-redis-test:1')
 
     @redises.get('mock-redis-test:1').should be_nil
   end
+
+  it 'accepts an array of keys' do
+    @redises.set('mock-redis-test:1', 1)
+    @redises.set('mock-redis-test:2', 2)
+
+    @redises.del(%w[mock-redis-test:1 mock-redis-test:2])
+
+    @redises.get('mock-redis-test:1').should be_nil
+    @redises.get('mock-redis-test:2').should be_nil
+  end
+
+  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/disconnect_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe '#disconnect [mock only]' do
+  it 'returns nil' do
+    @redises.mock.disconnect.should be_nil
+  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/echo_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe "#echo(str)" do
-  it "returns its argument" do
+describe '#echo(str)' do
+  it 'returns its argument' do
     @redises.echo('foo').should == 'foo'
   end
 
-  it "stringifies its argument" do
-    @redises.echo(1).should == "1"
+  it 'stringifies its argument' do
+    @redises.echo(1).should == '1'
   end
 end

data/spec/commands/eval_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe '#eval(*)' do
+  it 'returns nothing' do
+    @redises.eval('return nil').should be_nil
+  end
+end

data/spec/commands/evalsha_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe '#evalsha(*)' do
+  let(:script) { 'return nil' }
+  let(:script_digest) { Digest::SHA1.hexdigest(script) }
+
+  it 'returns nothing' do
+    @redises.evalsha(script_digest).should be_nil
+  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 false for keys that do not exist" do
-    @redises.exists(@key).should be_false
+  it 'returns 0 for keys that do not exist' do
+    @redises.exists(@key1).should == 0
+    @redises.exists(@key1, @key2).should == 0
   end
 
-  it "returns true for keys that do exist" do
-    @redises.set(@key, 1)
-    @redises.exists(@key).should be_true
+  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?(@key1).should == false
+    @redises.exists?(@key1, @key2).should == false
+  end
+
+  it 'returns true for keys that do exist' do
+    @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/expire_spec.rb

@@ -1,31 +1,35 @@
 require 'spec_helper'
 
-describe "#expire(key, seconds)" do
+describe '#expire(key, seconds)' do
   before do
     @key = 'mock-redis-test:expire'
     @redises.set(@key, 'spork')
   end
 
-  it "returns true for a key that exists" do
-    @redises.expire(@key, 1).should be_true
+  it 'returns true for a key that exists' do
+    @redises.expire(@key, 1).should == true
   end
 
-  it "returns false for a key that does not exist" do
-    @redises.expire('mock-redis-test:nonesuch', 1).should be_false
+  it 'returns false for a key that does not exist' do
+    @redises.expire('mock-redis-test:nonesuch', 1).should == false
   end
 
-  it "removes a key immediately when seconds==0" do
+  it 'removes a key immediately when seconds==0' do
     @redises.expire(@key, 0)
     @redises.get(@key).should be_nil
   end
 
-  it "raises an error if seconds is bogus" do
+  it 'raises an error if seconds is bogus' do
     lambda do
-      @redises.expireat(@key, 'a couple minutes or so')
-    end.should raise_error(RuntimeError)
+      @redises.expire(@key, 'a couple minutes or so')
+    end.should raise_error(Redis::CommandError)
   end
 
-  context "[mock only]" do
+  it 'stringifies key' do
+    @redises.expire(@key.to_sym, 9).should == true
+  end
+
+  context '[mock only]' do
     # These are mock-only since we can't actually manipulate time in
     # the real Redis.
 
@@ -35,49 +39,73 @@ describe "#expire(key, seconds)" do
 
     before do
       @now = Time.now
-      Time.stub!(:now).and_return(@now)
+      Time.stub(:now).and_return(@now)
     end
 
-    it "removes keys after enough time has passed" do
+    it 'removes keys after enough time has passed' do
       @mock.expire(@key, 5)
-      Time.stub!(:now).and_return(@now + 5)
+      Time.stub(:now).and_return(@now + 5)
       @mock.get(@key).should be_nil
     end
 
-    it "updates an existing expire time" do
+    it 'updates an existing expire time' do
       @mock.expire(@key, 5)
       @mock.expire(@key, 6)
 
-      Time.stub!(:now).and_return(@now + 5) 
+      Time.stub(:now).and_return(@now + 5)
+      @mock.get(@key).should_not be_nil
+    end
+
+    it 'has millisecond precision' do
+      @now = Time.at(@now.to_i + 0.5)
+      Time.stub(:now).and_return(@now)
+      @mock.expire(@key, 5)
+      Time.stub(:now).and_return(@now + 4.9)
       @mock.get(@key).should_not be_nil
     end
 
-    context "expirations on a deleted key" do
+    context 'expirations on a deleted key' do
       before { @mock.del(@key) }
 
-      it "cleans up the expiration once the key is gone (string)" do
+      it 'cleans up the expiration once the key is gone (string)' do
         @mock.set(@key, 'string')
         @mock.expire(@key, 2)
         @mock.del(@key)
         @mock.set(@key, 'string')
 
-        Time.stub!(:now).and_return(@now + 2)
+        Time.stub(:now).and_return(@now + 2)
 
         @mock.get(@key).should_not be_nil
       end
 
-      it "cleans up the expiration once the key is gone (list)" do
+      it 'cleans up the expiration once the key is gone (list)' do
         @mock.rpush(@key, 'coconuts')
         @mock.expire(@key, 2)
         @mock.rpop(@key)
 
         @mock.rpush(@key, 'coconuts')
 
-        Time.stub!(:now).and_return(@now + 2)
+        Time.stub(:now).and_return(@now + 2)
 
         @mock.lindex(@key, 0).should_not be_nil
       end
     end
 
+    context 'with two key expirations' do
+      let(:other_key) { 'mock-redis-test:expire-other' }
+
+      before { @redises.set(other_key, 'spork-other') }
+
+      it 'removes keys after enough time has passed' do
+        @mock.expire(@key, 5)
+        @mock.expire(other_key, 10)
+
+        Time.stub(:now).and_return(@now + 5)
+        @mock.get(@key).should be_nil
+
+        Time.stub(:now).and_return(@now + 10)
+        @mock.get(other_key).should be_nil
+      end
+    end
   end
 end