rediska 0.0.11 → 0.1.0

data/spec/support/strings.rb

@@ -3,42 +3,42 @@ shared_examples 'strings' do
     subject.set('key1', 'Hello')
     subject.append('key1', ' World')
 
-    subject.get('key1').should eq('Hello World')
+    expect(subject.get('key1')).to eq('Hello World')
   end
 
   it 'should decrement the integer value of a key by one' do
     subject.set('counter', '1')
     subject.decr('counter')
 
-    subject.get('counter').should eq('0')
+    expect(subject.get('counter')).to eq('0')
   end
 
   it 'should decrement the integer value of a key by the given number' do
     subject.set('counter', '10')
     subject.decrby('counter', '5')
 
-    subject.get('counter').should eq('5')
+    expect(subject.get('counter')).to eq('5')
   end
 
   it 'should get the value of a key' do
-    subject.get('key2').should be_nil
+    expect(subject.get('key2')).to be_nil
   end
 
   it 'should returns the bit value at offset in the string value stored at key' do
     subject.set('key1', 'a')
 
-    subject.getbit('key1', 1).should eq(1)
-    subject.getbit('key1', 2).should eq(1)
-    subject.getbit('key1', 3).should eq(0)
-    subject.getbit('key1', 4).should eq(0)
-    subject.getbit('key1', 5).should eq(0)
-    subject.getbit('key1', 6).should eq(0)
-    subject.getbit('key1', 7).should eq(1)
+    expect(subject.getbit('key1', 1)).to eq(1)
+    expect(subject.getbit('key1', 2)).to eq(1)
+    expect(subject.getbit('key1', 3)).to eq(0)
+    expect(subject.getbit('key1', 4)).to eq(0)
+    expect(subject.getbit('key1', 5)).to eq(0)
+    expect(subject.getbit('key1', 6)).to eq(0)
+    expect(subject.getbit('key1', 7)).to eq(1)
   end
 
   it 'should allow direct bit manipulation even if the string is not set' do
     subject.setbit('key1', 10, 1)
-    subject.getbit('key1', 10).should eq(1)
+    expect(subject.getbit('key1', 10)).to eq(1)
   end
 
   context 'when a bit is previously set to 0' do
@@ -47,11 +47,11 @@ shared_examples 'strings' do
     end
 
     it 'setting it to 1 returns 0' do
-      subject.setbit('key1', 10, 1).should eq(0)
+      expect(subject.setbit('key1', 10, 1)).to eq(0)
     end
 
     it 'setting it to 0 returns 0' do
-      subject.setbit('key1', 10, 0).should eq(0)
+      expect(subject.setbit('key1', 10, 0)).to eq(0)
     end
   end
 
@@ -61,95 +61,95 @@ shared_examples 'strings' do
     end
 
     it 'setting it to 0 returns 1' do
-      subject.setbit('key1', 10, 0).should eq(1)
+      expect(subject.setbit('key1', 10, 0)).to eq(1)
     end
 
     it 'setting it to 1 returns 1' do
-      subject.setbit('key1', 10, 1).should eq(1)
+      expect(subject.setbit('key1', 10, 1)).to eq(1)
     end
   end
 
   it 'should get a substring of the string stored at a key' do
     subject.set('key1', 'This a message')
 
-    subject.getrange('key1', 0, 3).should eq('This')
-    subject.substr('key1', 0, 3).should eq('This')
+    expect(subject.getrange('key1', 0, 3)).to eq('This')
+    expect(subject.substr('key1', 0, 3)).to eq('This')
   end
 
   it 'should set the string value of a key and return its old value' do
     subject.set('key1','value1')
 
-    subject.getset('key1', 'value2').should eq('value1')
-    subject.get('key1').should eq('value2')
+    expect(subject.getset('key1', 'value2')).to eq('value1')
+    expect(subject.get('key1')).to eq('value2')
   end
 
   it 'should return nil for #getset if the key does not exist when setting' do
-    subject.getset('key1', 'value1').should be_nil
-    subject.get('key1').should eq('value1')
+    expect(subject.getset('key1', 'value1')).to be_nil
+    expect(subject.get('key1')).to eq('value1')
   end
 
   it 'should increment the integer value of a key by one' do
     subject.set('counter', '1')
-    subject.incr('counter').should eq(2)
+    expect(subject.incr('counter')).to eq(2)
 
-    subject.get('counter').should eq('2')
+    expect(subject.get('counter')).to eq('2')
   end
 
   it 'should not change the expire value of the key during incr' do
     subject.set('counter', '1')
