rediska 0.0.11 → 0.1.0

data/spec/support/sorted_method.rb

@@ -0,0 +1,136 @@
+shared_examples 'sorted_method' do
+  shared_examples_for 'sortable' do
+    it 'returns empty array on nil' do
+      expect(subject.sort(nil)).to eq([])
+    end
+
+    context 'ordering' do
+      it 'orders ascending by default' do
+        expect(subject.sort(key)).to eq(['1', '2'])
+      end
+
+      it 'orders by ascending when specified' do
+        expect(subject.sort(key, order: 'ASC')).to eq(['1', '2'])
+      end
+
+      it 'orders by descending when specified' do
+        expect(subject.sort(key, order: 'DESC')).to eq(['2', '1'])
+      end
+
+      it 'orders by ascending when alpha is specified' do
+        expect(subject.sort(key, order: 'ALPHA')).to eq(['1', '2'])
+      end
+    end
+
+    context 'projections' do
+      it 'projects element when :get is #' do
+        expect(subject.sort(key, get: '#')).to eq(['1', '2'])
+      end
+
+      it 'projects through a key pattern' do
+        expect(subject.sort(key, get: 'fake-redis-test:values_*')).to eq(['a', 'b'])
+      end
+
+      it 'projects through a key pattern and reflects element' do
+        expect(subject.sort(key, get: ['#', 'fake-redis-test:values_*'])).to eq([['1', 'a'], ['2', 'b']])
+      end
+
+      it 'projects through a hash key pattern' do
+        expect(subject.sort(key, get: 'fake-redis-test:hash_*->key')).to eq(['x', 'y'])
+      end
+    end
+
+    context 'weights' do
+      it 'weights by projecting through a key pattern' do
+        expect(subject.sort(key, by: 'fake-redis-test:weight_*')).to eq(['2', '1'])
+      end
+
+      it 'weights by projecting through a key pattern and a specific order' do
+        expect(subject.sort(key, order: 'DESC', by: 'fake-redis-test:weight_*')).to eq(['1', '2'])
+      end
+    end
+
+    context 'limit' do
+      it 'only returns requested window in the enumerable' do
+        expect(subject.sort(key, limit: [0, 1])).to eq(['1'])
+      end
+    end
+
+    context 'store' do
+      it 'stores into another key' do
+        expect(subject.sort(key, store: 'fake-redis-test:some_bucket')).to eq(2)
+        expect(subject.lrange('fake-redis-test:some_bucket', 0, -1)).to eq(['1', '2'])
+      end
+
+      it 'stores into another key with other options specified' do
+        expect(subject.sort(key, store: 'fake-redis-test:some_bucket', by: 'fake-redis-test:weight_*')).to eq(2)
+        expect(subject.lrange('fake-redis-test:some_bucket', 0, -1)).to eq(['2', '1'])
+      end
+    end
+  end
+
+  describe '#sort' do
+    before(:each) do
+      subject.set('fake-redis-test:values_1', 'a')
+      subject.set('fake-redis-test:values_2', 'b')
+
+      subject.set('fake-redis-test:weight_1', '2')
+      subject.set('fake-redis-test:weight_2', '1')
+
+      subject.hset('fake-redis-test:hash_1', 'key', 'x')
+      subject.hset('fake-redis-test:hash_2', 'key', 'y')
+    end
+
+    context 'WRONGTYPE Operation' do
+      it 'should not allow #sort on Strings' do
+        subject.set('key1', 'Hello')
+
+        expect {
+          subject.sort('key1')
+        }.to raise_error(Redis::CommandError)
+      end
+
+      it 'should not allow #sort on Hashes' do
+        subject.hset('key1', 'k1', 'val1')
+        subject.hset('key1', 'k2', 'val2')
+
+        expect {
+          subject.sort('key1')
+        }.to raise_error(Redis::CommandError)
+      end
+    end
+
+    context 'list' do
+      let(:key) { 'fake-redis-test:list_sort' }
+
+      before do
+        subject.rpush(key, '1')
+        subject.rpush(key, '2')
+      end
+
+      it_behaves_like 'sortable'
+    end
+
+    context 'set' do
+      let(:key) { 'ake-redis-test:set_sort' }
+
+      before do
+        subject.sadd(key, '1')
+        subject.sadd(key, '2')
+      end
+
+      it_behaves_like 'sortable'
+    end
+
+    context 'zset' do
+      let(:key) { 'fake-redis-test:zset_sor' }
+
+      before do
+        subject.zadd(key, 100, '1')
+        subject.zadd(key, 99, '2')
+      end
+
+      it_behaves_like 'sortable'
+    end
+  end
+end

