rediska 0.0.11 → 0.1.0

data/lib/rediska/version.rb

@@ -1,3 +1,3 @@
 module Rediska
-  VERSION = '0.0.11'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/rediska.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   s.add_runtime_dependency     'redis', '~> 3.0.0'
-  s.add_development_dependency 'rspec', '~> 2.14'
+  s.add_development_dependency 'rspec'
   s.add_development_dependency 'coveralls'
   s.add_development_dependency 'rake'
 end

data/spec/lib/rediska/driver_spec.rb

@@ -5,23 +5,23 @@ describe Rediska::Driver do
 
   describe '#time' do
     before(:each) do
-      Time.stub_chain(:now, :to_f).and_return(1397845595.5139461)
+      allow(Time).to receive_message_chain(:now, :to_f).and_return(1397845595.5139461)
     end
 
     it 'is an array' do
-      subject.time.should be_an_instance_of(Array)
+      expect(subject.time).to be_an_instance_of(Array)
     end
 
     it 'has two elements' do
-      subject.time.count.should eq(2)
+      expect(subject.time.count).to eq(2)
     end
 
     it 'has the current time in seconds' do
-      subject.time.first.should eq(1397845595)
+      expect(subject.time.first).to eq(1397845595)
     end
 
     it 'has the current leftover microseconds' do
-      subject.time.last.should eq(513946)
+      expect(subject.time.last).to eq(513946)
     end
   end
 end

data/spec/redis_spec.rb

@@ -27,6 +27,7 @@ describe 'Rediska' do
     context 'memory' do
       before do
         subject.flushall
+        subject.discard rescue nil
       end
 
       it_behaves_like 'redis'
@@ -39,6 +40,7 @@ describe 'Rediska' do
         end
 
         subject.flushall
+        subject.discard rescue nil
       end
 
       it_behaves_like 'redis'
@@ -48,6 +50,7 @@ describe 'Rediska' do
   pending 'real redis (interoperability)' do
     before do
       subject.flushall
+      subject.discard rescue nil
     end
 
     before(:all) do

data/spec/support/connection.rb

@@ -1,7 +1,7 @@
 shared_examples 'connection' do
   it 'should authenticate to the server' do
     begin
-      subject.auth('pass').should eq('OK')
+      expect(subject.auth('pass')).to eq('OK')
     rescue Redis::CommandError => e
       raise unless e.message == 'ERR Client sent AUTH, but no password is set'
     end
@@ -12,28 +12,28 @@ shared_examples 'connection' do
     subject2 = Redis.new(host: '127.0.0.1', port: 6379)
 
     subject1.set('key1', '1')
-    subject2.get('key1').should eq('1')
+    expect(subject2.get('key1')).to eq('1')
 
     subject2.set('key2', '2')
-    subject1.get('key2').should eq('2')
+    expect(subject1.get('key2')).to eq('2')
 
-    subject1.get('key3').should be_nil
-    subject2.get('key3').should be_nil
+    expect(subject1.get('key3')).to be_nil
+    expect(subject2.get('key3')).to be_nil
 
-    subject1.dbsize.should eq(2)
-    subject2.dbsize.should eq(2)
+    expect(subject1.dbsize).to eq(2)
+    expect(subject2.dbsize).to eq(2)
   end
 
   it 'should connect to a specific database' do
     subject1 = Redis.new(host: '127.0.0.1', port: 6379, db: 0)
     subject1.set('key1', '1')
     subject1.select(0)
-    subject1.get('key1').should eq('1')
+    expect(subject1.get('key1')).to eq('1')
 
     subject2 = Redis.new(host: '127.0.0.1', port: 6379, db: 1)
     subject2.set('key1', '1')
     subject2.select(1)
-    subject2.get('key1').should eq('1')
+    expect(subject2.get('key1')).to eq('1')
   end
 
   it 'should handle multiple clients using the same db instance' do
@@ -41,25 +41,25 @@ shared_examples 'connection' do
     subject2 = Redis.new(host: '127.0.0.1', port: 6379, db: 2)
 
     subject1.set('key1', 'one')