-    subject.expire('counter', 600).should be_true
+    expect(subject.expire('counter', 600)).to be_truthy
 
-    subject.ttl('counter').should eq(600)
-    subject.incr('counter').should eq(2)
-    subject.ttl('counter').should be_within(10).of(600)
+    expect(subject.ttl('counter')).to eq(600)
+    expect(subject.incr('counter')).to eq(2)
+    expect(subject.ttl('counter')).to be_within(10).of(600)
   end
 
   it 'should decrement the integer value of a key by one' do
     subject.set('counter', '1')
-    subject.decr('counter').should eq(0)
+    expect(subject.decr('counter')).to eq(0)
 
-    subject.get('counter').should eq('0')
+    expect(subject.get('counter')).to eq('0')
   end
 
   it 'should not change the expire value of the key during decr' do
     subject.set('counter', '2')
-    subject.expire('counter', 600).should be_true
+    expect(subject.expire('counter', 600)).to be_truthy
 
-    subject.ttl('counter').should eq(600)
-    subject.decr('counter').should eq(1)
-    subject.ttl('counter').should be_within(10).of(600)
+    expect(subject.ttl('counter')).to eq(600)
+    expect(subject.decr('counter')).to eq(1)
+    expect(subject.ttl('counter')).to be_within(10).of(600)
   end
 
   it 'should increment the integer value of a key by the given number' do
     subject.set('counter', '10')
-    subject.incrby('counter', '5').should eq(15)
-    subject.incrby('counter', 2).should eq(17)
-    subject.get('counter').should eq('17')
+    expect(subject.incrby('counter', '5')).to eq(15)
+    expect(subject.incrby('counter', 2)).to eq(17)
+    expect(subject.get('counter')).to eq('17')
   end
 
   it 'should not change the expire value of the key during incrby' do
     subject.set('counter', '1')
-    subject.expire('counter', 600).should be_true
+    expect(subject.expire('counter', 600)).to be_truthy
 
-    subject.ttl('counter').should eq(600)
-    subject.incrby('counter', '5').should eq(6)
-    subject.ttl('counter').should be_within(10).of(600)
+    expect(subject.ttl('counter')).to eq(600)
+    expect(subject.incrby('counter', '5')).to eq(6)
+    expect(subject.ttl('counter')).to be_within(10).of(600)
   end
 
   it 'should decrement the integer value of a key by the given number' do
     subject.set('counter', '10')
-    subject.decrby('counter', '5').should eq(5)
-    subject.decrby('counter', 2).should eq(3)
-    subject.get('counter').should eq('3')
+    expect(subject.decrby('counter', '5')).to eq(5)
+    expect(subject.decrby('counter', 2)).to eq(3)
+    expect(subject.get('counter')).to eq('3')
   end
 
   it 'should not change the expire value of the key during decrby' do
     subject.set('counter', '8')
-    subject.expire('counter', 600).should be_true
+    expect(subject.expire('counter', 600)).to be_truthy
 
-    subject.ttl('counter').should eq(600)
-    subject.decrby('counter', '3').should eq(5)
-    subject.ttl('counter').should be_within(10).of(600)
+    expect(subject.ttl('counter')).to eq(600)
+    expect(subject.decrby('counter', '3')).to eq(5)
+    expect(subject.ttl('counter')).to be_within(10).of(600)
   end
 
   it 'should get the values of all the given keys' do
@@ -157,16 +157,16 @@ shared_examples 'strings' do
     subject.set('key2', 'value2')
     subject.set('key3', 'value3')
 
-    subject.mget('key1', 'key2', 'key3').should eq(['value1', 'value2', 'value3'])
-    subject.mget(['key1', 'key2', 'key3']).should eq(['value1', 'value2', 'value3'])
+    expect(subject.mget('key1', 'key2', 'key3')).to eq(['value1', 'value2', 'value3'])
+    expect(subject.mget(['key1', 'key2', 'key3'])).to eq(['value1', 'value2', 'value3'])
   end
 
   it 'returns nil for non existent keys' do
     subject.set('key1', 'value1')
     subject.set('key3', 'value3')
 
-    subject.mget('key1', 'key2', 'key3', 'key4').should eq(['value1', nil, 'value3', nil])
-    subject.mget(['key1', 'key2', 'key3', 'key4']).should eq(['value1', nil, 'value3', nil])
+    expect(subject.mget('key1', 'key2', 'key3', 'key4')).to eq(['value1', nil, 'value3', nil])
+    expect(subject.mget(['key1', 'key2', 'key3', 'key4'])).to eq(['value1', nil, 'value3', nil])
   end
 
   it 'raises an argument error when not passed any fields' do
@@ -180,8 +180,8 @@ shared_examples 'strings' do
   it 'should set multiple keys to multiple values' do
     subject.mset(:key1, 'value1', :key2, 'value2')
 
-    subject.get('key1').should eq('value1')
-    subject.get('key2').should eq('value2')
+    expect(subject.get('key1')).to eq('value1')
+    expect(subject.get('key2')).to eq('value2')
   end
 
   it 'should raise error if command arguments count is wrong' do
@@ -197,51 +197,51 @@ shared_examples 'strings' do
       subject.mset(:key1, 'value', :key2)
     }.to raise_error(Redis::CommandError, 'ERR wrong number of arguments for MSET')
 
-    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 set multiple keys to multiple values, only if none of the keys exist' do
-    subject.msetnx(:key1, 'value1', :key2, 'value2').should be_true
-    subject.msetnx(:key1, 'value3', :key2, 'value4').should be_false
+    expect(subject.msetnx(:key1, 'value1', :key2, 'value2')).to be_truthy
+    expect(subject.msetnx(:key1, 'value3', :key2, 'value4')).to be_falsey
 
-    subject.get('key1').should eq('value1')
-    subject.get('key2').should eq('value2')
+    expect(subject.get('key1')).to eq('value1')
+    expect(subject.get('key2')).to eq('value2')
   end
 
   it 'should set multiple keys to multiple values with a hash' do
     subject.mapped_mset(key1: 'value1', key2: 'value2')
 
-    subject.get('key1').should eq('value1')
-    subject.get('key2').should eq('value2')
+    expect(subject.get('key1')).to eq('value1')
+    expect(subject.get('key2')).to eq('value2')
   end
 
   it 'should set multiple keys to multiple values with a hash, only if none of the keys exist' do
-    subject.mapped_msetnx(key1: 'value1', key2: 'value2').should be_true
-    subject.mapped_msetnx(key1: 'value3', key2: 'value4').should be_false
+    expect(subject.mapped_msetnx(key1: 'value1', key2: 'value2')).to be_truthy
+    expect(subject.mapped_msetnx(key1: 'value3', key2: 'value4')).to be_falsey
 
-    subject.get('key1').should eq('value1')
-    subject.get('key2').should eq('value2')
+    expect(subject.get('key1')).to eq('value1')
+    expect(subject.get('key2')).to eq('value2')
   end
 
   it 'should set the string value of a key' do
     subject.set('key1', '1')
 
-    subject.get('key1').should eq('1')
+    expect(subject.get('key1')).to eq('1')
   end
 
   it 'should sets or clears the bit at offset in the string value stored at key' do
     subject.set('key1', 'abc')
     subject.setbit('key1', 11, 1)
 
-    subject.get('key1').should eq('arc')
+    expect(subject.get('key1')).to eq('arc')
   end
 
   it 'should set the value and expiration of a key' do
     subject.setex('key1', 30, 'value1')
 
-    subject.get('key1').should eq('value1')
-    subject.ttl('key1').should eq(30)
+    expect(subject.get('key1')).to eq('value1')
+    expect(subject.ttl('key1')).to eq(30)
   end
 
   it 'should set the value of a key, only if the key does not exist' do
@@ -249,20 +249,20 @@ shared_examples 'strings' do
     subject.setnx('key1', 'new value')
     subject.setnx('key2', 'another value')
 
-    subject.get('key1').should eq('test value')
-    subject.get('key2').should eq('another value')
+    expect(subject.get('key1')).to eq('test value')
+    expect(subject.get('key2')).to eq('another value')
   end
 
   it 'should overwrite part of a string at key starting at the specified offset' do
     subject.set('key1', 'Hello World')
     subject.setrange('key1', 6, 'Redis')
 
-    subject.get('key1').should eq('Hello Redis')
+    expect(subject.get('key1')).to eq('Hello Redis')
   end
 
   it 'should get the length of the value stored in a key' do
     subject.set('key1', 'abc')
 
-    subject.strlen('key1').should eq(3)
+    expect(subject.strlen('key1')).to eq(3)
   end
 end

data/spec/support/transactions.rb

@@ -1,19 +1,72 @@
 shared_examples 'transactions' do
-  it 'should mark the start of a transaction block' do
-    transaction = subject.multi do
-      subject.set('key1', '1')
-      subject.set('key2', '2')
-      subject.mget('key1', 'key2')
+  context '#multi' do
+    it "should respond with 'OK'" do
+      expect(subject.multi).to eq('OK')
     end
 
