rediska 0.0.11 → 0.1.0

data/spec/support/lists.rb

@@ -3,9 +3,9 @@ shared_examples 'lists' do
     subject.lpush('key1', 'val1')
     subject.lpush('key1', 'val2')
 
-    subject.lindex('key1', 0).should eq('val2')
-    subject.lindex('key1', -1).should eq('val1')
-    subject.lindex('key1', 3).should be_nil
+    expect(subject.lindex('key1', 0)).to eq('val2')
+    expect(subject.lindex('key1', -1)).to eq('val1')
+    expect(subject.lindex('key1', 3)).to be_nil
   end
 
   it 'should insert an element before or after another element in a list' do
@@ -13,17 +13,17 @@ shared_examples 'lists' do
     subject.rpush('key1', 'v3')
     subject.linsert('key1', :before, 'v3', 'v2')
 
-    subject.lrange('key1', 0, -1).should eq(['v1', 'v2', 'v3'])
+    expect(subject.lrange('key1', 0, -1)).to eq(['v1', 'v2', 'v3'])
   end
 
   it 'should allow multiple values to be added to a list in a single rpush' do
     subject.rpush('key1', [1, 2, 3])
-    subject.lrange('key1', 0, -1).should eq(['1', '2', '3'])
+    expect(subject.lrange('key1', 0, -1)).to eq(['1', '2', '3'])
   end
 
   it 'should allow multiple values to be added to a list in a single lpush' do
     subject.lpush('key1', [1, 2, 3])
-    subject.lrange('key1', 0, -1).should eq(['3', '2', '1'])
+    expect(subject.lrange('key1', 0, -1)).to eq(['3', '2', '1'])
   end
 
   it 'should error if an invalid where argument is given' do
@@ -39,8 +39,8 @@ shared_examples 'lists' do
     subject.rpush('key1', 'v1')
     subject.rpush('key1', 'v2')
 
-    subject.llen('key1').should eq(2)
-    subject.llen('key2').should eq(0)
+    expect(subject.llen('key1')).to eq(2)
+    expect(subject.llen('key2')).to eq(0)
   end
 
   it 'should remove and get the first element in a list' do
@@ -48,15 +48,15 @@ shared_examples 'lists' do
     subject.rpush('key1', 'v2')
     subject.rpush('key1', 'v3')
 
-    subject.lpop('key1').should eq('v1')
-    subject.lrange('key1', 0, -1).should eq(['v2', 'v3'])
+    expect(subject.lpop('key1')).to eq('v1')
+    expect(subject.lrange('key1', 0, -1)).to eq(['v2', 'v3'])
   end
 
   it 'should prepend a value to a list' do
     subject.rpush('key1', 'v1')
     subject.rpush('key1', 'v2')
 
-    subject.lrange('key1', 0, -1).should eq(['v1', 'v2'])
+    expect(subject.lrange('key1', 0, -1)).to eq(['v1', 'v2'])
   end
 
   it 'should prepend a value to a list, only if the list exists' do
@@ -65,8 +65,8 @@ shared_examples 'lists' do
     subject.lpushx('key1', 'v2')
     subject.lpushx('key2', 'v3')
 
-    subject.lrange('key1', 0, -1).should eq(['v2', 'v1'])
-    subject.llen('key2').should eq(0)
+    expect(subject.lrange('key1', 0, -1)).to eq(['v2', 'v1'])
+    expect(subject.llen('key2')).to eq(0)
   end
 
   it 'should get a range of elements from a list' do
@@ -74,7 +74,7 @@ shared_examples 'lists' do
     subject.rpush('key1', 'v2')
     subject.rpush('key1', 'v3')
 
-    subject.lrange('key1', 1, -1).should eq(['v2', 'v3'])
+    expect(subject.lrange('key1', 1, -1)).to eq(['v2', 'v3'])
   end
 
   it 'should remove elements from a list' do
@@ -84,9 +84,9 @@ shared_examples 'lists' do
     subject.rpush('key1', 'v2')
     subject.rpush('key1', 'v1')
 
-    subject.lrem('key1', 1, 'v1').should eq(1)
-    subject.lrem('key1', -2, 'v2').should eq(2)
-    subject.llen('key1').should eq(2)
+    expect(subject.lrem('key1', 1, 'v1')).to eq(1)
+    expect(subject.lrem('key1', -2, 'v2')).to eq(2)
+    expect(subject.llen('key1')).to eq(2)
   end
 
   it "should remove list's key when list is empty" do
@@ -95,7 +95,7 @@ shared_examples 'lists' do
     subject.lrem('key1', 1, 'v1')
     subject.lrem('key1', 1, 'v2')
 
-    subject.exists('key1').should be_false
+    expect(subject.exists('key1')).to be_falsey
   end
 
   it 'should set the value of an element in a list by its index' do
@@ -105,7 +105,7 @@ shared_examples 'lists' do
 
     subject.lset('key1', 0, 'four')
     subject.lset('key1', -2, 'five')
-    subject.lrange('key1', 0, -1).should eq(['four', 'five', 'three'])
+    expect(subject.lrange('key1', 0, -1)).to eq(['four', 'five', 'three'])
 
     expect {
       subject.lset('key1', 4, 'six')
@@ -118,7 +118,7 @@ shared_examples 'lists' do
     subject.rpush('key1', 'three')
 
     subject.ltrim('key1', 1, -1)
-    subject.lrange('key1', 0, -1).should eq(['two', 'three'])
+    expect(subject.lrange('key1', 0, -1)).to eq(['two', 'three'])
   end
 
   context 'when the list is smaller than the requested trim' do
@@ -132,7 +132,7 @@ shared_examples 'lists' do
       end
 
       it 'returns the unmodified list' do
-        subject.lrange('listOfOne', 0, -1).should  eq(['one'])
+        expect(subject.lrange('listOfOne', 0, -1)).to  eq(['one'])
       end
     end
   end
@@ -153,7 +153,7 @@ shared_examples 'lists' do
       end
 
       it 'should trim a list to the specified maximum size' do
-        subject.lrange('maxTest', 0, -1).should eq(['two','three', 'four', 'five', 'six'])
+        expect(subject.lrange('maxTest', 0, -1)).to eq(['two','three', 'four', 'five', 'six'])
       end
     end
   end
@@ -163,8 +163,8 @@ shared_examples 'lists' do
     subject.rpush('key1', 'two')
     subject.rpush('key1', 'three')
 
-    subject.rpop('key1').should eq('three')
-    subject.lrange('key1', 0, -1).should eq(['one', 'two'])
+    expect(subject.rpop('key1')).to eq('three')
+    expect(subject.lrange('key1', 0, -1)).to eq(['one', 'two'])
   end
 
   it 'should remove the last element in a list, append it to another list and return it' do
@@ -172,17 +172,24 @@ shared_examples 'lists' do
     subject.rpush('key1', 'two')
     subject.rpush('key1', 'three')
 
-    subject.rpoplpush('key1', 'key2').should eq('three')
+    expect(subject.rpoplpush('key1', 'key2')).to eq('three')
 
-    subject.lrange('key1', 0, -1).should eq(['one', 'two'])
-    subject.lrange('key2', 0, -1).should eq(['three'])
+    expect(subject.lrange('key1', 0, -1)).to eq(['one', 'two'])
+    expect(subject.lrange('key2', 0, -1)).to eq(['three'])
+  end
+
+  context 'when the source list is empty' do
+    it 'rpoplpush does not add anything to the destination list' do
+      subject.rpoplpush('source', 'destination')
+      expect(subject.lrange('destination', 0, -1)).to eq([])
+    end
   end
 
   it 'should append a value to a list' do
     subject.rpush('key1', 'one')
     subject.rpush('key1', 'two')
 
-    subject.lrange('key1', 0, -1).should eq(['one', 'two'])
+    expect(subject.lrange('key1', 0, -1)).to eq(['one', 'two'])
   end
 
   it 'should append a value to a list, only if the list exists' do
@@ -190,7 +197,7 @@ shared_examples 'lists' do
     subject.rpushx('key1', 'two')
     subject.rpushx('key2', 'two')
 
-    subject.lrange('key1', 0, -1).should eq(['one', 'two'])
-    subject.lrange('key2', 0, -1).should be_empty
+    expect(subject.lrange('key1', 0, -1)).to eq(['one', 'two'])
+    expect(subject.lrange('key2', 0, -1)).to be_empty
   end
 end

data/spec/support/server.rb

@@ -4,11 +4,11 @@ shared_examples 'server' do
     subject.set('key2', '2')
     subject.set('key2', 'two')
 
-    subject.dbsize.should eq(2)
+    expect(subject.dbsize).to eq(2)
   end
 
   it 'should get information and statistics about the server' do
-    subject.info.key?('redis_version').should be_true
+    expect(subject.info.key?('redis_version')).to be_truthy
   end
 
   it 'should handle non-existent methods' do
@@ -19,16 +19,16 @@ shared_examples 'server' do
 
   describe 'multiple databases' do
     it 'should default to database 0' do
-      subject.inspect.should =~ %r#/0>$#
+      expect(subject.inspect).to match(%r#/0>$#)
     end
 
     it 'should select another database' do
       subject.select(1)
-      subject.inspect.should =~ %r#/1>$#
+      expect(subject.inspect).to match(%r#/1>$#)
     end
 
     it 'should store keys separately in each database' do
-      subject.select(0).should eq('OK')
+      expect(subject.select(0)).to eq('OK')
       subject.set('key1', '1')
       subject.set('key2', '2')
 
@@ -38,56 +38,56 @@ shared_examples 'server' do
       subject.set('key5', '5')
 
       subject.select(0)
-      subject.dbsize.should eq(2)
-      subject.exists('key1').should be_true
-      subject.exists('key3').should be_false
+      expect(subject.dbsize).to eq(2)
+      expect(subject.exists('key1')).to be_truthy
+      expect(subject.exists('key3')).to be_falsey
 
       subject.select(1)
-      subject.dbsize.should eq(3)
-      subject.exists('key4').should be_true
-      subject.exists('key2').should be_false
+      expect(subject.dbsize).to eq(3)
+      expect(subject.exists('key4')).to be_truthy
+      expect(subject.exists('key2')).to be_falsey
 
       subject.flushall
-      subject.dbsize.should eq(0)
+      expect(subject.dbsize).to eq(0)
 
       subject.select(0)
-      subject.dbsize.should eq(0)
+      expect(subject.dbsize).to eq(0)
     end
 
     it 'should flush a database' do
       subject.select(0)
       subject.set('key1', '1')
       subject.set('key2', '2')
-      subject.dbsize.should eq(2)
+      expect(subject.dbsize).to eq(2)
 
       subject.select(1)
       subject.set('key3', '3')
       subject.set('key4', '4')
-      subject.dbsize.should eq(2)
+      expect(subject.dbsize).to eq(2)
 
-      subject.flushdb.should eq('OK')
+      expect(subject.flushdb).to eq('OK')
 
-      subject.dbsize.should eq(0)
+      expect(subject.dbsize).to eq(0)
       subject.select(0)
-      subject.dbsize.should eq(2)
+      expect(subject.dbsize).to eq(2)
     end
 
     it 'should flush all databases' do
       subject.select(0)
       subject.set('key3', '3')
       subject.set('key4', '4')
-      subject.dbsize.should eq(2)
+      expect(subject.dbsize).to eq(2)
 
       subject.select(1)
       subject.set('key3', '3')
       subject.set('key4', '4')
-      subject.dbsize.should eq(2)
+      expect(subject.dbsize).to eq(2)
 
-      subject.flushall.should eq('OK')
+      expect(subject.flushall).to eq('OK')
 
-      subject.dbsize.should eq(0)
+      expect(subject.dbsize).to eq(0)
       subject.select(0)
-      subject.dbsize.should eq(0)
+      expect(subject.dbsize).to eq(0)
     end
   end
 end

data/spec/support/sets.rb

@@ -1,9 +1,9 @@
 shared_examples 'sets' do
   it 'should add a member to a set' do
-    subject.sadd('key', 'value').should be_true
-    subject.sadd('key', 'value').should be_false
+    expect(subject.sadd('key', 'value')).to be_truthy
+    expect(subject.sadd('key', 'value')).to be_falsey
 
-    subject.smembers('key').should =~ ['value']
+    expect(subject.smembers('key')).to match_array(['value'])
   end
 
   it 'should raise error if command arguments count is not enough' do
@@ -15,20 +15,20 @@ shared_examples 'sets' do
       subject.sinter(*[])
     }.to raise_error(Redis::CommandError)
 
-    subject.smembers('key').should be_empty
+    expect(subject.smembers('key')).to be_empty
   end
 
   it 'should add multiple members to a set' do
-    subject.sadd('key', %w(value other something more)).should eq(4)
-    subject.sadd('key', %w(and additional values)).should eq(3)
-    subject.smembers('key').should =~ ['value', 'other', 'something', 'more', 'and', 'additional', 'values']
+    expect(subject.sadd('key', %w(value other something more))).to eq(4)
+    expect(subject.sadd('key', %w(and additional values))).to eq(3)
+    expect(subject.smembers('key')).to match_array(['value', 'other', 'something', 'more', 'and', 'additional', 'values'])
   end
 
   it 'should get the number of members in a set' do
     subject.sadd('key', 'val1')
     subject.sadd('key', 'val2')
 
-    subject.scard('key').should eq(2)
+    expect(subject.scard('key')).to eq(2)
   end
 
   it 'should subtract multiple sets' do
@@ -41,13 +41,13 @@ shared_examples 'sets' do
     subject.sadd('key3', 'c')
     subject.sadd('key3', 'e')
 
-    subject.sdiff('key1', 'key2', 'key3').should =~ ['b', 'd']
+    expect(subject.sdiff('key1', 'key2', 'key3')).to match_array(['b', 'd'])
   end
 
   it 'should subtract from a nonexistent set' do
     subject.sadd('key2', 'a')
     subject.sadd('key2', 'b')
-    subject.sdiff('key1', 'key2').should be_empty
+    expect(subject.sdiff('key1', 'key2')).to be_empty
   end
 
   it 'should subtract multiple sets and store the resulting set in a key' do
@@ -61,7 +61,7 @@ shared_examples 'sets' do
     subject.sadd('key3', 'e')
     subject.sdiffstore('key', 'key1', 'key2', 'key3')
 
-    subject.smembers('key').should =~ ['b', 'd']
+    expect(subject.smembers('key')).to match_array(['b', 'd'])
   end
 
   it 'should intersect multiple sets' do
@@ -74,7 +74,7 @@ shared_examples 'sets' do
     subject.sadd('key3', 'c')
     subject.sadd('key3', 'e')
 
-    subject.sinter('key1', 'key2', 'key3').should =~ ['c']
+    expect(subject.sinter('key1', 'key2', 'key3')).to match_array(['c'])
   end
 
   it 'should intersect multiple sets and store the resulting set in a key' do
@@ -87,15 +87,15 @@ shared_examples 'sets' do
     subject.sadd('key3', 'c')
     subject.sadd('key3', 'e')
     subject.sinterstore('key', 'key1', 'key2', 'key3')
-    subject.smembers('key').should =~ ['c']
+    expect(subject.smembers('key')).to match_array(['c'])
   end
 
   it 'should determine if a given value is a member of a set' do
     subject.sadd('key1', 'a')
 
-    subject.sismember('key1', 'a').should be_true
-    subject.sismember('key1', 'b').should be_false
-    subject.sismember('key2', 'a').should be_false
+    expect(subject.sismember('key1', 'a')).to be_truthy
+    expect(subject.sismember('key1', 'b')).to be_falsey
+    expect(subject.sismember('key2', 'a')).to be_falsey
   end
 
   it 'should get all the members in a set' do
@@ -104,43 +104,43 @@ shared_examples 'sets' do
     subject.sadd('key', 'c')
     subject.sadd('key', 'd')
 
-    subject.smembers('key').should =~ ['a', 'b', 'c', 'd']
+    expect(subject.smembers('key')).to match_array(['a', 'b', 'c', 'd'])
   end
 
   it 'should move a member from one set to another' do
     subject.sadd('key1', 'a')
     subject.sadd('key1', 'b')
     subject.sadd('key2', 'c')
-    subject.smove('key1', 'key2', 'a').should be_true
-    subject.smove('key1', 'key2', 'a').should be_false
+    expect(subject.smove('key1', 'key2', 'a')).to be_truthy
+    expect(subject.smove('key1', 'key2', 'a')).to be_falsey
 
-    subject.smembers('key1').should =~ ['b']
-    subject.smembers('key2').should =~ ['c', 'a']
+    expect(subject.smembers('key1')).to match_array(['b'])
+    expect(subject.smembers('key2')).to match_array(['c', 'a'])
   end
 
   it 'should remove and return a random member from a set' do
     subject.sadd('key1', 'a')
     subject.sadd('key1', 'b')
 
-    ['a', 'b'].include?(subject.spop('key1')).should be_true
-    ['a', 'b'].include?(subject.spop('key1')).should be_true
-    subject.spop('key1').should be_nil
+    expect(['a', 'b'].include?(subject.spop('key1'))).to be_truthy
+    expect(['a', 'b'].include?(subject.spop('key1'))).to be_truthy
+    expect(subject.spop('key1')).to be_nil
   end
 
   it 'should get a random member from a set' do
     subject.sadd('key1', 'a')
     subject.sadd('key1', 'b')
 
-    ['a', 'b'].include?(subject.spop('key1')).should be_true
+    expect(['a', 'b'].include?(subject.spop('key1'))).to be_truthy
   end
 
   it 'should remove a member from a set' do
     subject.sadd('key1', 'a')
     subject.sadd('key1', 'b')
-    subject.srem('key1', 'a').should be_true
-    subject.srem('key1', 'a').should be_false
+    expect(subject.srem('key1', 'a')).to be_truthy
+    expect(subject.srem('key1', 'a')).to be_falsey
 
-    subject.smembers('key1').should =~ ['b']
+    expect(subject.smembers('key1')).to match_array(['b'])
   end
 
   it "should remove the set's key once it's empty" do
@@ -149,7 +149,7 @@ shared_examples 'sets' do
     subject.srem('key1', 'b')
     subject.srem('key1', 'a')
 
-    subject.exists('key1').should be_false
+    expect(subject.exists('key1')).to be_falsey
   end
 
   it 'should add multiple sets' do
@@ -162,7 +162,7 @@ shared_examples 'sets' do
     subject.sadd('key3', 'c')
     subject.sadd('key3', 'e')
 
-    subject.sunion('key1', 'key2', 'key3').should =~ ['a', 'b', 'c', 'd', 'e']
+    expect(subject.sunion('key1', 'key2', 'key3')).to match_array(['a', 'b', 'c', 'd', 'e'])
   end
 
   it 'should add multiple sets and store the resulting set in a key' do
@@ -176,7 +176,7 @@ shared_examples 'sets' do
     subject.sadd('key3', 'e')
     subject.sunionstore('key', 'key1', 'key2', 'key3')
 
-    subject.smembers('key').should =~ ['a', 'b', 'c', 'd', 'e']
+    expect(subject.smembers('key')).to match_array(['a', 'b', 'c', 'd', 'e'])
   end
 
   describe 'srandmember' do
@@ -195,7 +195,7 @@ shared_examples 'sets' do
         it 'is a random element from the set' do
           random_element = subject.srandmember('key1')
 
-          ['a', 'b', 'c'].should include(random_element)
+          expect(['a', 'b', 'c']).to include(random_element)
         end
       end
 
@@ -203,7 +203,7 @@ shared_examples 'sets' do
         it 'is an array of one random element from the set' do
           subject.srandmember('key1', 1)
 
-          [['a'], ['b'], ['c']].should include(subject.srandmember('key1', 1))
+          expect([['a'], ['b'], ['c']]).to include(subject.srandmember('key1', 1))
         end
       end
 
@@ -211,10 +211,10 @@ shared_examples 'sets' do
         it 'is an array of two unique, random elements from the set' do
           random_elements = subject.srandmember('key1', 2)
 
-          random_elements.should have(2).items
-          random_elements.uniq.should have(2).items
+          expect(random_elements.size).to eq(2)
+          expect(random_elements.uniq.size).to eq(2)
           random_elements.all? do |element|
-            ['a', 'b', 'c'].should include(element)
+            expect(['a', 'b', 'c']).to include(element)
           end
         end
       end
@@ -223,10 +223,10 @@ shared_examples 'sets' do
         it 'is an array of 100 random elements from the set, some of which are repeated' do
           random_elements = subject.srandmember('key1', -100)
 
-          random_elements.should have(100).items
-          random_elements.uniq.should have_at_most(3).items
+          expect(random_elements.size).to eq(100)
+          expect(random_elements.uniq.size).to be <= 3
           random_elements.all? do |element|
-            ['a', 'b', 'c'].should include(element)
+            expect(['a', 'b', 'c']).to include(element)
           end
         end
       end
@@ -235,9 +235,9 @@ shared_examples 'sets' do
         it 'is an array of all of the elements from the set, none of which are repeated' do
           random_elements = subject.srandmember('key1', 100)
 
-          random_elements.should have(3).items
-          random_elements.uniq.should have(3).items
-          random_elements.should =~ ['a', 'b', 'c']
+          expect(random_elements.size).to eq(3)
+          expect(random_elements.uniq.size).to eq(3)
+          expect(random_elements).to match_array(['a', 'b', 'c'])
         end
       end
     end
@@ -246,11 +246,11 @@ shared_examples 'sets' do
       before { subject.del('key1') }
 
       it 'is nil without the extra parameter' do
-        subject.srandmember('key1').should be_nil
+        expect(subject.srandmember('key1')).to be_nil
       end
 
       it 'is an empty array with an extra parameter' do
-        subject.srandmember('key1', 1).should == []
+        expect(subject.srandmember('key1', 1)).to eq([])
       end
     end
   end