-    subject1.get('key1').should eq('one')
+    expect(subject1.get('key1')).to eq('one')
 
     subject2.set('key2', 'two')
-    subject2.get('key2').should eq('two')
+    expect(subject2.get('key2')).to eq('two')
 
-    subject1.get('key1').should eq('one')
+    expect(subject1.get('key1')).to eq('one')
   end
 
   it 'should not error with a disconnected client' do
     subject1 = Redis.new
     subject1.client.disconnect
-    subject1.get('key1').should be_nil
+    expect(subject1.get('key1')).to be_nil
   end
 
   it 'should echo the given string' do
-    subject.echo('something').should eq('something')
+    expect(subject.echo('something')).to eq('something')
   end
 
   it 'should ping the server' do
-    subject.ping.should eq('PONG')
+    expect(subject.ping).to eq('PONG')
   end
 end

data/spec/support/hashes.rb

@@ -2,102 +2,102 @@ shared_examples 'hashes' do
   it 'should delete a hash field' do
     subject.hset('key1', 'k1', 'val1')
     subject.hset('key1', 'k2', 'val2')
-    subject.hdel('key1', 'k1')
+    expect(subject.hdel('key1', 'k1')).to eq(1)
 
-    subject.hget('key1', 'k1').should be_nil
-    subject.hget('key1', 'k2').should eq('val2')
+    expect(subject.hget('key1', 'k1')).to be_nil
+    expect(subject.hget('key1', 'k2')).to eq('val2')
   end
 
   it 'should remove a hash with no keys left' do
     subject.hset('key1', 'k1', 'val1')
     subject.hset('key1', 'k2', 'val2')
-    subject.hdel('key1', 'k1')
-    subject.hdel('key1', 'k2')
+    expect(subject.hdel('key1', 'k1')).to eq(1)
+    expect(subject.hdel('key1', 'k2')).to eq(1)
 
-    subject.exists('key1').should be_false
+    expect(subject.exists('key1')).to be_falsey
   end
 
   it 'should convert key to a string for hset' do
     m = double('key')
-    m.stub(:to_s).and_return('foo')
+    allow(m).to receive(:to_s).and_return('foo')
 
     subject.hset('key1', m, 'bar')
-    subject.hget('key1', 'foo').should eq('bar')
+    expect(subject.hget('key1', 'foo')).to eq('bar')
   end
 
   it 'should convert key to a string for hget' do
     m = double('key')
-    m.stub(:to_s).and_return('foo')
+    allow(m).to receive(:to_s).and_return('foo')
 
     subject.hset('key1', 'foo', 'bar')
-    subject.hget('key1', m).should eq('bar')
+    expect(subject.hget('key1', m)).to eq('bar')
   end
 
   it 'should determine if a hash field exists' do
     subject.hset('key1', 'index', 'value')
 
-    subject.hexists('key1', 'index').should be_true
-    subject.hexists('key2', 'i2').should be_false
+    expect(subject.hexists('key1', 'index')).to be_truthy
+    expect(subject.hexists('key2', 'i2')).to be_falsey
   end
 
   it 'should get the value of a hash field' do
     subject.hset('key1', 'index', 'value')
 
-    subject.hget('key1', 'index').should eq('value')
+    expect(subject.hget('key1', 'index')).to eq('value')
   end
 
   it 'should get all the fields and values in a hash' do
     subject.hset('key1', 'i1', 'val1')
     subject.hset('key1', 'i2', 'val2')
 
-    subject.hgetall('key1').should eq({'i1' => 'val1', 'i2' => 'val2'})
+    expect(subject.hgetall('key1')).to eq({'i1' => 'val1', 'i2' => 'val2'})
   end
 
   it 'should increment the integer value of a hash field by the given number' do
     subject.hset('key1', 'cont1', '5')
-    subject.hincrby('key1', 'cont1', '5').should eq(10)
-    subject.hget('key1', 'cont1').should eq('10')
+    expect(subject.hincrby('key1', 'cont1', '5')).to eq(10)
+    expect(subject.hget('key1', 'cont1')).to eq('10')
   end
 
   it 'should increment non existing hash keys' do