data/spec/support/sorted_sets.rb

@@ -2,44 +2,44 @@ shared_examples 'sorted sets' do
   let(:infinity) { 1.0 / 0.0 }
 
   it 'should add a member to a sorted set, or update its score if it already exists' do
-    subject.zadd('key', 1, 'val').should be_true
-    subject.zscore('key', 'val').should eq(1.0)
+    expect(subject.zadd('key', 1, 'val')).to be_truthy
+    expect(subject.zscore('key', 'val')).to eq(1.0)
 
-    subject.zadd('key', 2, 'val').should be_false
-    subject.zscore('key', 'val').should eq(2.0)
+    expect(subject.zadd('key', 2, 'val')).to be_falsey
+    expect(subject.zscore('key', 'val')).to eq(2.0)
 
-    subject.zadd('key2', 'inf', 'val').should be_true
-    subject.zscore('key2', 'val').should eq(infinity)
+    expect(subject.zadd('key2', 'inf', 'val')).to be_truthy
+    expect(subject.zscore('key2', 'val')).to eq(infinity)
 
-    subject.zadd('key3', '+inf', 'val').should be_true
-    subject.zscore('key3', 'val').should eq(infinity)
+    expect(subject.zadd('key3', '+inf', 'val')).to be_truthy
+    expect(subject.zscore('key3', 'val')).to eq(infinity)
 
-    subject.zadd('key4', '-inf', 'val').should be_true
-    subject.zscore('key4', 'val').should eq(-infinity)
+    expect(subject.zadd('key4', '-inf', 'val')).to be_truthy
+    expect(subject.zscore('key4', 'val')).to eq(-infinity)
   end
 
   it 'should return a nil score for value not in a sorted set or empty key' do
     subject.zadd('key', 1, 'val')
 
-    subject.zscore('key', 'val').should eq(1.0)
-    subject.zscore('key', 'val2').should be_nil
-    subject.zscore('key2', 'val').should be_nil
+    expect(subject.zscore('key', 'val')).to eq(1.0)
+    expect(subject.zscore('key', 'val2')).to be_nil
+    expect(subject.zscore('key2', 'val')).to be_nil
   end
 
   it 'should add multiple members to a sorted set, or update its score if it already exists' do
-    subject.zadd('key', [1, 'val', 2, 'val2']).should eq(2)
-    subject.zscore('key', 'val').should eq(1)
-    subject.zscore('key', 'val2').should eq(2)
-
-    subject.zadd('key', [[5, 'val'], [3, 'val3'], [4, 'val4']]).should eq(2)
-    subject.zscore('key', 'val').should eq(5)
-    subject.zscore('key', 'val2').should eq(2)
-    subject.zscore('key', 'val3').should eq(3)
-    subject.zscore('key', 'val4').should eq(4)
-
-    subject.zadd('key', [[5, 'val5'], [3, 'val6']]).should eq(2)
-    subject.zscore('key', 'val5').should eq(5)
-    subject.zscore('key', 'val6').should eq(3)
+    expect(subject.zadd('key', [1, 'val', 2, 'val2'])).to eq(2)
+    expect(subject.zscore('key', 'val')).to eq(1)
+    expect(subject.zscore('key', 'val2')).to eq(2)
+
+    expect(subject.zadd('key', [[5, 'val'], [3, 'val3'], [4, 'val4']])).to eq(2)
+    expect(subject.zscore('key', 'val')).to eq(5)
+    expect(subject.zscore('key', 'val2')).to eq(2)
+    expect(subject.zscore('key', 'val3')).to eq(3)
+    expect(subject.zscore('key', 'val4')).to eq(4)
+
+    expect(subject.zadd('key', [[5, 'val5'], [3, 'val6']])).to eq(2)
+    expect(subject.zscore('key', 'val5')).to eq(5)
+    expect(subject.zscore('key', 'val6')).to eq(3)
   end
 
   it 'should error with wrong number of arguments when adding members' do
