rediska 0.0.4 → 0.0.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rediska (0.0.4)
+    rediska (0.0.5)
       redis (~> 3.0.0)
 
 GEM

data/lib/rediska/driver.rb

@@ -404,7 +404,7 @@ module Rediska
     def sdiff(key1, *keys)
       [key1, *keys].each { |k| data_type_check(k, ::Set) }
       keys = keys.map { |k| data[k] || ::Set.new }
-      keys.inject(data[key1]) do |memo, set|
+      keys.inject(data[key1] || Set.new) do |memo, set|
         memo - set
       end.to_a
     end
@@ -732,7 +732,7 @@ module Rediska
       return 0 unless data[key]
 
       response = values.map do |v|
-        data[key].delete(v) if data[key].has_key?(v)
+        data[key].delete(v.to_s) if data[key].has_key?(v.to_s)
       end.compact.size
 
       remove_key_for_empty_collection(key)

data/lib/rediska/version.rb

@@ -1,3 +1,3 @@
 module Rediska
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/spec/support/sets.rb

@@ -44,6 +44,12 @@ shared_examples 'sets' do
     subject.sdiff('key1', 'key2', 'key3').should =~ ['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
+  end
+
   it 'should subtract multiple sets and store the resulting set in a key' do
     subject.sadd('key1', 'a')
     subject.sadd('key1', 'b')

data/spec/support/sorted_sets.rb

@@ -130,7 +130,6 @@ shared_examples 'sorted sets' do
     subject.zscore('key', 1).should eq(1)
   end
 
-  # These won't pass until redis-rb releases v3.0.2
   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)
@@ -147,301 +146,307 @@ shared_examples 'sorted sets' do
       subject.zrange('key', 1, 2, with_scores: true).should eq([['two', 2], ['three', 3]])
     end
 
-    it 'should sort zrange results logically' do
-      subject.zadd('key', 5, 'val2')
-      subject.zadd('key', 5, 'val3')
-      subject.zadd('key', 5, 'val1')
+  it 'should sort zrange results logically' do
+    subject.zadd('key', 5, 'val2')
+    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]])
+  end
+
+  it 'should return a reversed range of members in a sorted set, by index' do
+    subject.zadd('key', 1, 'one')
+    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]])
+  end
+
+  it 'should return a range of members in a sorted set, by score' do
+    subject.zadd('key', 1, 'one')
+    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', 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'])
+  end
+
+  it 'should return a reversed range of members in a sorted set, by score' do
+    subject.zadd('key', 1, 'one')
+    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], ['one', 1]])
+    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], ['one', 1]])
+  end
+
+  it 'should determine the index of a member in a sorted set' do
+    subject.zadd('key', 1, 'one')
+    subject.zadd('key', 2, 'two')
+    subject.zadd('key', 3, 'three')
+
+    subject.zrank('key', 'three').should eq(2)
+    subject.zrank('key', 'four').should be_nil
+  end
+
+  it 'should determine the reversed index of a member in a sorted set' do
+    subject.zadd('key', 1, 'one')
+    subject.zadd('key', 2, 'two')
+    subject.zadd('key', 3, 'three')
+
+    subject.zrevrank('key', 'three').should eq(0)
+    subject.zrevrank('key', 'four').should be_nil
+  end
 
-      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]])
+  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
+  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
+  end
+
+  describe '#zinterstore' do
+    before do
+      subject.zadd('key1', 1, 'one')
+      subject.zadd('key1', 2, 'two')
+      subject.zadd('key1', 3, 'three')
+      subject.zadd('key2', 5, 'two')
+      subject.zadd('key2', 7, 'three')
+      subject.sadd('key3', 'one')
+      subject.sadd('key3', 'two')
     end
 
-    it 'should return a reversed range of members in a sorted set, by index' do
-      subject.zadd('key', 1, 'one')
-      subject.zadd('key', 2, 'two')
-      subject.zadd('key', 3, 'three')
+    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)]])
+    end
 
-      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]])
+    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)]])
     end
 
-    it 'should return a range of members in a sorted set, by score' do
-      subject.zadd('key', 1, 'one')
-      subject.zadd('key', 2, 'two')
-      subject.zadd('key', 3, 'three')
+    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)]])
+    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
+    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]])
+    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]])
+    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)]])
+    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)]])
+    end
 
