rediska 0.0.2

data/spec/support/keys.rb

@@ -0,0 +1,261 @@
+shared_examples 'keys' do
+  it 'should delete a key' do
+    subject.set('key1', '1')
+    subject.set('key2', '2')
+    subject.del('key1', 'key2')
+
+    subject.get('key1').should be_nil
+  end
+
+  it 'should delete multiple keys' do
+    subject.set('key1', '1')
+    subject.set('key2', '2')
+    subject.del(['key1', 'key2'])
+
+    subject.get('key1').should be_nil
+    subject.get('key2').should be_nil
+  end
+
+  it 'should error deleting no keys' do
+    expect {
+      subject.del
+    }.to raise_error(Redis::CommandError)
+
+    expect {
+      subject.del []
+    }.to raise_error(Redis::CommandError)
+  end
+
+  it 'should determine if a key exists' do
+    subject.set('key1', '1')
+
+    subject.exists('key1').should be_true
+    subject.exists('key2').should be_false
+  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)
+  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)
+  end
+
+  it 'should not have an expiration after re-set' do
+    subject.set('key1', '1')
+    subject.expireat('key1', Time.now.to_i + 2)
+    subject.set('key1', '1')
+
+    subject.ttl('key1').should eq(-1)
+  end
+
+  it 'should not have a ttl if expired' do
+    subject.set('key1', '1')
+    subject.expireat('key1', Time.now.to_i)
+
+    subject.ttl('key1').should eq(-1)
+  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
+  end
+
+  it 'should not find multiple keys if expired' do
+    subject.set('key1', '1')
+    subject.set('key2', '2')
+    subject.expireat('key1', Time.now.to_i)
+
+    subject.mget('key1', 'key2').should eq([nil, '2'])
+  end
+
+  it 'should only find keys that are not expired' do
+    subject.set('key1', '1')
+    subject.set('key2', '2')
+    subject.expireat('key1', Time.now.to_i)
+
+    subject.keys.should 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
+  end
+
+  it 'should find all keys matching the given pattern' do
+    subject.set('key:a', '1')
+    subject.set('key:b', '2')
+    subject.set('key:c', '3')
+    subject.set('akeyd', '4')
+    subject.set('key1', '5')
+
+    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']
+  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
+
+    subject.ttl('key1').should 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)
+  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')
+  end
+
+  it 'should rename a key, only if new key does not exist' do
+    subject.set('key1', '1')
+    subject.set('key2', '2')
+    subject.set('key3', '3')
+    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'
+  end
+
+  it 'should determine the type stored at key' do
+    subject.set('key1', '1')
+
+    subject.type('key1').should eq('string')
+    subject.type('key0').should eq('none')
+  end
+
+  it 'should convert the value into a string before storing' do
+    subject.set('key1', 1)
+    subject.get('key1').should eq('1')
+
+    subject.setex('key2', 30, 1)
+    subject.get('key2').should eq('1')
+
+    subject.getset('key3', 1)
+    subject.get('key3').should eq('1')
+  end
+
+  it "should return 'OK' for the setex command" do
+    subject.setex('key4', 30, 1).should 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')
+
+    subject.setex(456, 30, 'foo')
+    subject.keys.should include('456')
+    subject.get('456').should eq('foo')
+
+    subject.getset(789, 'foo')
+    subject.keys.should include('789')
+    subject.get('789').should eq('foo')
+  end
+
+  it 'should only operate against keys containing string values' do
+    subject.sadd('key1', 'one')
+
+    expect {
+      subject.get('key1')
+    }.to raise_error(Redis::CommandError, 'ERR Operation against a key holding the wrong kind of value')
+
+    expect {
+      subject.getset('key1', 1)
+    }.to raise_error(Redis::CommandError, 'ERR Operation against a key holding the wrong kind of value')
+
+    subject.hset('key2', 'one', 'two')
+
+    expect {
+      subject.get('key2')
+    }.to raise_error(Redis::CommandError, 'ERR Operation against a key holding the wrong kind of value')
+
+    expect {
+      subject.getset('key2', 1)
+    }.to raise_error(Redis::CommandError, 'ERR Operation against a key holding the wrong kind of value')
+  end
+
+  it 'should move a key from one database to another successfully' do
+    subject.select(0)
+    subject.set('key1', '1')
+
+    subject.move('key1', 1).should be_true
+
+    subject.select(0)
+    subject.get('key1').should be_nil
+
+    subject.select(1)
+    subject.get('key1').should 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
+
+    subject.move('key1', 1).should be_false
+
+    subject.select(0)
+    subject.get('key1').should be_nil
+
+    subject.select(1)
+    subject.get('key1').should be_nil
+  end
+
+  it 'should fail to move a key that exists in the destination database' do
+    subject.select(0)
+    subject.set('key1', '1')
+
+    subject.select(1)
+    subject.set('key1', '2')
+
+    subject.select(0)
+    subject.move('key1', 1).should be_false
+
+    subject.select(0)
+    subject.get('key1').should eq('1')
+
+    subject.select(1)
+    subject.get('key1').should eq('2')
+  end
+
+  it 'should fail to move a key to the same database' do
+    subject.select(0)
+    subject.set('key1', '1')
+
+    expect {
+      subject.move('key1', 0)
+    }.to raise_error(Redis::CommandError, 'ERR source and destination objects are the same')
+
+    subject.select(0)
+    subject.get('key1').should eq('1')
+  end
+end

data/spec/support/lists.rb

@@ -0,0 +1,196 @@
+shared_examples 'lists' do
+  it 'should get an element from a list by its index' 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
+  end
+
+  it 'should insert an element before or after another element in a list' do
+    subject.rpush('key1', 'v1')
+    subject.rpush('key1', 'v3')
+    subject.linsert('key1', :before, 'v3', 'v2')
+
+    subject.lrange('key1', 0, -1).should 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'])
+  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'])
+  end
+
+  it 'should error if an invalid where argument is given' do
+    subject.rpush('key1', 'v1')
+    subject.rpush('key1', 'v3')
+
+    expect {
+      subject.linsert('key1', :invalid, 'v3', 'v2')
+    }.to raise_error(Redis::CommandError)
+  end
+
+  it 'should get the length of a list' do
+    subject.rpush('key1', 'v1')
+    subject.rpush('key1', 'v2')
+
+    subject.llen('key1').should eq(2)
+    subject.llen('key2').should eq(0)
+  end
+
+  it 'should remove and get the first element in a list' do
+    subject.rpush('key1', 'v1')
+    subject.rpush('key1', 'v2')
+    subject.rpush('key1', 'v3')
+
+    subject.lpop('key1').should eq('v1')
+    subject.lrange('key1', 0, -1).should 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'])
+  end
+
+  it 'should prepend a value to a list, only if the list exists' do
+    subject.lpush('key1', 'v1')
+
+    subject.lpushx('key1', 'v2')
+    subject.lpushx('key2', 'v3')
+
+    subject.lrange('key1', 0, -1).should eq(['v2', 'v1'])
+    subject.llen('key2').should eq(0)
+  end
+
+  it 'should get a range of elements from a list' do
+    subject.rpush('key1', 'v1')
+    subject.rpush('key1', 'v2')
+    subject.rpush('key1', 'v3')
+
+    subject.lrange('key1', 1, -1).should eq(['v2', 'v3'])
+  end
+
+  it 'should remove elements from a list' do
+    subject.rpush('key1', 'v1')
+    subject.rpush('key1', 'v2')
+    subject.rpush('key1', 'v2')
+    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)
+  end
+
+  it "should remove list's key when list is empty" do
+    subject.rpush('key1', 'v1')
+    subject.rpush('key1', 'v2')
+    subject.lrem('key1', 1, 'v1')
+    subject.lrem('key1', 1, 'v2')
+
+    subject.exists('key1').should be_false
+  end
+
+  it 'should set the value of an element in a list by its index' do
+    subject.rpush('key1', 'one')
+    subject.rpush('key1', 'two')
+    subject.rpush('key1', 'three')
+
+    subject.lset('key1', 0, 'four')
+    subject.lset('key1', -2, 'five')
+    subject.lrange('key1', 0, -1).should eq(['four', 'five', 'three'])
+
+    expect {
+      subject.lset('key1', 4, 'six')
+    }.to raise_error(Redis::CommandError)
+  end
+
+  it 'should trim a list to the specified range' do
+    subject.rpush('key1', 'one')
+    subject.rpush('key1', 'two')
+    subject.rpush('key1', 'three')
+
+    subject.ltrim('key1', 1, -1)
+    subject.lrange('key1', 0, -1).should eq(['two', 'three'])
+  end
+
+  context 'when the list is smaller than the requested trim' do
+    before do
+      subject.rpush('listOfOne', 'one')
+    end
+
+    context 'trimming with a negative start (specifying a max)' do
+      before do
+        subject.ltrim('listOfOne', -5, -1)
+      end
+
+      it 'returns the unmodified list' do
+        subject.lrange('listOfOne', 0, -1).should  eq(['one'])
+      end
+    end
+  end
+
+  context 'when the list is larger than the requested trim' do
+    before do
+      subject.rpush('maxTest', 'one')
+      subject.rpush('maxTest', 'two')
+      subject.rpush('maxTest', 'three')
+      subject.rpush('maxTest', 'four')
+      subject.rpush('maxTest', 'five')
+      subject.rpush('maxTest', 'six')
+    end
+
+    context 'trimming with a negative start (specifying a max)' do
+      before do
+        subject.ltrim('maxTest', -5, -1)
+      end
+
+      it 'should trim a list to the specified maximum size' do
+        subject.lrange('maxTest', 0, -1).should eq(['two','three', 'four', 'five', 'six'])
+      end
+    end
+  end
+
+  it 'should remove and return the last element in a list' do
+    subject.rpush('key1', 'one')
+    subject.rpush('key1', 'two')
+    subject.rpush('key1', 'three')
+
+    subject.rpop('key1').should eq('three')
+    subject.lrange('key1', 0, -1).should eq(['one', 'two'])
+  end
+
+  it 'should remove the last element in a list, append it to another list and return it' do
+    subject.rpush('key1', 'one')
+    subject.rpush('key1', 'two')
+    subject.rpush('key1', 'three')
+
+    subject.rpoplpush('key1', 'key2').should eq('three')
+
+    subject.lrange('key1', 0, -1).should eq(['one', 'two'])
+    subject.lrange('key2', 0, -1).should eq(['three'])
+  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'])
+  end
+
+  it 'should append a value to a list, only if the list exists' do
+    subject.rpush('key1', 'one')
+    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
+  end
+end

data/spec/support/server.rb

@@ -0,0 +1,93 @@
+shared_examples 'server' do
+  it 'should return the number of keys in the selected database' do
+    subject.set('key1', '1')
+    subject.set('key2', '2')
+    subject.set('key2', 'two')
+
+    subject.dbsize.should eq(2)
+  end
+
+  it 'should get information and statistics about the server' do
+    subject.info.key?('redis_version').should be_true
+  end
+
+  it 'should handle non-existent methods' do
+    expect {
+      subject.idontexist
+    }.to raise_error(Redis::CommandError)
+  end
+
+  describe 'multiple databases' do
+    it 'should default to database 0' do
+      subject.inspect.should =~ %r#/0>$#
+    end
+
+    it 'should select another database' do
+      subject.select(1)
+      subject.inspect.should =~ %r#/1>$#
+    end
+
+    it 'should store keys separately in each database' do
+      subject.select(0).should eq('OK')
+      subject.set('key1', '1')
+      subject.set('key2', '2')
+
+      subject.select(1)
+      subject.set('key3', '3')
+      subject.set('key4', '4')
+      subject.set('key5', '5')
+
+      subject.select(0)
+      subject.dbsize.should eq(2)
+      subject.exists('key1').should be_true
+      subject.exists('key3').should be_false
+
+      subject.select(1)
+      subject.dbsize.should eq(3)
+      subject.exists('key4').should be_true
+      subject.exists('key2').should be_false
+
+      subject.flushall
+      subject.dbsize.should eq(0)
+
+      subject.select(0)
+      subject.dbsize.should 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)
+
+      subject.select(1)
+      subject.set('key3', '3')
+      subject.set('key4', '4')
+      subject.dbsize.should eq(2)
+
+      subject.flushdb.should eq('OK')
+
+      subject.dbsize.should eq(0)
+      subject.select(0)
+      subject.dbsize.should 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)
+
+      subject.select(1)
+      subject.set('key3', '3')
+      subject.set('key4', '4')
+      subject.dbsize.should eq(2)
+
+      subject.flushall.should eq('OK')
+
+      subject.dbsize.should eq(0)
+      subject.select(0)
+      subject.dbsize.should eq(0)
+    end
+  end
+end