mock_redis 0.5.4 → 0.31.0

data/spec/commands/rename_spec.rb

@@ -5,34 +5,38 @@ describe '#rename(key, newkey)' do
     @key = 'mock-redis-test:rename:key'
     @newkey = 'mock-redis-test:rename:newkey'
 
-    @redises.set(@key, "oof")
+    @redises.set(@key, 'oof')
   end
 
-  it "responds with 'OK'" do
+  it 'responds with "OK"' do
     @redises.rename(@key, @newkey).should == 'OK'
   end
 
-  it "moves the data" do
+  it 'moves the data' do
     @redises.rename(@key, @newkey)
-    @redises.get(@newkey).should == "oof"
+    @redises.get(@newkey).should == 'oof'
   end
 
-  it "raises an error when the source key is nonexistant" do
+  it 'raises an error when the source key is nonexistant' do
     @redises.del(@key)
     lambda do
       @redises.rename(@key, @newkey)
     end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error when key == newkey" do
-    lambda do
-      @redises.rename(@key, @key)
-    end.should raise_error(RuntimeError)
+  it 'responds with "OK" when key == newkey' do
+    @redises.rename(@key, @key).should == 'OK'
+  end
+
+  it 'overwrites any existing value at newkey' do
+    @redises.set(@newkey, 'rab')
+    @redises.rename(@key, @newkey)
+    @redises.get(@newkey).should == 'oof'
   end
 
-  it "overwrites any existing value at newkey" do
-    @redises.set(@newkey, "rab")
+  it 'keeps expiration' do
+    @redises.expire(@key, 1000)
     @redises.rename(@key, @newkey)
-    @redises.get(@newkey).should == "oof"
+    @redises.ttl(@newkey).should be > 0
   end
 end

data/spec/commands/renamenx_spec.rb

@@ -5,39 +5,37 @@ describe '#renamenx(key, newkey)' do
     @key = 'mock-redis-test:renamenx:key'
     @newkey = 'mock-redis-test:renamenx:newkey'
 
-    @redises.set(@key, "oof")
+    @redises.set(@key, 'oof')
   end
 
-  it "responds with true when newkey does not exist" do
-    @redises.renamenx(@key, @newkey).should be_true
+  it 'responds with true when newkey does not exist' do
+    @redises.renamenx(@key, @newkey).should == true
   end
 
-  it "responds with false when newkey exists" do
+  it 'responds with false when newkey exists' do
     @redises.set(@newkey, 'monkey')
-    @redises.renamenx(@key, @newkey).should be_false
+    @redises.renamenx(@key, @newkey).should == false
   end
 
-  it "moves the data" do
+  it 'moves the data' do
     @redises.renamenx(@key, @newkey)
-    @redises.get(@newkey).should == "oof"
+    @redises.get(@newkey).should == 'oof'
   end
 
-  it "raises an error when the source key is nonexistant" do
+  it 'raises an error when the source key is nonexistant' do
     @redises.del(@key)
     lambda do
       @redises.rename(@key, @newkey)
     end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error when key == newkey" do
-    lambda do
-      @redises.renamenx(@key, @key)
-    end.should raise_error(RuntimeError)
+  it 'returns false when key == newkey' do
+    @redises.renamenx(@key, @key).should == false
   end
 
-  it "leaves any existing value at newkey alone" do
-    @redises.set(@newkey, "rab")
+  it 'leaves any existing value at newkey alone' do
+    @redises.set(@newkey, 'rab')
     @redises.renamenx(@key, @newkey)
-    @redises.get(@newkey).should == "rab"
+    @redises.get(@newkey).should == 'rab'
   end
 end

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

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe '#rpop(key)' do
   before { @key = 'mock-redis-test:43093' }
 
-  it "returns and removes the first element of a list" do
+  it 'returns and removes the first element of a list' do
     @redises.lpush(@key, 1)
     @redises.lpush(@key, 2)
 
-    @redises.rpop(@key).should == "1"
+    @redises.rpop(@key).should == '1'
 
     @redises.llen(@key).should == 1
   end
 
-  it "returns nil if the list is empty" do
+  it 'returns nil if the list is empty' do
     @redises.lpush(@key, 'foo')
     @redises.rpop(@key)
 
     @redises.rpop(@key).should be_nil
   end
 
-  it "returns nil for nonexistent values" do
+  it 'returns nil for nonexistent values' do
     @redises.rpop(@key).should be_nil
   end
 