-    subject.hget('key1', 'cont2').should be_nil
-    subject.hincrby('key1', 'cont2', '5').should eq(5)
+    expect(subject.hget('key1', 'cont2')).to be_nil
+    expect(subject.hincrby('key1', 'cont2', '5')).to eq(5)
   end
 
   it 'should increment the float value of a hash field by the given float' do
     subject.hset('key1', 'cont1', 5.0)
-    subject.hincrbyfloat('key1', 'cont1', 4.1).should be == 9.1
-    subject.hget('key1', 'cont1').should be == '9.1'
+    expect(subject.hincrbyfloat('key1', 'cont1', 4.1)).to eq(9.1)
+    expect(subject.hget('key1', 'cont1')).to eq('9.1')
   end
 
   it 'should increment non existing hash keys' do
-    subject.hget('key1', 'cont2').should be_nil
-    subject.hincrbyfloat('key1', 'cont2', 5.5).should be == 5.5
+    expect(subject.hget('key1', 'cont2')).to be_nil
+    expect(subject.hincrbyfloat('key1', 'cont2', 5.5)).to eq(5.5)
   end
 
   it 'should get all the fields in a hash' do
     subject.hset('key1', 'i1', 'val1')
     subject.hset('key1', 'i2', 'val2')
 
-    subject.hkeys('key1').should eq(['i1', 'i2'])
-    subject.hkeys('key2').should be_empty
+    expect(subject.hkeys('key1')).to eq(['i1', 'i2'])
+    expect(subject.hkeys('key2')).to be_empty
   end
 
   it 'should get the number of fields in a hash' do
     subject.hset('key1', 'i1', 'val1')
     subject.hset('key1', 'i2', 'val2')
 
-    subject.hlen('key1').should eq(2)
+    expect(subject.hlen('key1')).to eq(2)
   end
 
   it 'should get the values of all the given hash fields' do
     subject.hset('key1', 'i1', 'val1')
     subject.hset('key1', 'i2', 'val2')
 
-    subject.hmget('key1', 'i1', 'i2', 'i3').should eq(['val1', 'val2', nil])
-    subject.hmget('key1', ['i1', 'i2', 'i3']).should =~ ['val1', 'val2', nil]
+    expect(subject.hmget('key1', 'i1', 'i2', 'i3')).to eq(['val1', 'val2', nil])
+    expect(subject.hmget('key1', ['i1', 'i2', 'i3'])).to match_array(['val1', 'val2', nil])
 
-    subject.hmget('key2', 'i1', 'i2').should eq([nil, nil])
+    expect(subject.hmget('key2', 'i1', 'i2')).to eq([nil, nil])
   end
 
   it 'should throw an argument error when you do not ask for any keys' do
@@ -111,7 +111,7 @@ shared_examples 'hashes' do
       subject.hmset('key')
     }.to raise_error(Redis::CommandError)
 
-    subject.exists('key').should be_false
+    expect(subject.exists('key')).to be_falsey
   end
 
   it 'rejects an insert with a key but no value' do
@@ -123,7 +123,7 @@ shared_examples 'hashes' do
       subject.hmset('key', 'foo', 3, 'bar')
     }.to raise_error(Redis::CommandError)
 
-    subject.exists('key').should be_false
+    expect(subject.exists('key')).to be_falsey
   end
 
   it 'should reject the wrong number of arguments' do
@@ -135,48 +135,48 @@ shared_examples 'hashes' do
   it 'should set multiple hash fields to multiple values' do
     subject.hmset('key', 'k1', 'value1', 'k2', 'value2')
 
-    subject.hget('key', 'k1').should eq('value1')
-    subject.hget('key', 'k2').should eq('value2')
+    expect(subject.hget('key', 'k1')).to eq('value1')
+    expect(subject.hget('key', 'k2')).to eq('value2')
   end
 
   it 'should set multiple hash fields from a ruby hash to multiple values' do
     subject.mapped_hmset('foo', k1: 'value1', k2: 'value2')
 
-    subject.hget('foo', 'k1').should eq('value1')
-    subject.hget('foo', 'k2').should eq('value2')
+    expect(subject.hget('foo', 'k1')).to eq('value1')
+    expect(subject.hget('foo', 'k2')).to eq('value2')
   end
 
   it 'should set the string value of a hash field' do