@@ -65,34 +65,34 @@ shared_examples 'sorted sets' do
   end
 
   it 'should allow floats as scores when adding or updating' do
-    subject.zadd('key', 4.321, 'val').should be_true
-    subject.zscore('key', 'val').should eq(4.321)
+    expect(subject.zadd('key', 4.321, 'val')).to be_truthy
+    expect(subject.zscore('key', 'val')).to eq(4.321)
 
-    subject.zadd('key', 54.3210, 'val').should be_false
-    subject.zscore('key', 'val').should eq(54.321)
+    expect(subject.zadd('key', 54.3210, 'val')).to be_falsey
+    expect(subject.zscore('key', 'val')).to eq(54.321)
   end
 
   it 'should remove members from sorted sets' do
-    subject.zrem('key', 'val').should be_false
-    subject.zadd('key', 1, 'val').should be_true
-    subject.zrem('key', 'val').should be_true
+    expect(subject.zrem('key', 'val')).to be_falsey
+    expect(subject.zadd('key', 1, 'val')).to be_truthy
+    expect(subject.zrem('key', 'val')).to be_truthy
   end
 
   it 'should remove multiple members from sorted sets' do
-    subject.zrem('key2', %w(val)).should eq(0)
-    subject.zrem('key2', %w(val val2 val3)).should eq(0)
+    expect(subject.zrem('key2', %w(val))).to eq(0)
+    expect(subject.zrem('key2', %w(val val2 val3))).to eq(0)
 
     subject.zadd('key2', 1, 'val')
     subject.zadd('key2', 1, 'val2')
     subject.zadd('key2', 1, 'val3')
 
-    subject.zrem('key2', %w(val val2 val3 val4)).should eq(3)
+    expect(subject.zrem('key2', %w(val val2 val3 val4))).to eq(3)
   end
 
   it "should remove sorted set's key when it is empty" do
     subject.zadd('key', 1, 'val')
     subject.zrem('key', 'val')
-    subject.exists('key').should be_false
+    expect(subject.exists('key')).to be_falsey
   end
 
   it 'should get the number of members in a sorted set' do
@@ -100,7 +100,7 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 2, 'val1')
     subject.zadd('key', 5, 'val3')
 
-    subject.zcard('key').should eq(3)
+    expect(subject.zcard('key')).to eq(3)
   end
 
   it 'should count the members in a sorted set with scores within the given values' do
@@ -108,27 +108,27 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 2, 'val2')
     subject.zadd('key', 3, 'val3')
 
-    subject.zcount('key', 2, 3).should eq(2)
+    expect(subject.zcount('key', 2, 3)).to eq(2)
   end
 
   it 'should increment the score of a member in a sorted set' do
     subject.zadd('key', 1, 'val1')
-    subject.zincrby('key', 2, 'val1').should eq(3)
-    subject.zscore('key', 'val1').should eq(3)
+    expect(subject.zincrby('key', 2, 'val1')).to eq(3)
+    expect(subject.zscore('key', 'val1')).to eq(3)
   end
 
   it 'initializes the sorted set if the key wasnt already set' do
-    subject.zincrby('key', 1, 'val1').should eq(1)
+    expect(subject.zincrby('key', 1, 'val1')).to eq(1)
   end
 
   it 'should convert the key to a string for zscore' do
     subject.zadd('key', 1, 1)
-    subject.zscore('key', 1).should eq(1)
+    expect(subject.zscore('key', 1)).to eq(1)
   end
 
   it 'should handle infinity values when incrementing a sorted set key' do