-  it "removes empty lists" do
+  it 'removes empty lists' do
     @redises.lpush(@key, 'foo')
     @redises.rpop(@key)
 
     @redises.get(@key).should be_nil
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/rpoplpush_spec.rb

@@ -12,34 +12,39 @@ describe '#rpoplpush(source, destination)' do
     @redises.lpush(@list2, 'x')
   end
 
-  it "returns the value moved" do
-    @redises.rpoplpush(@list1, @list2).should == "b"
+  it 'returns the value moved' do
+    @redises.rpoplpush(@list1, @list2).should == 'b'
   end
 
-  it "takes the last element of destination and prepends it to source" do
+  it "returns false and doesn't append if source empty" do
+    @redises.rpoplpush('empty', @list1).should be_nil
+    @redises.lrange(@list1, 0, -1).should == %w[a b]
+  end
+
+  it 'takes the last element of destination and prepends it to source' do
     @redises.rpoplpush(@list1, @list2)
 
     @redises.lrange(@list1, 0, -1).should == %w[a]
     @redises.lrange(@list2, 0, -1).should == %w[b x y]
   end
 
-  it "rotates a list when source and destination are the same" do
+  it 'rotates a list when source and destination are the same' do
     @redises.rpoplpush(@list1, @list1)
     @redises.lrange(@list1, 0, -1).should == %w[b a]
   end
 
-  it "removes empty lists" do
+  it 'removes empty lists' do
     @redises.llen(@list1).times { @redises.rpoplpush(@list1, @list2) }
     @redises.get(@list1).should be_nil
   end
 
-  it "raises an error for non-list source value" do
+  it 'raises an error for non-list source value' do
     @redises.set(@list1, 'string value')
 
     lambda do
       @redises.rpoplpush(@list1, @list2)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/rpush_spec.rb

@@ -1,37 +1,43 @@
 require 'spec_helper'
 
-describe "#rpush(key)" do
+describe '#rpush(key)' do
   before { @key = "mock-redis-test:#{__FILE__}" }
 
-  it "returns the new size of the list" do
+  it 'returns the new size of the list' do
     @redises.rpush(@key, 'X').should == 1
     @redises.rpush(@key, 'X').should == 2
   end
 
-  it "creates a new list when run against a nonexistent key" do
+  it 'creates a new list when run against a nonexistent key' do
     @redises.rpush(@key, 'value')
     @redises.llen(@key).should == 1
   end
 
-  it "appends items to the list" do
-    @redises.rpush(@key, "bert")
-    @redises.rpush(@key, "ernie")
+  it 'appends items to the list' do
+    @redises.rpush(@key, 'bert')
+    @redises.rpush(@key, 'ernie')
 
-    @redises.lindex(@key, 0).should == "bert"
-    @redises.lindex(@key, 1).should == "ernie"
+    @redises.lindex(@key, 0).should == 'bert'
+    @redises.lindex(@key, 1).should == 'ernie'
   end
 
-  it "stores values as strings" do
+  it 'stores values as strings' do
     @redises.rpush(@key, 1)
-    @redises.lindex(@key, 0).should == "1"
+    @redises.lindex(@key, 0).should == '1'
   end
 
-  it "supports a variable number of arguments" do
+  it 'supports a variable number of arguments' do
     @redises.rpush(@key, [1, 2, 3]).should == 3
-    @redises.lindex(@key, 0).should == "1"
-    @redises.lindex(@key, 1).should == "2"
-    @redises.lindex(@key, 2).should == "3"
+    @redises.lindex(@key, 0).should == '1'
+    @redises.lindex(@key, 1).should == '2'
+    @redises.lindex(@key, 2).should == '3'
   end
 
-  it_should_behave_like "a list-only command"
+  it 'raises an error if an empty array is given' do
+    lambda do
+      @redises.rpush(@key, [])
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/rpushx_spec.rb

@@ -1,33 +1,46 @@
 require 'spec_helper'
 
-describe "#rpushx(key, value)" do
+describe '#rpushx(key, value)' do
   before { @key = 'mock-redis-test:92925' }
 
-  it "returns the new size of the list" do
+  it 'returns the new size of the list' do
     @redises.lpush(@key, 'X')
 
     @redises.rpushx(@key, 'X').should == 2
     @redises.rpushx(@key, 'X').should == 3
   end
 
-  it "does nothing when run against a nonexistent key" do
+  it 'does nothing when run against a nonexistent key' do
     @redises.rpushx(@key, 'value')
     @redises.get(@key).should be_nil
   end
 