-      subject.zrangebyscore('key', 0, 100).should eq(['one', 'two', 'three'])
-      subject.zrangebyscore('key', 1, 2).should eq(['one', 'two'])
-      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'])
+    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]])
     end
 
-    it 'should return a reversed range of members in a sorted set, by score' do
+    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)]])
+    end
+
+    it 'should error without enough weights given' do
+      expect {
+        subject.zinterstore('out', %w(key1 key2), weights: [])
+      }.to raise_error(Redis::CommandError)
+
+      expect {
+        subject.zinterstore('out', %w(key1 key2), weights: [10])
+      }.to raise_error(Redis::CommandError)
+    end
+
+    it 'should error with too many weights given' do
+      expect {
+        subject.zinterstore('out', %w(key1 key2), weights: [10, 1, 1])
+      }.to raise_error(Redis::CommandError)
+    end
+
+    it 'should error with an invalid aggregate' do
+      expect {
+        subject.zinterstore('out', %w(key1 key2), aggregate: :invalid)
+      }.to raise_error(Redis::CommandError)
+    end
+  end
+
+  describe 'zremrangebyscore' do
+    it 'should remove items by score' do
       subject.zadd('key', 1, 'one')
       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], ['one', 1]])
-      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], ['one', 1]])
+      subject.zremrangebyscore('key', 0, 2).should eq(2)
+      subject.zcard('key').should eq(1)
     end
 
-    it 'should determine the index of a member in a sorted set' do
+    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
+    end
+
+    it 'should return 0 if the key did not exist' do
+      subject.zremrangebyscore('key', 0, 2).should eq(0)
+    end
+  end
+
+  describe '#zremrangebyrank' do
+    it 'removes all elements with in the given range' do
       subject.zadd('key', 1, 'one')
       subject.zadd('key', 2, 'two')
       subject.zadd('key', 3, 'three')
 
-      subject.zrank('key', 'three').should eq(2)
-      subject.zrank('key', 'four').should be_nil
+      subject.zremrangebyrank('key', 0, 1).should eq(2)
+      subject.zcard('key').should eq(1)
     end
 
-    it 'should determine the reversed index of a member in a sorted set' do
+    it 'handles out of range requests' do
       subject.zadd('key', 1, 'one')
       subject.zadd('key', 2, 'two')
       subject.zadd('key', 3, 'three')
 