-    subject.zincrby('bar', '+inf', 's2').should eq(infinity)
-    subject.zincrby('bar', '-inf', 's1').should eq(-infinity)
+    expect(subject.zincrby('bar', '+inf', 's2')).to eq(infinity)
+    expect(subject.zincrby('bar', '-inf', 's1')).to eq(-infinity)
   end
 
   it 'should return a range of members in a sorted set, by index' do
@@ -136,10 +136,10 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 2, 'two')
     subject.zadd('key', 3, 'three')
 
-    subject.zrange('key', 0, -1).should eq(['one', 'two', 'three'])
-    subject.zrange('key', 1, 2).should eq(['two', 'three'])
-    subject.zrange('key', 0, -1, with_scores: true).should eq([['one', 1], ['two', 2], ['three', 3]])
-      subject.zrange('key', 1, 2, with_scores: true).should eq([['two', 2], ['three', 3]])
+    expect(subject.zrange('key', 0, -1)).to eq(['one', 'two', 'three'])
+    expect(subject.zrange('key', 1, 2)).to eq(['two', 'three'])
+    expect(subject.zrange('key', 0, -1, with_scores: true)).to eq([['one', 1], ['two', 2], ['three', 3]])
+      expect(subject.zrange('key', 1, 2, with_scores: true)).to eq([['two', 2], ['three', 3]])
     end
 
   it 'should sort zrange results logically' do
@@ -147,8 +147,8 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 5, 'val3')
     subject.zadd('key', 5, 'val1')
 
-    subject.zrange('key', 0, -1).should eq(%w(val1 val2 val3))
-    subject.zrange('key', 0, -1, with_scores: true).should eq([['val1', 5], ['val2', 5], ['val3', 5]])
+    expect(subject.zrange('key', 0, -1)).to eq(%w(val1 val2 val3))
+    expect(subject.zrange('key', 0, -1, with_scores: true)).to eq([['val1', 5], ['val2', 5], ['val3', 5]])
   end
 
   it 'should return a reversed range of members in a sorted set, by index' do
@@ -156,10 +156,10 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 2, 'two')
     subject.zadd('key', 3, 'three')
 
-    subject.zrevrange('key', 0, -1).should eq(['three', 'two', 'one'])
-    subject.zrevrange('key', 1, 2).should eq(['two', 'one'])
-    subject.zrevrange('key', 0, -1, with_scores: true).should eq([['three', 3], ['two', 2], ['one', 1]])
-    subject.zrevrange('key', 0, -1, with_scores: true).should eq([['three', 3], ['two', 2], ['one', 1]])
+    expect(subject.zrevrange('key', 0, -1)).to eq(['three', 'two', 'one'])
+    expect(subject.zrevrange('key', 1, 2)).to eq(['two', 'one'])
+    expect(subject.zrevrange('key', 0, -1, with_scores: true)).to eq([['three', 3], ['two', 2], ['one', 1]])
+    expect(subject.zrevrange('key', 0, -1, with_scores: true)).to eq([['three', 3], ['two', 2], ['one', 1]])
   end
 
   it 'should return a range of members in a sorted set, by score' do
@@ -167,21 +167,21 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 2, 'two')
     subject.zadd('key', 3, 'three')
 
-    subject.zrangebyscore('key', 0, 100).should eq(['one', 'two', 'three'])
-    subject.zrangebyscore('key', 1, 2).should eq(['one', 'two'])
-    subject.zrangebyscore('key', 1, '(2').should eq(['one'])
-    subject.zrangebyscore('key', '(1', 2).should eq(['two'])
-    subject.zrangebyscore('key', '(1', '(2').should eq([])
-    subject.zrangebyscore('key', 0, 100, with_scores: true).should eq([['one', 1], ['two', 2], ['three', 3]])
-    subject.zrangebyscore('key', 1, 2, with_scores: true).should eq([['one', 1], ['two', 2]])
-    subject.zrangebyscore('key', 0, 100, limit: [0, 1]).should eq(['one'])
-    subject.zrangebyscore('key', 0, 100, limit: [0, -1]).should eq(['one', 'two', 'three'])
-    subject.zrangebyscore('key', 0, 100, limit: [1, -1], with_scores: true).should eq([['two', 2], ['three', 3]])
-    subject.zrangebyscore('key', '-inf', '+inf').should eq(['one', 'two', 'three'])
-    subject.zrangebyscore('key', 2, '+inf').should eq(['two', 'three'])
-    subject.zrangebyscore('key', '-inf', 2).should eq(['one', 'two'])
-
-    subject.zrangebyscore('badkey', 1, 2).should eq([])
+    expect(subject.zrangebyscore('key', 0, 100)).to eq(['one', 'two', 'three'])
+    expect(subject.zrangebyscore('key', 1, 2)).to eq(['one', 'two'])
+    expect(subject.zrangebyscore('key', 1, '(2')).to eq(['one'])
+    expect(subject.zrangebyscore('key', '(1', 2)).to eq(['two'])
+    expect(subject.zrangebyscore('key', '(1', '(2')).to eq([])
+    expect(subject.zrangebyscore('key', 0, 100, with_scores: true)).to eq([['one', 1], ['two', 2], ['three', 3]])
+    expect(subject.zrangebyscore('key', 1, 2, with_scores: true)).to eq([['one', 1], ['two', 2]])
+    expect(subject.zrangebyscore('key', 0, 100, limit: [0, 1])).to eq(['one'])
+    expect(subject.zrangebyscore('key', 0, 100, limit: [0, -1])).to eq(['one', 'two', 'three'])
+    expect(subject.zrangebyscore('key', 0, 100, limit: [1, -1], with_scores: true)).to eq([['two', 2], ['three', 3]])
+    expect(subject.zrangebyscore('key', '-inf', '+inf')).to eq(['one', 'two', 'three'])
+    expect(subject.zrangebyscore('key', 2, '+inf')).to eq(['two', 'three'])
+    expect(subject.zrangebyscore('key', '-inf', 2)).to eq(['one', 'two'])
+
+    expect(subject.zrangebyscore('badkey', 1, 2)).to eq([])
   end
 
   it 'should return a reversed range of members in a sorted set, by score' do
@@ -189,13 +189,13 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 2, 'two')
     subject.zadd('key', 3, 'three')
 
-    subject.zrevrangebyscore('key', 100, 0).should eq(['three', 'two', 'one'])
-    subject.zrevrangebyscore('key', 2, 1).should eq(['two', 'one'])
-    subject.zrevrangebyscore('key', 1, 2).should be_empty
-    subject.zrevrangebyscore('key', 2, 1, with_scores: true).should eq([['two', 2.0], ['one', 1.0]])
-    subject.zrevrangebyscore('key', 100, 0, limit: [0, 1]).should eq(['three'])
-    subject.zrevrangebyscore('key', 100, 0, limit: [0, -1]).should eq(['three', 'two', 'one'])
-    subject.zrevrangebyscore('key', 100, 0, limit: [1, -1], with_scores: true).should eq([['two', 2.0], ['one', 1.0]])
+    expect(subject.zrevrangebyscore('key', 100, 0)).to eq(['three', 'two', 'one'])
+    expect(subject.zrevrangebyscore('key', 2, 1)).to eq(['two', 'one'])
+    expect(subject.zrevrangebyscore('key', 1, 2)).to be_empty
+    expect(subject.zrevrangebyscore('key', 2, 1, with_scores: true)).to eq([['two', 2.0], ['one', 1.0]])
+    expect(subject.zrevrangebyscore('key', 100, 0, limit: [0, 1])).to eq(['three'])
+    expect(subject.zrevrangebyscore('key', 100, 0, limit: [0, -1])).to eq(['three', 'two', 'one'])
+    expect(subject.zrevrangebyscore('key', 100, 0, limit: [1, -1], with_scores: true)).to eq([['two', 2.0], ['one', 1.0]])
   end
 
   it 'should determine the index of a member in a sorted set' do
@@ -203,8 +203,8 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 2, 'two')
     subject.zadd('key', 3, 'three')
 
-    subject.zrank('key', 'three').should eq(2)
-    subject.zrank('key', 'four').should be_nil
+    expect(subject.zrank('key', 'three')).to eq(2)
+    expect(subject.zrank('key', 'four')).to be_nil
   end
 
   it 'should determine the reversed index of a member in a sorted set' do
@@ -212,16 +212,16 @@ shared_examples 'sorted sets' do
     subject.zadd('key', 2, 'two')
     subject.zadd('key', 3, 'three')
 
-    subject.zrevrank('key', 'three').should eq(0)
-    subject.zrevrank('key', 'four').should be_nil
+    expect(subject.zrevrank('key', 'three')).to eq(0)
+    expect(subject.zrevrank('key', 'four')).to be_nil
   end
 
   it 'should not raise errors for zrank() on accessing a non-existing key in a sorted set' do
-    subject.zrank('no_such_key', 'no_suck_id').should be_nil
+    expect(subject.zrank('no_such_key', 'no_suck_id')).to be_nil
   end
 
   it 'should not raise errors for zrevrank() on accessing a non-existing key in a sorted set' do
-    subject.zrevrank('no_such_key', 'no_suck_id').should be_nil
+    expect(subject.zrevrank('no_such_key', 'no_suck_id')).to be_nil
   end
 
   describe '#zinterstore' do
@@ -236,53 +236,53 @@ shared_examples 'sorted sets' do
     end
 
     it 'should intersect two keys with custom scores' do
-      subject.zinterstore('out', ['key1', 'key2']).should eq(2)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['two', (2 + 5)], ['three', (3 + 7)]])
+      expect(subject.zinterstore('out', ['key1', 'key2'])).to eq(2)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['two', (2 + 5)], ['three', (3 + 7)]])
     end
 
     it 'should intersect two keys with a default score' do
-      subject.zinterstore('out', ['key1', 'key3']).should eq(2)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['one', (1 + 1)], ['two', (2 + 1)]])
+      expect(subject.zinterstore('out', ['key1', 'key3'])).to eq(2)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['one', (1 + 1)], ['two', (2 + 1)]])
     end
 
     it 'should intersect more than two keys' do
-      subject.zinterstore('out', ['key1', 'key2', 'key3']).should eq(1)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['two', (2 + 5 + 1)]])
+      expect(subject.zinterstore('out', ['key1', 'key2', 'key3'])).to eq(1)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['two', (2 + 5 + 1)]])
     end
 
     it 'should not intersect an unknown key' do
-      subject.zinterstore('out', ['key1', 'no_key']).should eq(0)
-      subject.zrange('out', 0, -1, with_scores: true).should be_empty
+      expect(subject.zinterstore('out', ['key1', 'no_key'])).to eq(0)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to be_empty
     end
 
     it 'should intersect two keys by minimum values' do
-      subject.zinterstore('out', ['key1', 'key2'], aggregate: :min).should eq(2)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['two', 2], ['three', 3]])
+      expect(subject.zinterstore('out', ['key1', 'key2'], aggregate: :min)).to eq(2)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['two', 2], ['three', 3]])
     end
 
     it 'should intersect two keys by maximum values' do
-      subject.zinterstore('out', ['key1', 'key2'], aggregate: :max).should eq(2)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['two', 5], ['three', 7]])
+      expect(subject.zinterstore('out', ['key1', 'key2'], aggregate: :max)).to eq(2)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['two', 5], ['three', 7]])
     end
 
     it 'should intersect two keys by explicitly summing values' do
-      subject.zinterstore('out', %w(key1 key2), aggregate: :sum).should eq(2)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['two', (2 + 5)], ['three', (3 + 7)]])
+      expect(subject.zinterstore('out', %w(key1 key2), aggregate: :sum)).to eq(2)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['two', (2 + 5)], ['three', (3 + 7)]])
     end
 
     it 'should intersect two keys with weighted values' do
-      subject.zinterstore('out', %w(key1 key2), weights: [10, 1]).should eq(2)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['two', (2 * 10 + 5)], ['three', (3 * 10 + 7)]])
+      expect(subject.zinterstore('out', %w(key1 key2), weights: [10, 1])).to eq(2)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['two', (2 * 10 + 5)], ['three', (3 * 10 + 7)]])
     end
 
     it 'should intersect two keys with weighted minimum values' do