-    subject.hset('key1', 'k1', 'val1').should be_true
-    subject.hset('key1', 'k1', 'val1').should be_false
+    expect(subject.hset('key1', 'k1', 'val1')).to be_truthy
+    expect(subject.hset('key1', 'k1', 'val1')).to be_falsey
 
-    subject.hget('key1', 'k1').should eq('val1')
+    expect(subject.hget('key1', 'k1')).to eq('val1')
   end
 
   it 'should set the value of a hash field, only if the field does not exist' do
     subject.hset('key1', 'k1', 'val1')
-    subject.hsetnx('key1', 'k1', 'value').should be_false
-    subject.hsetnx('key1', 'k2', 'val2').should be_true
-    subject.hsetnx('key1', :k1, 'value').should be_false
-    subject.hsetnx('key1', :k3, 'val3').should be_true
+    expect(subject.hsetnx('key1', 'k1', 'value')).to be_falsey
+    expect(subject.hsetnx('key1', 'k2', 'val2')).to be_truthy
+    expect(subject.hsetnx('key1', :k1, 'value')).to be_falsey
+    expect(subject.hsetnx('key1', :k3, 'val3')).to be_truthy
 
-    subject.hget('key1', 'k1').should eq('val1')
-    subject.hget('key1', 'k2').should eq('val2')
-    subject.hget('key1', 'k3').should eq('val3')
+    expect(subject.hget('key1', 'k1')).to eq('val1')
+    expect(subject.hget('key1', 'k2')).to eq('val2')
+    expect(subject.hget('key1', 'k3')).to eq('val3')
   end
 
   it 'should get all the values in a hash' do
     subject.hset('key1', 'k1', 'val1')
     subject.hset('key1', 'k2', 'val2')
 
-    subject.hvals('key1').should eq(['val1', 'val2'])
+    expect(subject.hvals('key1')).to eq(['val1', 'val2'])
   end
 
   it 'should accept a list of array pairs as arguments and not throw an invalid argument number error' do
     subject.hmset('key1', [:k1, 'val1'], [:k2, 'val2'], [:k3, 'val3'])
-    subject.hget('key1', :k1).should eq('val1')
-    subject.hget('key1', :k2).should eq('val2')
-    subject.hget('key1', :k3).should eq('val3')
+    expect(subject.hget('key1', :k1)).to eq('val1')
+    expect(subject.hget('key1', :k2)).to eq('val2')
+    expect(subject.hget('key1', :k3)).to eq('val3')
   end
 
   it 'should reject a list of arrays that contain an invalid number of arguments' do
@@ -187,16 +187,16 @@ shared_examples 'hashes' do
 
   it 'should convert a integer field name to string for hdel' do
     subject.hset('key1', '1', 1)
-    subject.hdel('key1', 1).should eq(1)
+    expect(subject.hdel('key1', 1)).to eq(1)
   end
 
   it 'should convert a integer field name to string for hexists' do
     subject.hset('key1', '1', 1)
-    subject.hexists('key1', 1).should be_true
+    expect(subject.hexists('key1', 1)).to be_truthy
   end
 
   it 'should convert a integer field name to string for hincrby' do
     subject.hset('key1', 1, 0)
-    subject.hincrby('key1', 1, 1).should eq(1)
+    expect(subject.hincrby('key1', 1, 1)).to eq(1)
   end
 end

data/spec/support/keys.rb

@@ -4,7 +4,7 @@ shared_examples 'keys' do
     subject.set('key2', '2')
     subject.del('key1', 'key2')
 
-    subject.get('key1').should be_nil
+    expect(subject.get('key1')).to be_nil
   end
 
   it 'should delete multiple keys' do
@@ -12,8 +12,8 @@ shared_examples 'keys' do
     subject.set('key2', '2')
     subject.del(['key1', 'key2'])
 
-    subject.get('key1').should be_nil
-    subject.get('key2').should be_nil
+    expect(subject.get('key1')).to be_nil
+    expect(subject.get('key2')).to be_nil
   end
 
   it 'should error deleting no keys' do
@@ -29,22 +29,22 @@ shared_examples 'keys' do
   it 'should determine if a key exists' do
     subject.set('key1', '1')
 
-    subject.exists('key1').should be_true
-    subject.exists('key2').should be_false
+    expect(subject.exists('key1')).to be_truthy
+    expect(subject.exists('key2')).to be_falsey
   end
 
   it "should set a key's time to live in seconds" do
     subject.set('key1', '1')
     subject.expire('key1', 1)
 
-    subject.ttl('key1').should eq(1)
+    expect(subject.ttl('key1')).to eq(1)
   end
 
   it "should set the expiration for a key as a UNIX timestamp" do
     subject.set('key1', '1')
     subject.expireat('key1', Time.now.to_i + 100)
 
-    subject.ttl('key1').should_not eq(-1)
+    expect(subject.ttl('key1')).not_to eq(-1)
   end
 
   it 'should not have an expiration after re-set' do
@@ -52,21 +52,21 @@ shared_examples 'keys' do
     subject.expireat('key1', Time.now.to_i + 2)
     subject.set('key1', '1')
 
-    subject.ttl('key1').should eq(-1)
+    expect(subject.ttl('key1')).to eq(-1)
   end
 
   it 'should not have a ttl if expired (and thus key does not exist)' do
     subject.set('key1', '1')
     subject.expireat('key1', Time.now.to_i)
 
-    subject.ttl('key1').should eq(-2)
+    expect(subject.ttl('key1')).to eq(-2)
   end
 
   it 'should not find a key if expired' do
     subject.set('key1', '1')
     subject.expireat('key1', Time.now.to_i)
 
-    subject.get('key1').should be_nil
+    expect(subject.get('key1')).to be_nil
   end
 
   it 'should not find multiple keys if expired' do
@@ -74,7 +74,7 @@ shared_examples 'keys' do
     subject.set('key2', '2')
     subject.expireat('key1', Time.now.to_i)
 
-    subject.mget('key1', 'key2').should eq([nil, '2'])
+    expect(subject.mget('key1', 'key2')).to eq([nil, '2'])
   end
 
   it 'should only find keys that are not expired' do
@@ -82,14 +82,14 @@ shared_examples 'keys' do
     subject.set('key2', '2')
     subject.expireat('key1', Time.now.to_i)
 
-    subject.keys.should eq(['key2'])
+    expect(subject.keys).to eq(['key2'])
   end
 
   it 'should not exist if expired' do
     subject.set('key1', '1')
     subject.expireat('key1', Time.now.to_i)
 
-    subject.exists('key1').should be_false
+    expect(subject.exists('key1')).to be_falsey
   end
 
   it 'should find all keys matching the given pattern' do
@@ -101,32 +101,32 @@ shared_examples 'keys' do
 
     subject.mset('database', 1, 'above', 2, 'suitability', 3, 'able', 4)
 
-    subject.keys('key:*').should =~ ['key:a', 'key:b', 'key:c']
-    subject.keys('ab*').should =~ ['above', 'able']
+    expect(subject.keys('key:*')).to match_array(['key:a', 'key:b', 'key:c'])
+    expect(subject.keys('ab*')).to match_array(['above', 'able'])
   end
 
   it 'should remove the expiration from a key' do
     subject.set('key1', '1')
     subject.expireat('key1', Time.now.to_i + 1)
-    subject.persist('key1').should be_true
-    subject.persist('key1').should be_false
+    expect(subject.persist('key1')).to be_truthy
+    expect(subject.persist('key1')).to be_falsey
 
-    subject.ttl('key1').should eq(-1)
+    expect(subject.ttl('key1')).to eq(-1)
   end
 
   it 'should return a random key from the keyspace' do
     subject.set('key1', '1')
     subject.set('key2', '2')
 
-    ['key1', 'key2'].should include(subject.randomkey)
+    expect(['key1', 'key2']).to include(subject.randomkey)
   end
 
   it 'should rename a key' do
     subject.set('key1', '2')
     subject.rename('key1', 'key2')
 
-    subject.get('key1').should be_nil
-    subject.get('key2').should eq('2')
+    expect(subject.get('key1')).to be_nil
+    expect(subject.get('key2')).to eq('2')
   end
 
   it 'should rename a key, only if new key does not exist' do
@@ -136,71 +136,67 @@ shared_examples 'keys' do
     subject.renamenx('key1', 'key2')
     subject.renamenx('key3', 'key4')
 
-    subject.get('key1').should eq('1')
-    subject.get('key2').should eq('2')
-    subject.get('key3').should be_nil
-    subject.get('key4').should eq('3')
-  end
-
-  it 'should sort the elements in a list, set or sorted set' do
-    pending 'SORT Command not implemented yet'
+    expect(subject.get('key1')).to eq('1')
+    expect(subject.get('key2')).to eq('2')
+    expect(subject.get('key3')).to be_nil
+    expect(subject.get('key4')).to eq('3')
   end
 
   it 'should determine the type stored at key' do
     subject.set('key1', '1')
 
     # Non-existing key.
-    subject.type('key0').should be == 'none'
+    expect(subject.type('key0')).to eq('none')
 
     # String.
     subject.set('key1', '1')
-    subject.type('key1').should be == 'string'
+    expect(subject.type('key1')).to eq('string')
 
 
     # List.
     subject.lpush('key2', '1')
-    subject.type('key2').should be == 'list'
+    expect(subject.type('key2')).to eq('list')
 
     # Set.
     subject.sadd('key3', '1')
-    subject.type('key3').should be == 'set'
+    expect(subject.type('key3')).to eq('set')
 
     # Sorted Set.
     subject.zadd('key4', 1.0, '1')
-    subject.type('key4').should be == 'zset'
+    expect(subject.type('key4')).to eq('zset')
 
     # Hash.
     subject.hset('key5', 'a', '1')
-    subject.type('key5').should be == 'hash'
+    expect(subject.type('key5')).to eq('hash')
   end
 
   it 'should convert the value into a string before storing' do
     subject.set('key1', 1)
-    subject.get('key1').should eq('1')
+    expect(subject.get('key1')).to eq('1')
 
     subject.setex('key2', 30, 1)
-    subject.get('key2').should eq('1')
+    expect(subject.get('key2')).to eq('1')
 
     subject.getset('key3', 1)
-    subject.get('key3').should eq('1')
+    expect(subject.get('key3')).to eq('1')
   end
 
   it "should return 'OK' for the setex command" do
-    subject.setex('key4', 30, 1).should eq('OK')
+    expect(subject.setex('key4', 30, 1)).to eq('OK')
   end
 
   it 'should convert the key into a string before storing' do
     subject.set(123, 'foo')
-    subject.keys.should include('123')
-    subject.get('123').should eq('foo')
+    expect(subject.keys).to include('123')
+    expect(subject.get('123')).to eq('foo')
 
     subject.setex(456, 30, 'foo')
-    subject.keys.should include('456')
-    subject.get('456').should eq('foo')
+    expect(subject.keys).to include('456')
+    expect(subject.get('456')).to eq('foo')
 
     subject.getset(789, 'foo')
-    subject.keys.should include('789')
-    subject.get('789').should eq('foo')
+    expect(subject.keys).to include('789')
+    expect(subject.get('789')).to eq('foo')
   end
 
   it 'should only operate against keys containing string values' do
@@ -229,26 +225,26 @@ shared_examples 'keys' do
     subject.select(0)
     subject.set('key1', '1')
 
-    subject.move('key1', 1).should be_true
+    expect(subject.move('key1', 1)).to be_truthy
 
     subject.select(0)
-    subject.get('key1').should be_nil
+    expect(subject.get('key1')).to be_nil
 
     subject.select(1)
-    subject.get('key1').should eq('1')
+    expect(subject.get('key1')).to eq('1')
   end
 
   it 'should fail to move a key that does not exist in the source database' do
     subject.select(0)
-    subject.get('key1').should be_nil
+    expect(subject.get('key1')).to be_nil
 
-    subject.move('key1', 1).should be_false
+    expect(subject.move('key1', 1)).to be_falsey
 
     subject.select(0)
-    subject.get('key1').should be_nil
+    expect(subject.get('key1')).to be_nil
 
     subject.select(1)
-    subject.get('key1').should be_nil
+    expect(subject.get('key1')).to be_nil
   end
 
   it 'should fail to move a key that exists in the destination database' do
@@ -259,13 +255,13 @@ shared_examples 'keys' do
     subject.set('key1', '2')
 
     subject.select(0)
-    subject.move('key1', 1).should be_false
+    expect(subject.move('key1', 1)).to be_falsey
 
     subject.select(0)
-    subject.get('key1').should eq('1')
+    expect(subject.get('key1')).to eq('1')
 
     subject.select(1)
-    subject.get('key1').should eq('2')
+    expect(subject.get('key1')).to eq('2')
   end
 
   it 'should fail to move a key to the same database' do
@@ -277,7 +273,7 @@ shared_examples 'keys' do
     }.to raise_error(Redis::CommandError, 'ERR source and destination objects are the same')
 
     subject.select(0)
-    subject.get('key1').should eq('1')
+    expect(subject.get('key1')).to eq('1')
   end
 
   it 'should scan all keys in the database' do
@@ -293,8 +289,8 @@ shared_examples 'keys' do
       break if cursor == '0'
     end
 
-    all_keys.uniq.should have(100).items
-    all_keys[0].should =~ /key\d+/
+    expect(all_keys.uniq.size).to eq(100)
+    expect(all_keys[0]).to match(/key\d+/)
   end
 
   it "should match keys to a pattern when scanning" do
@@ -313,7 +309,7 @@ shared_examples 'keys' do
       break if cursor == '0'
     end
 
-    all_keys.uniq.should have(50).items
+    expect(all_keys.uniq.size).to eq(50)
   end
 
   it 'should specify doing more work when scanning' do
@@ -323,7 +319,56 @@ shared_examples 'keys' do
 
     cursor, all_keys = subject.scan(cursor, count: 100)
 
-    cursor.should eq('0')
-    all_keys.uniq.should have(100).items
+    expect(cursor).to eq('0')
+    expect(all_keys.uniq.size).to eq(100)
+  end
+
+  context 'with extended options' do
+    it 'uses ex option to set the expire time, in seconds' do
+      ttl = 7
+
+      expect(subject.set('key1', '1', ex: ttl)).to eq('OK')
+      expect(subject.ttl('key1')).to eq(ttl)
+    end
+
+    it 'uses px option to set the expire time, in miliseconds' do
+      ttl = 7000
+
+      expect(subject.set('key1', '1', px: ttl)).to eq('OK')
+      expect(subject.ttl('key1')).to eq(ttl / 1000)
+    end
+
+    # Note that the redis-rb implementation will always give PX last.
+    # Redis seems to process each expiration option and the last one wins.
+    it 'prefers the finer-grained PX expiration option over EX' do
+      ttl_px = 6000
+      ttl_ex = 10
+
+      subject.set('key1', '1', px: ttl_px, ex: ttl_ex)
+      expect(subject.ttl('key1')).to eq(ttl_px / 1000)
+
+      subject.set('key1', '1', ex: ttl_ex, px: ttl_px)
+      expect(subject.ttl('key1')).to eq(ttl_px / 1000)
+    end
+
+    it 'uses nx option to only set the key if it does not already exist' do
+      expect(subject.set('key1', '1', nx: true)).to be_truthy
+      expect(subject.set('key1', '2', nx: true)).to be_falsey
+
+      expect(subject.get('key1')).to eq('1')
+    end
+
+    it 'uses xx option to only set the key if it already exists' do
+      expect(subject.set('key2', '1', xx: true)).to be_falsey
+      subject.set('key2', '2')
+      expect(subject.set('key2', '1', xx: true)).to be_truthy
+
+      expect(subject.get('key2')).to eq('1')
+    end
+
+    it 'does not set the key if both xx and nx option are specified' do
+      expect(subject.set('key2', '1', nx: true, xx: true)).to be_falsey
+      expect(subject.get('key2')).to be_nil
+    end
   end
 end