-    transaction.should eq(['OK', 'OK', ['1', '2']])
+    it "should forbid nesting" do
+      subject.multi
+      expect{subject.multi}.to raise_error(Redis::CommandError)
+    end
+
+    it "should mark the start of a transaction block" do
+      transaction = subject.multi do |multi|
+        multi.set('key1', '1')
+        multi.set('key2', '2')
+        multi.mget('key1', 'key2')
+      end
+
+      expect(transaction).to eq(['OK', 'OK', ['1', '2']])
+    end
+  end
+
+  context '#discard' do
+    it "should responde with 'OK' after #multi" do
+      subject.multi
+      expect(subject.discard).to eq('OK')
+    end
+
+    it "can't be run outside of #multi/#exec" do
+      expect{subject.discard}.to raise_error(Redis::CommandError)
+    end
+  end
+
+  context '#exec' do
+    it "can't be run outside of #multi" do
+      expect{subject.exec}.to raise_error(Redis::CommandError)
+    end
   end
 
-  it 'should execute all command after multi' do
-    subject.multi
-    subject.set('key1', '1')
-    subject.set('key2', '2')
-    subject.mget('key1', 'key2')
-    subject.exec.should be == ['OK', 'OK', ['1', '2']]
+  context 'saving up commands for later' do
+    before(:each) do
+      subject.multi
+    end
+
+    let(:string) { 'fake-redis-test:string' }
+    let(:list) { 'fake-redis-test:list' }
+
+    it "makes commands respond with 'QUEUED'" do
+      expect(subject.set(string, 'string')).to eq('QUEUED')
+      expect(subject.lpush(list, 'list')).to eq('QUEUED')
+    end
+
+    it "gives you the commands' responses when you call #exec" do
+      subject.set(string, 'string')
+      subject.lpush(list, 'list')
+      subject.lpush(list, 'list')
+
+      expect(subject.exec).to eq(['OK', 1, 2])
+    end
+
+    it "does not raise exceptions, but rather puts them in #exec's response" do
+      subject.set(string, 'string')
+      subject.lpush(string, 'oops!')
+      subject.lpush(list, 'list')
+
+      responses = subject.exec
+      expect(responses[0]).to eq('OK')
+      expect(responses[1]).to be_a(RuntimeError)
+      expect(responses[2]).to eq(1)
+    end
   end
 end

data/spec/support/upcase_method_names.rb

@@ -1,9 +1,9 @@
 shared_examples 'upcase method names' do
   it '#ZCOUNT' do
-    subject.ZCOUNT('key', 2, 3).should eq(subject.zcount('key', 2, 3))
+    expect(subject.ZCOUNT('key', 2, 3)).to eq(subject.zcount('key', 2, 3))
   end
 
   it '#ZSCORE' do
-    subject.ZSCORE('key', 2).should eq(subject.zscore('key', 2))
+    expect(subject.ZSCORE('key', 2)).to eq(subject.zscore('key', 2))
   end
 end

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: rediska
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.1.0
 platform: ruby
 authors:
 - Leonid Beder
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-08 00:00:00.000000000 Z
+date: 2014-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: |-
@@ -75,23 +75,26 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
 - lib/rediska.rb
+- lib/rediska/command_executor.rb
 - lib/rediska/configuration.rb
 - lib/rediska/connection.rb
 - lib/rediska/databases/expiring.rb
 - lib/rediska/databases/memory.rb
 - lib/rediska/databases/pstore.rb
 - lib/rediska/driver.rb
+- lib/rediska/sort_method.rb
 - lib/rediska/sorted_set_argument_handler.rb
 - lib/rediska/sorted_set_store.rb
+- lib/rediska/transaction_commands.rb
 - lib/rediska/version.rb
 - lib/rediska/zset.rb
 - rediska.gemspec
@@ -105,6 +108,7 @@ files:
 - spec/support/lists.rb
 - spec/support/server.rb
 - spec/support/sets.rb
+- spec/support/sorted_method.rb
 - spec/support/sorted_sets.rb
 - spec/support/strings.rb
 - spec/support/transactions.rb
@@ -119,12 +123,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -144,6 +148,7 @@ test_files:
 - spec/support/lists.rb
 - spec/support/server.rb
 - spec/support/sets.rb
+- spec/support/sorted_method.rb
 - spec/support/sorted_sets.rb
 - spec/support/strings.rb
 - spec/support/transactions.rb