-  it "appends items to the list" do
-    @redises.lpush(@key, "bert")
-    @redises.rpushx(@key, "ernie")
+  it 'appends items to the list' do
+    @redises.lpush(@key, 'bert')
+    @redises.rpushx(@key, 'ernie')
 
-    @redises.lindex(@key, 0).should == "bert"
-    @redises.lindex(@key, 1).should == "ernie"
+    @redises.lindex(@key, 0).should == 'bert'
+    @redises.lindex(@key, 1).should == 'ernie'
   end
 
-  it "stores values as strings" do
+  it 'stores values as strings' do
     @redises.rpush(@key, 1)
     @redises.rpushx(@key, 2)
-    @redises.lindex(@key, 1).should == "2"
+    @redises.lindex(@key, 1).should == '2'
   end
 
-  it_should_behave_like "a list-only command"
+  it 'raises an error if an empty array is given' do
+    @redises.lpush(@key, 'X')
+    lambda do
+      @redises.rpushx(@key, [])
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it 'stores multiple items if an array of more than one item is given' do
+    @redises.lpush(@key, 'X')
+    @redises.rpushx(@key, [1, 2]).should == 3
+    @redises.lrange(@key, 0, -1).should == %w[X 1 2]
+  end
+
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/sadd_spec.rb

@@ -3,39 +3,43 @@ require 'spec_helper'
 describe '#sadd(key, member)' do
   before { @key = 'mock-redis-test:sadd' }
 
-  it "returns true if the set did not already contain member" do
-    @redises.sadd(@key, 1).should be_true
+  it 'returns true if the set did not already contain member' do
+    @redises.sadd(@key, 1).should == true
   end
 
-  it "returns false if the set did already contain member" do
+  it 'returns false if the set did already contain member' do
     @redises.sadd(@key, 1)
-    @redises.sadd(@key, 1).should be_false
+    @redises.sadd(@key, 1).should == false
   end
 
-  it "adds member to the set" do
+  it 'adds member to the set' do
     @redises.sadd(@key, 1)
     @redises.sadd(@key, 2)
     @redises.smembers(@key).should == %w[2 1]
   end
 
   describe 'adding multiple members at once' do
-
-    it "returns the amount of added members" do
+    it 'returns the amount of added members' do
       @redises.sadd(@key, [1, 2, 3]).should == 3
       @redises.sadd(@key, [1, 2, 3, 4]).should == 1
     end
 
-    it "returns 0 if the set did already contain all members" do
+    it 'returns 0 if the set did already contain all members' do
       @redises.sadd(@key, [1, 2, 3])
       @redises.sadd(@key, [1, 2, 3]).should == 0
     end
 
-    it "adds the members to the set" do
+    it 'adds the members to the set' do
       @redises.sadd(@key, [1, 2, 3])
       @redises.smembers(@key).should == %w[1 2 3]
     end
 
+    it 'raises an error if an empty array is given' do
+      lambda do
+        @redises.sadd(@key, [])
+      end.should raise_error(Redis::CommandError)
+    end
   end
 
-  it_should_behave_like "a set-only command"
+  it_should_behave_like 'a set-only command'
 end

data/spec/commands/scan_each_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe '#scan_each' do
+  subject { MockRedis::Database.new(self) }
+
+  let(:match) { '*' }
+
+  before do
+    allow(subject).to receive_message_chain(:data, :keys).and_return(collection)
+  end
+
+  context 'when no keys are found' do
+    let(:collection) { [] }
+
+    it 'does not iterate over any elements' do
+      expect(subject.scan_each.to_a).to be_empty
+    end
+  end
+
+  context 'when keys are found' do
+    context 'when no match filter is supplied' do
+      let(:collection) { Array.new(20) { |i| "mock:key#{i}" } }
+
+      it 'iterates over each item in the collection' do
+        expect(subject.scan_each.to_a).to match_array(collection)
+      end
+    end
+
+    context 'when giving a custom match filter' do
+      let(:match) { 'mock:key*' }
+      let(:collection) { %w[mock:key mock:key2 mock:otherkey] }
+      let(:expected) { %w[mock:key mock:key2] }
+
+      it 'iterates over each item in the filtered collection' do
+        expect(subject.scan_each(match: match).to_a).to match_array(expected)
+      end
+    end
+  end
+end

data/spec/commands/scan_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe '#scan' do
+  subject { MockRedis::Database.new(self) }
+
+  let(:count) { 10 }
+  let(:match) { '*' }
+
+  before do
+    allow(subject).to receive_message_chain(:data, :keys).and_return(collection)
+  end
+
+  context 'when no keys are found' do
+    let(:collection) { [] }
+
+    it 'returns a 0 cursor and an empty collection' do
+      expect(subject.scan(0, count: count, match: match)).to eq(['0', []])
+    end
+  end
+
+  context 'when keys are found' do
+    context 'when count is lower than collection size' do
+      let(:collection) { Array.new(count * 2) { |i| "mock:key#{i}" } }
+      let(:expected_first) { [count.to_s, collection[0...count]] }
+      let(:expected_second) { ['0', collection[count..-1]] }
+
+      it 'returns a the next cursor and the collection' do
+        expect(subject.scan(0, count: count, match: match)).to eq(expected_first)
+      end
+
+      it 'returns the correct results of the next cursor' do
+        expect(subject.scan(count, count: count, match: match)).to eq(expected_second)
+      end
+    end
+
+    context 'when count is greater or equal than collection size' do
+      let(:collection) { Array.new(count) { |i| "mock:key#{i}" } }
+      let(:expected) { ['0', collection] }
+
+      it 'returns a 0 cursor and the collection' do
+        expect(subject.scan(0, count: count, match: match)).to eq(expected)
+      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] }
+      let(:expected) { ['0', %w[mock:key mock:key2]] }
+
+      it 'returns a 0 cursor and the filtered collection' do
+        expect(subject.scan(0, count: count, match: match)).to eq(expected)
+      end
+    end
+  end
+end

data/spec/commands/scard_spec.rb

@@ -3,16 +3,16 @@ require 'spec_helper'
 describe '#scard(key)' do
   before { @key = 'mock-redis-test:scard' }
 
-  it "returns 0 for an empty set" do
+  it 'returns 0 for an empty set' do
     @redises.scard(@key).should == 0
   end
 
-  it "returns the number of elements in the set" do
+  it 'returns the number of elements in the set' do
     @redises.sadd(@key, 'one')
     @redises.sadd(@key, 'two')
     @redises.sadd(@key, 'three')
     @redises.scard(@key).should == 3
   end
 
-  it_should_behave_like "a set-only command"
+  it_should_behave_like 'a set-only command'
 end

data/spec/commands/script_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe '#script(subcommand, *args)' do
+  before { @key = 'mock-redis-test:script' }
+
+  it 'works with load subcommand' do
+    expect { @redises.send_without_checking(:script, :load, 'return 1') }.to_not raise_error
+  end
+end

data/spec/commands/sdiff_spec.rb

@@ -6,42 +6,42 @@ describe '#sdiff(key [, key, ...])' do
     @evens   = 'mock-redis-test:sdiff:odds'
     @primes  = 'mock-redis-test:sdiff:primes'
 
-    (1..10).each {|i| @redises.sadd(@numbers, i) }
-    [2, 4, 6, 8, 10].each {|i| @redises.sadd(@evens, i) }
-    [2, 3, 5, 7].each {|i| @redises.sadd(@primes, i) }
+    (1..10).each { |i| @redises.sadd(@numbers, i) }
+    [2, 4, 6, 8, 10].each { |i| @redises.sadd(@evens, i) }
+    [2, 3, 5, 7].each { |i| @redises.sadd(@primes, i) }
   end
 
-  it "returns the first set minus the second set" do
+  it 'returns the first set minus the second set' do
     @redises.sdiff(@numbers, @evens).should == %w[1 3 5 7 9]
   end
 
-  it "returns the first set minus all the other sets" do
+  it 'returns the first set minus all the other sets' do
     @redises.sdiff(@numbers, @evens, @primes).should == %w[1 9]
   end
 
-  it "treats missing keys as empty sets" do
+  it 'treats missing keys as empty sets' do
     @redises.sdiff(@evens, 'mock-redis-test:nonesuch').should == %w[2 4 6 8 10]
   end
 
-  it "returns the first set when called with a single argument" do
+  it 'returns the first set when called with a single argument' do
     @redises.sdiff(@primes).should == %w[2 3 5 7]
   end
 
-  it "raises an error if given 0 arguments" do
+  it 'raises an error if given 0 arguments' do
     lambda do
-      @redises.sdiff()
-    end.should raise_error(RuntimeError)
+      @redises.sdiff
+    end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if any argument is not a a set" do
+  it 'raises an error if any argument is not a a set' do
     @redises.set('foo', 1)
 
     lambda do
       @redises.sdiff(@numbers, 'foo')
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
 
     lambda do
       @redises.sdiff('foo', @numbers)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 end