-      subject.zinterstore('out', %w(key1 key2), weights: [10, 1], aggregate: :min).should eq(2)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['two', 5], ['three', 7]])
+      expect(subject.zinterstore('out', %w(key1 key2), weights: [10, 1], aggregate: :min)).to eq(2)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['two', 5], ['three', 7]])
     end
 
     it 'should intersect two keys with weighted maximum values' do
-      subject.zinterstore('out', %w(key1 key2), weights: [10, 1], aggregate: :max).should eq(2)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['two', (2 * 10)], ['three', (3 * 10)]])
+      expect(subject.zinterstore('out', %w(key1 key2), weights: [10, 1], aggregate: :max)).to eq(2)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['two', (2 * 10)], ['three', (3 * 10)]])
     end
 
     it 'should error without enough weights given' do
@@ -314,23 +314,23 @@ shared_examples 'sorted sets' do
       subject.zadd('key', 2, 'two')
       subject.zadd('key', 3, 'three')
 
-      subject.zremrangebyscore('key', 0, 2).should eq(2)
-      subject.zcard('key').should eq(1)
+      expect(subject.zremrangebyscore('key', 0, 2)).to eq(2)
+      expect(subject.zcard('key')).to eq(1)
     end
 
     it 'should remove items by score with infinity' do # Issue #50
       subject.zadd('key', 10.0, 'one')
       subject.zadd('key', 20.0, 'two')
       subject.zadd('key', 30.0, 'three')
-      subject.zremrangebyscore('key', '-inf', '+inf').should eq(3)
-      subject.zcard('key').should eq(0)
-      subject.zscore('key', 'one').should be_nil
-      subject.zscore('key', 'two').should be_nil
-      subject.zscore('key', 'three').should be_nil
+      expect(subject.zremrangebyscore('key', '-inf', '+inf')).to eq(3)
+      expect(subject.zcard('key')).to eq(0)
+      expect(subject.zscore('key', 'one')).to be_nil
+      expect(subject.zscore('key', 'two')).to be_nil
+      expect(subject.zscore('key', 'three')).to be_nil
     end
 
     it 'should return 0 if the key did not exist' do
-      subject.zremrangebyscore('key', 0, 2).should eq(0)
+      expect(subject.zremrangebyscore('key', 0, 2)).to eq(0)
     end
   end
 
@@ -340,8 +340,8 @@ shared_examples 'sorted sets' do
       subject.zadd('key', 2, 'two')
       subject.zadd('key', 3, 'three')
 
-      subject.zremrangebyrank('key', 0, 1).should eq(2)
-      subject.zcard('key').should eq(1)
+      expect(subject.zremrangebyrank('key', 0, 1)).to eq(2)
+      expect(subject.zcard('key')).to eq(1)
     end
 
     it 'handles out of range requests' do
@@ -349,8 +349,12 @@ shared_examples 'sorted sets' do
       subject.zadd('key', 2, 'two')
       subject.zadd('key', 3, 'three')
 
-      subject.zremrangebyrank('key', 25, -1).should eq(0)
-      subject.zcard('key').should eq(3)
+      expect(subject.zremrangebyrank('key', 25, -1)).to eq(0)
+      expect(subject.zcard('key')).to eq(3)
+    end
+
+    it "should return 0 if the key didn't exist" do
+      expect(subject.zremrangebyrank('key', 0, 1)).to eq(0)
     end
   end
 
@@ -366,53 +370,53 @@ shared_examples 'sorted sets' do
     end
 
     it 'should union two keys with custom scores' do
-      subject.zunionstore('out', %w(key1 key2)).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', 1], ['val2', (2 + 5)], ['val3', (3 + 7)]])
+      expect(subject.zunionstore('out', %w(key1 key2))).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', 1], ['val2', (2 + 5)], ['val3', (3 + 7)]])
     end
 
     it 'should union two keys with a default score' do