-      subject.zrevrank('key', 'three').should eq(0)
-      subject.zrevrank('key', 'four').should 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
-    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
-    end
-
-    describe '#zinterstore' do
-      before do
-        subject.zadd('key1', 1, 'one')
-        subject.zadd('key1', 2, 'two')
-        subject.zadd('key1', 3, 'three')
-        subject.zadd('key2', 5, 'two')
-        subject.zadd('key2', 7, 'three')
-        subject.sadd('key3', 'one')
-        subject.sadd('key3', 'two')
-      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)]])
-      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)]])
-      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)]])
-      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
-      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]])
-      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]])
-      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)]])
-      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)]])
-      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]])
-      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)]])
-      end
-
-      it 'should error without enough weights given' do
-        expect {
-          subject.zinterstore('out', %w(key1 key2), weights: [])
-        }.to raise_error(Redis::CommandError)
-
-        expect {
-          subject.zinterstore('out', %w(key1 key2), weights: [10])
-        }.to raise_error(Redis::CommandError)
-      end
-
-      it 'should error with too many weights given' do
-        expect {
-          subject.zinterstore('out', %w(key1 key2), weights: [10, 1, 1])
-        }.to raise_error(Redis::CommandError)
-      end
-
-      it 'should error with an invalid aggregate' do
-        expect {
-          subject.zinterstore('out', %w(key1 key2), aggregate: :invalid)
-        }.to raise_error(Redis::CommandError)
-      end
-    end
-
-    context 'zremrangebyscore' do
-      it 'should remove items by score' do
-        subject.zadd('key', 1, 'one')
-        subject.zadd('key', 2, 'two')
-        subject.zadd('key', 3, 'three')
-
-        subject.zremrangebyscore('key', 0, 2).should eq(2)
-        subject.zcard('key').should 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
-      end
-
-      it 'should return 0 if the key did not exist' do
-        subject.zremrangebyscore('key', 0, 2).should eq(0)
-      end
-    end
-
-    context '#zremrangebyrank' do
-      it 'removes all elements with in the given range' do
-        subject.zadd('key', 1, 'one')
-        subject.zadd('key', 2, 'two')
-        subject.zadd('key', 3, 'three')
-
-        subject.zremrangebyrank('key', 0, 1).should eq(2)
-        subject.zcard('key').should eq(1)
-      end
-
-      it 'handles out of range requests' do
-        subject.zadd('key', 1, 'one')
-        subject.zadd('key', 2, 'two')
-        subject.zadd('key', 3, 'three')
-
-        subject.zremrangebyrank('key', 25, -1).should eq(0)
-        subject.zcard('key').should eq(3)
-      end
-    end
-
-    describe '#zunionstore' do
-      before do
-        subject.zadd('key1', 1, 'val1')
-        subject.zadd('key1', 2, 'val2')
-        subject.zadd('key1', 3, 'val3')
-        subject.zadd('key2', 5, 'val2')
-        subject.zadd('key2', 7, 'val3')
-        subject.sadd('key3', 'val1')
-        subject.sadd('key3', 'val2')
-      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)]])
-      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]])
-      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)]])
-      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]])
-      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]])
-      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]])
-      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)]])
-      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)]])
-      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)]])
-      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)]])
-      end
-
-      it 'should error without enough weights given' do
-        expect {
-          subject.zunionstore('out', %w(key1 key2), weights: [])
-        }.to raise_error(Redis::CommandError)
-
-        expect {
-          subject.zunionstore('out', %w(key1 key2), weights: [10])
-        }.to raise_error(Redis::CommandError)
-      end
-
-      it 'should error with too many weights given' do
-        expect {
-          subject.zunionstore('out', %w(key1 key2), weights: [10, 1, 1])
-        }.to raise_error(Redis::CommandError)
-      end
-
-      it 'should error with an invalid aggregate' do
-        expect {
-          subject.zunionstore('out', %w(key1 key2), aggregate: :invalid)
-        }.to raise_error(Redis::CommandError)
-      end
-    end
-
-    #it 'should remove all members in a sorted set within the given indexes'
-    #it 'should return a range of members in a sorted set, by index, with scores ordered from high to low'
-    #it 'should return a range of members in a sorted set, by score, with scores ordered from high to low'
-    #it 'should determine the index of a member in a sorted set, with scores ordered from high to low'
-    #it 'should get the score associated with the given member in a sorted set'
-    #it 'should add multiple sorted sets and store the resulting sorted set in a new key'
+      subject.zremrangebyrank('key', 25, -1).should eq(0)
+      subject.zcard('key').should eq(3)
+    end
+  end
+
+  describe '#zunionstore' do
+    before do
+      subject.zadd('key1', 1, 'val1')
+      subject.zadd('key1', 2, 'val2')
+      subject.zadd('key1', 3, 'val3')
+      subject.zadd('key2', 5, 'val2')
+      subject.zadd('key2', 7, 'val3')
+      subject.sadd('key3', 'val1')
+      subject.sadd('key3', 'val2')
+    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)]])
+    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]])
+    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)]])
+    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]])
+    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]])
+    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]])
+    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)]])
+    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)]])
+    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)]])
+    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)]])
+    end
+
+    it 'should error without enough weights given' do
+      expect {
+        subject.zunionstore('out', %w(key1 key2), weights: [])
+      }.to raise_error(Redis::CommandError)
+
+      expect {
+        subject.zunionstore('out', %w(key1 key2), weights: [10])
+      }.to raise_error(Redis::CommandError)
+    end
+
+    it 'should error with too many weights given' do
+      expect {
+        subject.zunionstore('out', %w(key1 key2), weights: [10, 1, 1])
+      }.to raise_error(Redis::CommandError)
+    end
+
+    it 'should error with an invalid aggregate' do
+      expect {
+        subject.zunionstore('out', %w(key1 key2), aggregate: :invalid)
+      }.to raise_error(Redis::CommandError)
+    end
   end
+
+  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
+  end
+
+  #it 'should remove all members in a sorted set within the given indexes'
+  #it 'should return a range of members in a sorted set, by index, with scores ordered from high to low'
+  #it 'should return a range of members in a sorted set, by score, with scores ordered from high to low'
+  #it 'should determine the index of a member in a sorted set, with scores ordered from high to low'
+  #it 'should get the score associated with the given member in a sorted set'
+  #it 'should add multiple sorted sets and store the resulting sorted set in a new key'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rediska
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-30 00:00:00.000000000 Z
+date: 2013-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis