mock_redis 0.5.4 → 0.31.0

data/spec/commands/move_spec.rb

@@ -8,7 +8,7 @@ describe '#move(key, db)' do
     @key = 'mock-redis-test:move'
   end
 
-  context "when key exists in destdb" do
+  context 'when key exists in destdb' do
     before do
       @redises.set(@key, 'srcvalue')
       @redises.select(@destdb)
@@ -16,81 +16,81 @@ describe '#move(key, db)' do
       @redises.select(@srcdb)
     end
 
-    it "returns false" do
-      @redises.move(@key, @destdb).should be_false
+    it 'returns false' do
+      @redises.move(@key, @destdb).should == false
     end
 
-    it "leaves destdb/key alone" do
+    it 'leaves destdb/key alone' do
       @redises.select(@destdb)
-      @redises.get(@key).should == "destvalue"
+      @redises.get(@key).should == 'destvalue'
     end
 
-    it "leaves srcdb/key alone" do
-      @redises.get(@key).should == "srcvalue"
+    it 'leaves srcdb/key alone' do
+      @redises.get(@key).should == 'srcvalue'
     end
   end
 
-  context "when key does not exist in srcdb" do
+  context 'when key does not exist in srcdb' do
     before do
       @redises.select(@destdb)
       @redises.set(@key, 'destvalue')
       @redises.select(@srcdb)
     end
 
-    it "returns false" do
-      @redises.move(@key, @destdb).should be_false
+    it 'returns false' do
+      @redises.move(@key, @destdb).should == false
     end
 
-    it "leaves destdb/key alone" do
+    it 'leaves destdb/key alone' do
       @redises.select(@destdb)
-      @redises.get(@key).should == "destvalue"
+      @redises.get(@key).should == 'destvalue'
     end
   end
 
-  context "when key exists in the currently-selected DB and not in db" do
+  context 'when key exists in the currently-selected DB and not in db' do
     before do
       @redises.set(@key, 'value')
     end
 
-    it "returns true" do
-      @redises.move(@key, @destdb).should be_true
+    it 'returns true' do
+      @redises.move(@key, @destdb).should == true
     end
   end
 
-  context "on a string" do
+  context 'on a string' do
     before do
       @redises.set(@key, 'value')
       @redises.move(@key, @destdb)
     end
 
-    it "removes key from srcdb" do
-      @redises.exists(@key).should be_false
+    it 'removes key from srcdb' do
+      @redises.exists?(@key).should == false
     end
 
-    it "copies key to destdb" do
+    it 'copies key to destdb' do
       @redises.select(@destdb)
       @redises.get(@key).should == 'value'
     end
   end
 
-  context "on a list" do
+  context 'on a list' do
     before do
       @redises.rpush(@key, 'bert')
       @redises.rpush(@key, 'ernie')
       @redises.move(@key, @destdb)
     end
 
-    it "removes key from srcdb" do
-      @redises.exists(@key).should be_false
+    it 'removes key from srcdb' do
+      @redises.exists?(@key).should == false
     end
 
-    it "copies key to destdb" do
+    it 'copies key to destdb' do
       @redises.select(@destdb)
       @redises.lrange(@key, 0, -1).should == %w[bert ernie]
     end
   end
 
-  context "on a hash" do
+  context 'on a hash' do
     before do
       @redises.hset(@key, 'a', 1)
       @redises.hset(@key, 'b', 2)
@@ -98,17 +98,17 @@ describe '#move(key, db)' do
       @redises.move(@key, @destdb)
     end
 
-    it "removes key from srcdb" do
-      @redises.exists(@key).should be_false
+    it 'removes key from srcdb' do
+      @redises.exists?(@key).should == false
     end
 
-    it "copies key to destdb" do
+    it 'copies key to destdb' do
       @redises.select(@destdb)
-      @redises.hgetall(@key).should == {'a' => "1", 'b' => "2"}
+      @redises.hgetall(@key).should == { 'a' => '1', 'b' => '2' }
     end
   end
 
-  context "on a set" do
+  context 'on a set' do
     before do
       @redises.sadd(@key, 'beer')
       @redises.sadd(@key, 'wine')
@@ -116,17 +116,17 @@ describe '#move(key, db)' do
       @redises.move(@key, @destdb)
     end
 
-    it "removes key from srcdb" do
-      @redises.exists(@key).should be_false
+    it 'removes key from srcdb' do
+      @redises.exists?(@key).should == false
     end
 
-    it "copies key to destdb" do
+    it 'copies key to destdb' do
       @redises.select(@destdb)
       @redises.smembers(@key).should == %w[wine beer]
     end
   end
 
-  context "on a zset" do
+  context 'on a zset' do
     before do
       @redises.zadd(@key, 1, 'beer')
       @redises.zadd(@key, 2, 'wine')
@@ -134,14 +134,14 @@ describe '#move(key, db)' do
       @redises.move(@key, @destdb)
     end
 
-    it "removes key from srcdb" do
-      @redises.exists(@key).should be_false
+    it 'removes key from srcdb' do
+      @redises.exists?(@key).should == false
     end
 
-    it "copies key to destdb" do
+    it 'copies key to destdb' do
       @redises.select(@destdb)
       @redises.zrange(@key, 0, -1, :with_scores => true).should ==
-        [["beer", 1.0], ["wine", 2.0]]
+        [['beer', 1.0], ['wine', 2.0]]
     end
   end
 end

data/spec/commands/mset_spec.rb

@@ -10,20 +10,34 @@ describe '#mset(key, value [, key, value, ...])' do
     @redises.mset(@key1, 1).should == 'OK'
   end
 
-  it "sets the values" do
+  it "responds with 'OK' for passed Array with 1 item" do
+    @redises.mset([@key1, 1]).should == 'OK'
+  end
+
+  it "responds with 'OK' for passed Array with 2 items" do
+    @redises.mset([@key1, 1, @key2, 2]).should == 'OK'
+  end
+
+  it 'sets the values' do
     @redises.mset(@key1, 'value1', @key2, 'value2')
     @redises.mget(@key1, @key2).should == %w[value1 value2]
   end
 
-  it "raises an error if given an odd number of arguments" do
+  it 'raises an error if given an odd number of arguments' do
     lambda do
       @redises.mset(@key1, 'value1', @key2)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it 'raises an error if given 0 arguments' do
+    lambda do
+      @redises.mset
+    end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if given 0 arguments" do
+  it 'raises an error if given odd-sized array' do
     lambda do
-      @redises.mset()
-    end.should raise_error(RuntimeError)
+      @redises.mset([@key1, 1, @key2])
+    end.should raise_error(Redis::CommandError)
   end
 end

data/spec/commands/msetnx_spec.rb

@@ -6,35 +6,35 @@ describe '#msetnx(key, value [, key, value, ...])' do
     @key2 = 'mock-redis-test:msetnx2'
   end
 
-  it "responds with 1 if any keys were set" do
-    @redises.msetnx(@key1, 1).should be_true
+  it 'responds with 1 if any keys were set' do
+    @redises.msetnx(@key1, 1).should == true
   end
 
-  it "sets the values" do
+  it 'sets the values' do
     @redises.msetnx(@key1, 'value1', @key2, 'value2')
     @redises.mget(@key1, @key2).should == %w[value1 value2]
   end
 
-  it "does nothing if any value is already set" do
-    @redises.set(@key1, "old1")
+  it 'does nothing if any value is already set' do
+    @redises.set(@key1, 'old1')
     @redises.msetnx(@key1, 'value1', @key2, 'value2')
-    @redises.mget(@key1, @key2).should == ["old1", nil]
+    @redises.mget(@key1, @key2).should == ['old1', nil]
   end
 
-  it "responds with 0 if any value is already set" do
-    @redises.set(@key1, "old1")
-    @redises.msetnx(@key1, 'value1', @key2, 'value2').should be_false
+  it 'responds with 0 if any value is already set' do
+    @redises.set(@key1, 'old1')
+    @redises.msetnx(@key1, 'value1', @key2, 'value2').should == false
   end
 
-  it "raises an error if given an odd number of arguments" do
+  it 'raises an error if given an odd number of arguments' do
     lambda do
       @redises.msetnx(@key1, 'value1', @key2)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if given 0 arguments" do
+  it 'raises an error if given 0 arguments' do
     lambda do
-      @redises.msetnx()
-    end.should raise_error(RuntimeError)
+      @redises.msetnx
+    end.should raise_error(Redis::CommandError)
   end
 end

data/spec/commands/persist_spec.rb

@@ -1,31 +1,31 @@
 require 'spec_helper'
 
-describe "#persist(key)" do
+describe '#persist(key)' do
   before do
     @key = 'mock-redis-test:persist'
     @redises.set(@key, 'spork')
   end
 
-  it "returns true for a key with a timeout" do
-    @redises.expire(@key, 10000)
-    @redises.persist(@key).should be_true
+  it 'returns true for a key with a timeout' do
+    @redises.expire(@key, 10_000)
+    @redises.persist(@key).should == true
   end
 
-  it "returns false for a key with no timeout" do
-    @redises.persist(@key).should be_false
+  it 'returns false for a key with no timeout' do
+    @redises.persist(@key).should == false
   end
 
-  it "returns false for a key that does not exist" do
-    @redises.persist('mock-redis-test:nonesuch').should be_false
+  it 'returns false for a key that does not exist' do
+    @redises.persist('mock-redis-test:nonesuch').should == false
   end
 
-  it "removes the timeout" do
-    @redises.expire(@key, 10000)
+  it 'removes the timeout' do
+    @redises.expire(@key, 10_000)
     @redises.persist(@key)
-    @redises.persist(@key).should be_false
+    @redises.persist(@key).should == false
   end
 
-  context "[mock only]" do
+  context '[mock only]' do
     # These are mock-only since we can't actually manipulate time in
     # the real Redis.
 
@@ -35,15 +35,14 @@ describe "#persist(key)" do
 
     before do
       @now = Time.now
-      Time.stub!(:now).and_return(@now)
+      Time.stub(:now).and_return(@now)
     end
 
-    it "makes keys stay around" do
+    it 'makes keys stay around' do
       @mock.expire(@key, 5)
       @mock.persist(@key)
-      Time.stub!(:now).and_return(@now + 5)
+      Time.stub(:now).and_return(@now + 5)
       @mock.get(@key).should_not be_nil
     end
-
   end
 end

data/spec/commands/pexpire_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe '#pexpire(key, ms)' do
+  before do
+    @key = 'mock-redis-test:pexpire'
+    @redises.set(@key, 'spork')
+  end
+
+  it 'returns true for a key that exists' do
+    @redises.pexpire(@key, 1).should == true
+  end
+
+  it 'returns false for a key that does not exist' do
+    @redises.pexpire('mock-redis-test:nonesuch', 1).should == false
+  end
+
+  it 'removes a key immediately when ms==0' do
+    @redises.pexpire(@key, 0)
+    @redises.get(@key).should be_nil
+  end
+
+  it 'raises an error if ms is bogus' do
+    lambda do
+      @redises.pexpire(@key, 'a couple minutes or so')
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it 'stringifies key' do
+    @redises.pexpire(@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.
+
+    before(:all) do
+      @mock = @redises.mock
+    end
+
+    before do
+      @now = Time.now.round
+      Time.stub(:now).and_return(@now)
+    end
+
+    it 'removes keys after enough time has passed' do
+      @mock.pexpire(@key, 5)
+      Time.stub(:now).and_return(@now + Rational(6, 1000))
+      @mock.get(@key).should be_nil
+    end
+
+    it 'updates an existing pexpire time' do
+      @mock.pexpire(@key, 5)
+      @mock.pexpire(@key, 6)
+
+      Time.stub(:now).and_return(@now + Rational(5, 1000))
+      @mock.get(@key).should_not be_nil
+    end
+
+    context 'expirations on a deleted key' do
+      before { @mock.del(@key) }
+
+      it 'cleans up the expiration once the key is gone (string)' do
+        @mock.set(@key, 'string')
+        @mock.pexpire(@key, 2)
+        @mock.del(@key)
+        @mock.set(@key, 'string')
+
+        Time.stub(:now).and_return(@now + 0.003)
+
+        @mock.get(@key).should_not be_nil
+      end
+
+      it 'cleans up the expiration once the key is gone (list)' do
+        @mock.rpush(@key, 'coconuts')
+        @mock.pexpire(@key, 2)
+        @mock.rpop(@key)
+
+        @mock.rpush(@key, 'coconuts')
+
+        Time.stub(:now).and_return(@now + 0.003)
+
+        @mock.lindex(@key, 0).should_not be_nil
+      end
+    end
+  end
+end

data/spec/commands/pexpireat_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe '#pexpireat(key, timestamp_ms)' do
+  before do
+    @key = 'mock-redis-test:pexpireat'
+    @redises.set(@key, 'spork')
+  end
+
+  it 'returns true for a key that exists' do
+    @redises.pexpireat(@key, (Time.now.to_f * 1000).to_i + 1).should == true
+  end
+
+  it 'returns false for a key that does not exist' do
+    @redises.pexpireat('mock-redis-test:nonesuch',
+                       (Time.now.to_f * 1000).to_i + 1).should == false
+  end
+
+  it 'removes a key immediately when timestamp is now' do
+    @redises.pexpireat(@key, (Time.now.to_f * 1000).to_i)
+    @redises.get(@key).should be_nil
+  end
+
+  it "raises an error if you don't give it a Unix timestamp" do
+    lambda do
+      @redises.pexpireat(@key, Time.now) # oops, forgot .to_i
+    end.should raise_error(Redis::CommandError)
+  end
+
+  context '[mock only]' do
+    # These are mock-only since we can't actually manipulate time in
+    # the real Redis.
+
+    before(:all) do
+      @mock = @redises.mock
+    end
+
+    before do
+      @now = Time.now
+      Time.stub(:now).and_return(@now)
+    end
+
+    it 'removes keys after enough time has passed' do
+      @mock.pexpireat(@key, (@now.to_f * 1000).to_i + 5)
+      Time.stub(:now).and_return(@now + 0.006)
+      @mock.get(@key).should be_nil
+    end
+  end
+end

data/spec/commands/ping_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
-describe "#ping" do
-  it "returns 'PONG'" do
+describe '#ping' do
+  it 'returns "PONG" with no arguments' do
     @redises.ping.should == 'PONG'
   end
+
+  it 'returns the argument' do
+    @redises.ping('HELLO').should == 'HELLO'
+  end
 end

data/spec/commands/pipelined_spec.rb

@@ -9,15 +9,106 @@ describe '#pipelined' do
     res.should == true
   end
 
-  it "returns results of pipelined operations" do
-    @redises.set "hello", "world"
-    @redises.set "foo", "bar"
+  context 'with a few added data' do
+    let(:key1)   { 'hello' }
+    let(:key2)   { 'world' }
+    let(:value1) { 'foo' }
+    let(:value2) { 'bar' }
 
-    results = @redises.pipelined do
-      @redises.get "hello"
-      @redises.get "foo"
+    before do
+      @redises.set key1, value1
+      @redises.set key2, value2
     end
 
-    results.should == ["world", "bar"]
+    it 'returns results of pipelined operations' do
+      results = @redises.pipelined do |redis|
+        redis.get key1
+        redis.get key2
+      end
+
+      results.should == [value1, value2]
+    end
+
+    it 'returns futures' do
+      future = nil
+
+      @redises.mock.pipelined do |redis|
+        future = redis.get key1
+      end
+
+      future.class.should be MockRedis::Future
+    end
+  end
+
+  context 'with pipelined operations returning array replies' do
+    let(:key1) { 'colors' }
+    let(:key2) { 'seasons' }
+    let(:value1) { %w[blue yellow] }
+    let(:value2) { %w[summer winter] }
+
+    before do
+      @redises.rpush(key1, value1)
+      @redises.rpush(key2, value2)
+    end
+
+    after do
+      @redises.del key1
+      @redises.del key2
+    end
+
+    it 'returns an array of the array replies' do
+      results = @redises.pipelined do |_redis|
+        @redises.lrange(key1, 0, -1)
+        @redises.lrange(key2, 0, -1)
+      end
+
+      results.should == [value1, value2]
+    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' }
+    let(:value1) { 'foo' }
+    let(:value2) { 'bar' }
+
+    before do
+      @redises.set key1, value1
+      @redises.set key2, value2
+    end
+
+    it 'returns results of the nested pipelines' do
+      results = @redises.pipelined do |pr1|
+        pr1.pipelined do |pr2|
+          pr2.get key1
+        end
+
+        pr1.pipelined do |pr2|
+          pr2.get key2
+        end
+      end
+
+      results.should == [value1, value2]
+    end
   end
 end

data/spec/commands/pttl_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe '#pttl(key)' do
+  before do
+    @key = 'mock-redis-test:persist'
+    @redises.set(@key, 'spork')
+  end
+
+  it 'returns -1 for a key with no expiration' do
+    @redises.pttl(@key).should == -1
+  end
+
+  it 'returns -2 for a key that does not exist' do
+    @redises.pttl('mock-redis-test:nonesuch').should == -2
+  end
+
+  it 'stringifies key' do
+    @redises.expire(@key, 8)
+    # Don't check against Redis since millisecond timing differences are likely
+    @redises.send_without_checking(:pttl, @key.to_sym).should > 0
+  end
+
+  context '[mock only]' do
+    # These are mock-only since we can't actually manipulate time in
+    # the real Redis.
+
+    before(:all) do
+      @mock = @redises.mock
+    end
+
+    before do
+      @now = Time.now.round
+      Time.stub(:now).and_return(@now)
+    end
+
+    it "gives you the key's remaining lifespan in milliseconds" do
+      @mock.expire(@key, 5)
+      @mock.pttl(@key).should == 5000
+    end
+  end
+end

data/spec/commands/randomkey_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe '#randomkey [mock only]' do
   before { @mock = @redises.mock }
 
-  it "finds a random key" do
+  it 'finds a random key' do
     @keys = ['mock-redis-test:1', 'mock-redis-test:2', 'mock-redis-test:3']
 
     @keys.each do |k|
@@ -13,8 +13,8 @@ describe '#randomkey [mock only]' do
     @keys.should include(@mock.randomkey)
   end
 
-  it "returns nil when there are no keys" do
-    @mock.keys('*').each {|k| @mock.del(k)}
+  it 'returns nil when there are no keys' do
+    @mock.keys('*').each { |k| @mock.del(k) }
     @mock.randomkey.should be_nil
   end
 end