-      subject.zunionstore('out', %w(key1 key3)).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', (1 + 1)], ['val2', (2 + 1)], ['val3', 3]])
+      expect(subject.zunionstore('out', %w(key1 key3))).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', (1 + 1)], ['val2', (2 + 1)], ['val3', 3]])
     end
 
     it 'should union more than two keys' do
-      subject.zunionstore('out', %w(key1 key2 key3)).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', (1 + 1)], ['val2', (2 + 5 + 1)], ['val3', (3 + 7)]])
+      expect(subject.zunionstore('out', %w(key1 key2 key3))).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', (1 + 1)], ['val2', (2 + 5 + 1)], ['val3', (3 + 7)]])
     end
 
     it 'should union with an unknown key' do
-      subject.zunionstore('out', %w(key1 no_key)).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', 1], ['val2', 2], ['val3', 3]])
+      expect(subject.zunionstore('out', %w(key1 no_key))).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', 1], ['val2', 2], ['val3', 3]])
     end
 
     it 'should union two keys by minimum values' do
-      subject.zunionstore('out', %w(key1 key2), aggregate: :min).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', 1], ['val2', 2], ['val3', 3]])
+      expect(subject.zunionstore('out', %w(key1 key2), aggregate: :min)).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', 1], ['val2', 2], ['val3', 3]])
     end
 
     it 'should union two keys by maximum values' do
-      subject.zunionstore('out', %w(key1 key2), aggregate: :max).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', 1], ['val2', 5], ['val3', 7]])
+      expect(subject.zunionstore('out', %w(key1 key2), aggregate: :max)).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', 1], ['val2', 5], ['val3', 7]])
     end
 
     it 'should union two keys by explicitly summing values' do
-      subject.zunionstore('out', %w(key1 key2), aggregate: :sum).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', 1], ['val2', (2 + 5)], ['val3', (3 + 7)]])
+      expect(subject.zunionstore('out', %w(key1 key2), aggregate: :sum)).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', 1], ['val2', (2 + 5)], ['val3', (3 + 7)]])
     end
 
     it 'should union two keys with weighted values' do
-      subject.zunionstore('out', %w(key1 key2), :weights => [10, 1]).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', (1 * 10)], ['val2', (2 * 10 + 5)], ['val3', (3 * 10 + 7)]])
+      expect(subject.zunionstore('out', %w(key1 key2), :weights => [10, 1])).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', (1 * 10)], ['val2', (2 * 10 + 5)], ['val3', (3 * 10 + 7)]])
     end
 
     it 'should union two keys with weighted minimum values' do
-      subject.zunionstore('out', %w(key1 key2), weights: [10, 1], aggregate: :min).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val2', 5], ['val3', 7], ['val1', (1 * 10)]])
+      expect(subject.zunionstore('out', %w(key1 key2), weights: [10, 1], aggregate: :min)).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val2', 5], ['val3', 7], ['val1', (1 * 10)]])
     end
 
     it 'should union two keys with weighted maximum values' do
-      subject.zunionstore('out', %w(key1 key2), weights: [10, 1], aggregate: :max).should eq(3)
-      subject.zrange('out', 0, -1, with_scores: true).should eq([['val1', (1 * 10)], ['val2', (2 * 10)], ['val3', (3 * 10)]])
+      expect(subject.zunionstore('out', %w(key1 key2), weights: [10, 1], aggregate: :max)).to eq(3)
+      expect(subject.zrange('out', 0, -1, with_scores: true)).to eq([['val1', (1 * 10)], ['val2', (2 * 10)], ['val3', (3 * 10)]])
     end
 
     it 'should error without enough weights given' do
@@ -441,7 +445,7 @@ shared_examples 'sorted sets' do
   it 'zrem should remove members add by zadd' do
     subject.zadd('key1', 1, 3)
     subject.zrem('key1', 3)
-    subject.zscore('key1', 3).should be_nil
+    expect(subject.zscore('key1', 3)).to be_nil
   end
 
   #it 'should remove all members in a sorted set within the given indexes'