fakeredis 0.5.0 → 0.8.0

data/spec/sets_spec.rb

@@ -7,30 +7,34 @@ module FakeRedis
     end
 
     it "should add a member to a set" do
-      @client.sadd("key", "value").should be == true
-      @client.sadd("key", "value").should be == false
+      expect(@client.sadd("key", "value")).to eq(true)
+      expect(@client.sadd("key", "value")).to eq(false)
 
-      @client.smembers("key").should be == ["value"]
+      expect(@client.smembers("key")).to eq(["value"])
     end
 
     it "should raise error if command arguments count is not enough" do
       expect { @client.sadd("key", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sadd' command")
       expect { @client.sinter(*[]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sinter' command")
+      expect { @client.sinter([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sinter' command")
+      expect { @client.sunion(*[]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sunion' command")
+      expect { @client.sunion([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sunion' command")
+      expect { @client.srem("key", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'srem' command")
 
-      @client.smembers("key").should be_empty
+      expect(@client.smembers("key")).to be_empty
     end
 
     it "should add multiple members to a set" do
-      @client.sadd("key", %w(value other something more)).should be == 4
-      @client.sadd("key", %w(and additional values)).should be == 3
-      @client.smembers("key").should =~ ["value", "other", "something", "more", "and", "additional", "values"]
+      expect(@client.sadd("key", %w(value other something more))).to eq(4)
+      expect(@client.sadd("key", %w(and additional values))).to eq(3)
+      expect(@client.smembers("key")).to match_array(["value", "other", "something", "more", "and", "additional", "values"])
     end
 
     it "should get the number of members in a set" do
       @client.sadd("key", "val1")
       @client.sadd("key", "val2")
 
-      @client.scard("key").should be == 2
+      expect(@client.scard("key")).to eq(2)
     end
 
     it "should subtract multiple sets" do
@@ -43,14 +47,16 @@ module FakeRedis
       @client.sadd("key3", "c")
       @client.sadd("key3", "e")
 
-      @client.sdiff("key1", "key2", "key3").should =~ ["b", "d"]
+      expect(@client.sdiff("key1", "key2", "key3")).to match_array(["b", "d"])
+      expect(@client.sdiff("key1", ["key2", "key3"])).to match_array(["b", "d"])
     end
 
     it "should subtract from a nonexistent set" do
       @client.sadd("key2", "a")
       @client.sadd("key2", "b")
 
-      @client.sdiff("key1", "key2").should == []
+      expect(@client.sdiff("key1", "key2")).to eq([])
+      expect(@client.sdiff(["key1", "key2"])).to eq([])
     end
 
     it "should subtract multiple sets and store the resulting set in a key" do
@@ -63,8 +69,10 @@ module FakeRedis
       @client.sadd("key3", "c")
       @client.sadd("key3", "e")
       @client.sdiffstore("key", "key1", "key2", "key3")
+      @client.sdiffstore("new_key", "key1", ["key2", "key3"])
 
-      @client.smembers("key").should =~ ["b", "d"]
+      expect(@client.smembers("key")).to match_array(["b", "d"])
+      expect(@client.smembers("new_key")).to match_array(["b", "d"])
     end
 
     it "should intersect multiple sets" do
@@ -77,7 +85,8 @@ module FakeRedis
       @client.sadd("key3", "c")
       @client.sadd("key3", "e")
 
-      @client.sinter("key1", "key2", "key3").should be == ["c"]
+      expect(@client.sinter("key1", "key2", "key3")).to eq(["c"])
+      expect(@client.sinter(["key1", "key2", "key3"])).to eq(["c"])
     end
 
     it "should intersect multiple sets and store the resulting set in a key" do
@@ -90,15 +99,18 @@ module FakeRedis
       @client.sadd("key3", "c")
       @client.sadd("key3", "e")
       @client.sinterstore("key", "key1", "key2", "key3")
-      @client.smembers("key").should be == ["c"]
+      @client.sinterstore("new_key", ["key1", "key2", "key3"])
+
+      expect(@client.smembers("key")).to eq(["c"])
+      expect(@client.smembers("new_key")).to eq(["c"])
     end
 
     it "should determine if a given value is a member of a set" do
       @client.sadd("key1", "a")
 
-      @client.sismember("key1", "a").should be == true
-      @client.sismember("key1", "b").should be == false
-      @client.sismember("key2", "a").should be == false
+      expect(@client.sismember("key1", "a")).to eq(true)
+      expect(@client.sismember("key1", "b")).to eq(false)
+      expect(@client.sismember("key2", "a")).to eq(false)
     end
 
     it "should get all the members in a set" do
@@ -107,51 +119,67 @@ module FakeRedis
       @client.sadd("key", "c")
       @client.sadd("key", "d")
 
-      @client.smembers("key").should =~ ["a", "b", "c", "d"]
+      expect(@client.smembers("key")).to match_array(["a", "b", "c", "d"])
     end
 
     it "should move a member from one set to another" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
       @client.sadd("key2", "c")
-      @client.smove("key1", "key2", "a").should be == true
-      @client.smove("key1", "key2", "a").should be == false
+      expect(@client.smove("key1", "key2", "a")).to eq(true)
+      expect(@client.smove("key1", "key2", "a")).to eq(false)
 
-      @client.smembers("key1").should be == ["b"]
-      @client.smembers("key2").should =~ ["c", "a"]
+      expect(@client.smembers("key1")).to eq(["b"])
+      expect(@client.smembers("key2")).to match_array(["c", "a"])
     end
 
     it "should remove and return a random member from a set" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
 
-      ["a", "b"].include?(@client.spop("key1")).should be true
-      ["a", "b"].include?(@client.spop("key1")).should be true
-      @client.spop("key1").should be_nil
+      expect(["a", "b"].include?(@client.spop("key1"))).to be true
+      expect(["a", "b"].include?(@client.spop("key1"))).to be true
+      expect(@client.spop("key1")).to be_nil
     end
 
     it "should get a random member from a set" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
 
-      ["a", "b"].include?(@client.spop("key1")).should be true
+      expect(["a", "b"].include?(@client.spop("key1"))).to be true
+    end
+
+    it "should pop multiple members from a set" do
+      @client.sadd("key1", "a")
+      @client.sadd("key1", "b")
+      @client.sadd("key1", "c")
+
+      vals = @client.spop("key1", 2)
+      expect(vals.count).to eq(2)
+      vals.each { |v| expect(["a", "b", "c"].include?(v)).to be true }
+
+      new_vals = @client.spop("key1", 2)
+      expect(new_vals.count).to eq(1)
+      expect(["a", "b", "c"].include?(new_vals.first)).to be true
+
+      expect(["a", "b", "c"]).to eq((vals + new_vals).sort)
     end
 
     it "should remove a member from a set" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
-      @client.srem("key1", "a").should be == true
-      @client.srem("key1", "a").should be == false
+      expect(@client.srem("key1", "a")).to eq(true)
+      expect(@client.srem("key1", "a")).to eq(false)
 
-      @client.smembers("key1").should be == ["b"]
+      expect(@client.smembers("key1")).to eq(["b"])
     end
 
     it "should remove multiple members from a set" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
 
-      @client.srem("key1", [ "a", "b"]).should == 2
-      @client.smembers("key1").should be_empty
+      expect(@client.srem("key1", [ "a", "b"])).to eq(2)
+      expect(@client.smembers("key1")).to be_empty
     end
 
     it "should remove the set's key once it's empty" do
@@ -160,7 +188,7 @@ module FakeRedis
       @client.srem("key1", "b")
       @client.srem("key1", "a")
 
-      @client.exists("key1").should be == false
+      expect(@client.exists("key1")).to eq(false)
     end
 
     it "should add multiple sets" do
@@ -173,7 +201,7 @@ module FakeRedis
       @client.sadd("key3", "c")
       @client.sadd("key3", "e")
 
-      @client.sunion("key1", "key2", "key3").should =~ ["a", "b", "c", "d", "e"]
+      expect(@client.sunion("key1", "key2", "key3")).to match_array(["a", "b", "c", "d", "e"])
     end
 
     it "should add multiple sets and store the resulting set in a key" do
@@ -187,7 +215,7 @@ module FakeRedis
       @client.sadd("key3", "e")
       @client.sunionstore("key", "key1", "key2", "key3")
 
-      @client.smembers("key").should =~ ["a", "b", "c", "d", "e"]
+      expect(@client.smembers("key")).to match_array(["a", "b", "c", "d", "e"])
     end
   end
 
@@ -207,7 +235,7 @@ module FakeRedis
         it 'is a random element from the set' do
           random_element = @client.srandmember("key1")
 
-          ['a', 'b', 'c'].include?(random_element).should be true
+          expect(['a', 'b', 'c'].include?(random_element)).to be true
         end
       end
 
@@ -215,7 +243,7 @@ module FakeRedis
         it 'is an array of one random element from the set' do
           random_elements = @client.srandmember("key1", 1)
 
-          [['a'], ['b'], ['c']].include?(@client.srandmember("key1", 1)).should be true
+          expect([['a'], ['b'], ['c']].include?(random_elements)).to be true
         end
       end
 
@@ -223,10 +251,10 @@ module FakeRedis
         it 'is an array of two unique, random elements from the set' do
           random_elements = @client.srandmember("key1", 2)
 
-          random_elements.count.should == 2
-          random_elements.uniq.count.should == 2
+          expect(random_elements.count).to eq(2)
+          expect(random_elements.uniq.count).to eq(2)
           random_elements.all? do |element|
-            ['a', 'b', 'c'].include?(element).should be true
+            expect(['a', 'b', 'c'].include?(element)).to be true
           end
         end
       end
@@ -235,10 +263,10 @@ module FakeRedis
         it 'is an array of 100 random elements from the set, some of which are repeated' do
           random_elements = @client.srandmember("key1", -100)
 
-          random_elements.count.should == 100
-          random_elements.uniq.count.should <= 3
+          expect(random_elements.count).to eq(100)
+          expect(random_elements.uniq.count).to be <= 3
           random_elements.all? do |element|
-            ['a', 'b', 'c'].include?(element).should be true
+            expect(['a', 'b', 'c'].include?(element)).to be true
           end
         end
       end
@@ -247,9 +275,9 @@ module FakeRedis
         it 'is an array of all of the elements from the set, none of which are repeated' do
           random_elements = @client.srandmember("key1", 100)
 
-          random_elements.count.should == 3
-          random_elements.uniq.count.should == 3
-          random_elements.should =~ ['a', 'b', 'c']
+          expect(random_elements.count).to eq(3)
+          expect(random_elements.uniq.count).to eq(3)
+          expect(random_elements).to match_array(['a', 'b', 'c'])
         end
       end
     end
@@ -258,11 +286,49 @@ module FakeRedis
       before { @client.del("key1") }
 
       it 'is nil without the extra parameter' do
-        @client.srandmember("key1").should be_nil
+        expect(@client.srandmember("key1")).to be_nil
       end
 
       it 'is an empty array with an extra parameter' do
-        @client.srandmember("key1", 1).should == []
+        expect(@client.srandmember("key1", 1)).to eq([])
+      end
+    end
+
+    describe "#sscan" do
+      it 'with no arguments and few items, returns all items' do
+        @client.sadd('set', ['name', 'Jack', 'age', '33'])
+        result = @client.sscan('set', 0)
+
+        expect(result[0]).to eq('0')
+        expect(result[1]).to eq(['name', 'Jack', 'age', '33'])
+      end
+
+      it 'with a count should return that number of members or more' do
+        @client.sadd('set', ['a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'])
+        result = @client.sscan('set', 0, count: 3)
+        expect(result[0]).to eq('3')
+        expect(result[1]).to eq([ 'a', '1', 'b'])
+      end
+
+      it 'returns items starting at the provided cursor' do
+        @client.sadd('set', ['a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'])
+        result = @client.sscan('set', 2, count: 3)
+        expect(result[0]).to eq('5')
+        expect(result[1]).to eq(['b', '2', 'c'])
+      end
+
+      it 'with match, returns items matching the given pattern' do
+        @client.sadd('set', ['aa', '1', 'b', '2', 'cc', '3', 'd', '4', 'ee', '5', 'f', '6', 'gg', '7'])
+        result = @client.sscan('set', 2, count: 7, match: '??')
+        expect(result[0]).to eq('9')
+        expect(result[1]).to eq(['cc','ee'])
+      end
+
+      it 'returns an empty result if the key is not found' do
+        result = @client.sscan('set', 0)
+
+        expect(result[0]).to eq('0')
+        expect(result[1]).to eq([])
       end
     end
   end

data/spec/sort_method_spec.rb

@@ -32,6 +32,12 @@ module FakeRedis
       end
     end
 
+    context "none" do
+      it "should return empty array" do
+        expect(@client.sort("key")).to eq []
+      end
+    end
+
     context "list" do
       before do
         @key = "fake-redis-test:list_sort"

data/spec/sorted_sets_spec.rb

@@ -9,84 +9,126 @@ module FakeRedis
     end
 
     it "should add a member to a sorted set, or update its score if it already exists" do
-      @client.zadd("key", 1, "val").should be(true)
-      @client.zscore("key", "val").should be == 1.0
+      expect(@client.zadd("key", 1, "val")).to be(true)
+      expect(@client.zscore("key", "val")).to eq(1.0)
 
-      @client.zadd("key", 2, "val").should be(false)
-      @client.zscore("key", "val").should be == 2.0
+      expect(@client.zadd("key", 2, "val")).to be(false)
+      expect(@client.zscore("key", "val")).to eq(2.0)
 
       # These assertions only work in redis-rb v3.0.2 or higher
-      @client.zadd("key2", "inf", "val").should be == true
-      @client.zscore("key2", "val").should be == Infinity
+      expect(@client.zadd("key2", "inf", "val")).to eq(true)
+      expect(@client.zscore("key2", "val")).to eq(Infinity)
 
-      @client.zadd("key3", "+inf", "val").should be == true
-      @client.zscore("key3", "val").should be == Infinity
+      expect(@client.zadd("key3", "+inf", "val")).to eq(true)
+      expect(@client.zscore("key3", "val")).to eq(Infinity)
 
-      @client.zadd("key4", "-inf", "val").should be == true
-      @client.zscore("key4", "val").should be == -Infinity
+      expect(@client.zadd("key4", "-inf", "val")).to eq(true)
+      expect(@client.zscore("key4", "val")).to eq(-Infinity)
     end
 
     it "should return a nil score for value not in a sorted set or empty key" do
       @client.zadd "key", 1, "val"
 
-      @client.zscore("key", "val").should be == 1.0
-      @client.zscore("key", "val2").should be_nil
-      @client.zscore("key2", "val").should be_nil
+      expect(@client.zscore("key", "val")).to eq(1.0)
+      expect(@client.zscore("key", "val2")).to be_nil
+      expect(@client.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
-      @client.zadd("key", [1, "val", 2, "val2"]).should be == 2
-      @client.zscore("key", "val").should be == 1
-      @client.zscore("key", "val2").should be == 2
-
-      @client.zadd("key", [[5, "val"], [3, "val3"], [4, "val4"]]).should be == 2
-      @client.zscore("key", "val").should be == 5
-      @client.zscore("key", "val2").should be == 2
-      @client.zscore("key", "val3").should be == 3
-      @client.zscore("key", "val4").should be == 4
-
-      @client.zadd("key", [[5, "val5"], [3, "val6"]]).should be == 2
-      @client.zscore("key", "val5").should be == 5
-      @client.zscore("key", "val6").should be == 3
+      expect(@client.zadd("key", [1, "val", 2, "val2"])).to eq(2)
+      expect(@client.zscore("key", "val")).to eq(1)
+      expect(@client.zscore("key", "val2")).to eq(2)
+
+      expect(@client.zadd("key", [[5, "val"], [3, "val3"], [4, "val4"]])).to eq(2)
+      expect(@client.zscore("key", "val")).to eq(5)
+      expect(@client.zscore("key", "val2")).to eq(2)
+      expect(@client.zscore("key", "val3")).to eq(3)
+      expect(@client.zscore("key", "val4")).to eq(4)
+
+      expect(@client.zadd("key", [[5, "val5"], [3, "val6"]])).to eq(2)
+      expect(@client.zscore("key", "val5")).to eq(5)
+      expect(@client.zscore("key", "val6")).to eq(3)
     end
 
     it "should error with wrong number of arguments when adding members" do
-      lambda { @client.zadd("key") }.should raise_error(ArgumentError, "wrong number of arguments")
-      lambda { @client.zadd("key", 1) }.should raise_error(ArgumentError, "wrong number of arguments")
-      lambda { @client.zadd("key", [1]) }.should raise_error(Redis::CommandError, "ERR wrong number of arguments for 'zadd' command")
-      lambda { @client.zadd("key", [1, "val", 2]) }.should raise_error(Redis::CommandError, "ERR syntax error")
-      lambda { @client.zadd("key", [[1, "val"], [2]]) }.should raise_error(Redis::CommandError, "ERR syntax error")
+      expect { @client.zadd("key") }.to raise_error(ArgumentError, "wrong number of arguments")
+      expect { @client.zadd("key", 1) }.to raise_error(ArgumentError, "wrong number of arguments")
+      expect { @client.zadd("key", [1]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'zadd' command")
+      expect { @client.zadd("key", [1, "val", 2]) }.to raise_error(Redis::CommandError, "ERR syntax error")
+      expect { @client.zadd("key", [[1, "val"], [2]]) }.to raise_error(Redis::CommandError, "ERR syntax error")
     end
 
     it "should allow floats as scores when adding or updating" do
-      @client.zadd("key", 4.321, "val").should be(true)
-      @client.zscore("key", "val").should be == 4.321
+      expect(@client.zadd("key", 4.321, "val")).to be(true)
+      expect(@client.zscore("key", "val")).to eq(4.321)
+
+      expect(@client.zadd("key", 54.3210, "val")).to be(false)
+      expect(@client.zscore("key", "val")).to eq(54.321)
+    end
 
-      @client.zadd("key", 54.3210, "val").should be(false)
-      @client.zscore("key", "val").should be == 54.321
+    it "should allow strings that can be parsed as float when adding or updating" do
+      expect(@client.zadd("key", "4.321", "val")).to be(true)
+      expect(@client.zscore("key", "val")).to eq(4.321)
+
+      expect(@client.zadd("key", "54.3210", "val")).to be(false)
+      expect(@client.zscore("key", "val")).to eq(54.321)
+    end
+
+    it "should error when the score is not a valid float" do
+      expect { @client.zadd("key", "score", "val") }.to raise_error(Redis::CommandError, "ERR value is not a valid float")
+      expect { @client.zadd("key", {}, "val") }.to raise_error(Redis::CommandError, "ERR value is not a valid float")
+      expect { @client.zadd("key", Time.now, "val") }.to raise_error(Redis::CommandError, "ERR value is not a valid float")
     end
 
     it "should remove members from sorted sets" do
-      @client.zrem("key", "val").should be(false)
-      @client.zadd("key", 1, "val").should be(true)
-      @client.zrem("key", "val").should be(true)
+      expect(@client.zrem("key", "val")).to be(false)
+      expect(@client.zadd("key", 1, "val")).to be(true)
+      expect(@client.zrem("key", "val")).to be(true)
     end
 
     it "should remove multiple members from sorted sets" do
-      @client.zrem("key2", %w(val)).should be == 0
-      @client.zrem("key2", %w(val val2 val3)).should be == 0
+      expect(@client.zrem("key2", %w(val))).to eq(0)
+      expect(@client.zrem("key2", %w(val val2 val3))).to eq(0)
 
       @client.zadd("key2", 1, "val")
       @client.zadd("key2", 1, "val2")
       @client.zadd("key2", 1, "val3")
 
-      @client.zrem("key2", %w(val val2 val3 val4)).should be == 3
+      expect(@client.zrem("key2", %w(val val2 val3 val4))).to eq(3)
     end
 
     it "should remove sorted set's key when it is empty" do
       @client.zadd("key", 1, "val")
       @client.zrem("key", "val")
-      @client.exists("key").should be == false
+      expect(@client.exists("key")).to eq(false)
+    end
+
+    it "should pop members with the highest scores from sorted set" do
+      @client.zadd("key", [1, "val1", 2, "val2", 3, "val3"])
+      expect(@client.zpopmax("key")).to eq(["val3", 3.0])
+      expect(@client.zpopmax("key", 3)).to eq([["val2", 2.0], ["val1", 1.0]])
+      expect(@client.zpopmax("nonexistent")).to eq(nil)
+    end
+
+    it "should pop members with the lowest scores from sorted set" do
+      @client.zadd("key", [1, "val1", 2, "val2", 3, "val3"])
+      expect(@client.zpopmin("key")).to eq(["val1", 1.0])
+      expect(@client.zpopmin("key", 3)).to eq([["val2", 2.0], ["val3", 3.0]])
+      expect(@client.zpopmin("nonexistent")).to eq(nil)
+    end
+
+    it "should pop members with the highest score from first sorted set that is non-empty" do
+      @client.zadd("key1", [1, "val1", 2, "val2"])
+      @client.zadd("key2", [3, "val3"])
+      expect(@client.bzpopmax("nonexistent", "key1", "key2", 0)).to eq(["key1", "val2", 2.0])
+      expect(@client.bzpopmax("nonexistent")).to eq(nil)
+    end
+
+    it "should pop members with the lowest score from first sorted set that is non-empty" do
+      @client.zadd("key1", [1, "val1", 2, "val2"])
+      @client.zadd("key2", [3, "val3"])
+      expect(@client.bzpopmin("nonexistent", "key1", "key2", 0)).to eq(["key1", "val1", 1.0])
+      expect(@client.bzpopmin("nonexistent")).to eq(nil)
     end
 
     it "should get the number of members in a sorted set" do
@@ -94,7 +136,7 @@ module FakeRedis
       @client.zadd("key", 2, "val1")
       @client.zadd("key", 5, "val3")
 
-      @client.zcard("key").should be == 3
+      expect(@client.zcard("key")).to eq(3)
     end
 
     it "should count the members in a sorted set with scores within the given values" do
@@ -102,28 +144,28 @@ module FakeRedis
       @client.zadd("key", 2, "val2")
       @client.zadd("key", 3, "val3")
 
-      @client.zcount("key", 2, 3).should be == 2
+      expect(@client.zcount("key", 2, 3)).to eq(2)
     end
 
     it "should increment the score of a member in a sorted set" do
       @client.zadd("key", 1, "val1")
-      @client.zincrby("key", 2, "val1").should be == 3
-      @client.zscore("key", "val1").should be == 3
+      expect(@client.zincrby("key", 2, "val1")).to eq(3)
+      expect(@client.zscore("key", "val1")).to eq(3)
     end
 
     it "initializes the sorted set if the key wasnt already set" do
-      @client.zincrby("key", 1, "val1").should be == 1
+      expect(@client.zincrby("key", 1, "val1")).to eq(1)
     end
 
     it "should convert the key to a string for zscore" do
       @client.zadd("key", 1, 1)
-      @client.zscore("key", 1).should be == 1
+      expect(@client.zscore("key", 1)).to 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
-      @client.zincrby("bar", "+inf", "s2").should be == Infinity
-      @client.zincrby("bar", "-inf", "s1").should be == -Infinity
+      expect(@client.zincrby("bar", "+inf", "s2")).to eq(Infinity)
+      expect(@client.zincrby("bar", "-inf", "s1")).to eq(-Infinity)
     end
 
     it "should return a range of members in a sorted set, by index" do
@@ -131,10 +173,11 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrange("key", 0, -1).should be == ["one", "two", "three"]
-      @client.zrange("key", 1, 2).should be == ["two", "three"]
-      @client.zrange("key", 0, -1, :withscores => true).should be == [["one", 1], ["two", 2], ["three", 3]]
-      @client.zrange("key", 1, 2, :with_scores => true).should be == [["two", 2], ["three", 3]]
+      expect(@client.zrange("key", 0, -1)).to eq(["one", "two", "three"])
+      expect(@client.zrange("key", 1, 2)).to eq(["two", "three"])
+      expect(@client.zrange("key", -50, -2)).to eq(["one", "two"])
+      expect(@client.zrange("key", 0, -1, :withscores => true)).to eq([["one", 1], ["two", 2], ["three", 3]])
+      expect(@client.zrange("key", 1, 2, :with_scores => true)).to eq([["two", 2], ["three", 3]])
     end
 
     it "should sort zrange results logically" do
@@ -142,8 +185,8 @@ module FakeRedis
       @client.zadd("key", 5, "val3")
       @client.zadd("key", 5, "val1")
 
-      @client.zrange("key", 0, -1).should be == %w(val1 val2 val3)
-      @client.zrange("key", 0, -1, :with_scores => true).should be == [["val1", 5], ["val2", 5], ["val3", 5]]
+      expect(@client.zrange("key", 0, -1)).to eq(%w(val1 val2 val3))
+      expect(@client.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
@@ -151,10 +194,10 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrevrange("key", 0, -1).should be == ["three", "two", "one"]
-      @client.zrevrange("key", 1, 2).should be == ["two", "one"]
-      @client.zrevrange("key", 0, -1, :withscores => true).should be == [["three", 3], ["two", 2], ["one", 1]]
-      @client.zrevrange("key", 0, -1, :with_scores => true).should be == [["three", 3], ["two", 2], ["one", 1]]
+      expect(@client.zrevrange("key", 0, -1)).to eq(["three", "two", "one"])
+      expect(@client.zrevrange("key", 1, 2)).to eq(["two", "one"])
+      expect(@client.zrevrange("key", 0, -1, :withscores => true)).to eq([["three", 3], ["two", 2], ["one", 1]])
+      expect(@client.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
@@ -162,21 +205,21 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrangebyscore("key", 0, 100).should be == ["one", "two", "three"]
-      @client.zrangebyscore("key", 1, 2).should be == ["one", "two"]
-      @client.zrangebyscore("key", 1, '(2').should be == ['one']
-      @client.zrangebyscore("key", '(1', 2).should be == ['two']
-      @client.zrangebyscore("key", '(1', '(2').should be == []
-      @client.zrangebyscore("key", 0, 100, :withscores => true).should be == [["one", 1], ["two", 2], ["three", 3]]
-      @client.zrangebyscore("key", 1, 2, :with_scores => true).should be == [["one", 1], ["two", 2]]
-      @client.zrangebyscore("key", 0, 100, :limit => [0, 1]).should be == ["one"]
-      @client.zrangebyscore("key", 0, 100, :limit => [0, -1]).should be == ["one", "two", "three"]
-      @client.zrangebyscore("key", 0, 100, :limit => [1, -1], :with_scores => true).should be == [["two", 2], ["three", 3]]
-      @client.zrangebyscore("key", '-inf', '+inf').should be == ["one", "two", "three"]
-      @client.zrangebyscore("key", 2, '+inf').should be == ["two", "three"]
-      @client.zrangebyscore("key", '-inf', 2).should be == ['one', "two"]
-
-      @client.zrangebyscore("badkey", 1, 2).should be == []
+      expect(@client.zrangebyscore("key", 0, 100)).to eq(["one", "two", "three"])
+      expect(@client.zrangebyscore("key", 1, 2)).to eq(["one", "two"])
+      expect(@client.zrangebyscore("key", 1, '(2')).to eq(['one'])
+      expect(@client.zrangebyscore("key", '(1', 2)).to eq(['two'])
+      expect(@client.zrangebyscore("key", '(1', '(2')).to eq([])
+      expect(@client.zrangebyscore("key", 0, 100, :withscores => true)).to eq([["one", 1], ["two", 2], ["three", 3]])
+      expect(@client.zrangebyscore("key", 1, 2, :with_scores => true)).to eq([["one", 1], ["two", 2]])
+      expect(@client.zrangebyscore("key", 0, 100, :limit => [0, 1])).to eq(["one"])
+      expect(@client.zrangebyscore("key", 0, 100, :limit => [0, -1])).to eq(["one", "two", "three"])
+      expect(@client.zrangebyscore("key", 0, 100, :limit => [1, -1], :with_scores => true)).to eq([["two", 2], ["three", 3]])
+      expect(@client.zrangebyscore("key", '-inf', '+inf')).to eq(["one", "two", "three"])
+      expect(@client.zrangebyscore("key", 2, '+inf')).to eq(["two", "three"])
+      expect(@client.zrangebyscore("key", '-inf', 2)).to eq(['one', "two"])
+
+      expect(@client.zrangebyscore("badkey", 1, 2)).to eq([])
     end
 
     it "should return a reversed range of members in a sorted set, by score" do
@@ -184,13 +227,13 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrevrangebyscore("key", 100, 0).should be == ["three", "two", "one"]
-      @client.zrevrangebyscore("key", 2, 1).should be == ["two", "one"]
-      @client.zrevrangebyscore("key", 1, 2).should be == []
-      @client.zrevrangebyscore("key", 2, 1, :with_scores => true).should be == [["two", 2.0], ["one", 1.0]]
-      @client.zrevrangebyscore("key", 100, 0, :limit => [0, 1]).should be == ["three"]
-      @client.zrevrangebyscore("key", 100, 0, :limit => [0, -1]).should be == ["three", "two", "one"]
-      @client.zrevrangebyscore("key", 100, 0, :limit => [1, -1], :with_scores => true).should be == [["two", 2.0], ["one", 1.0]]
+      expect(@client.zrevrangebyscore("key", 100, 0)).to eq(["three", "two", "one"])
+      expect(@client.zrevrangebyscore("key", 2, 1)).to eq(["two", "one"])
+      expect(@client.zrevrangebyscore("key", 1, 2)).to eq([])
+      expect(@client.zrevrangebyscore("key", 2, 1, :with_scores => true)).to eq([["two", 2.0], ["one", 1.0]])
+      expect(@client.zrevrangebyscore("key", 100, 0, :limit => [0, 1])).to eq(["three"])
+      expect(@client.zrevrangebyscore("key", 100, 0, :limit => [0, -1])).to eq(["three", "two", "one"])
+      expect(@client.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
@@ -198,8 +241,8 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrank("key", "three").should be == 2
-      @client.zrank("key", "four").should be_nil
+      expect(@client.zrank("key", "three")).to eq(2)
+      expect(@client.zrank("key", "four")).to be_nil
     end
 
     it "should determine the reversed index of a member in a sorted set" do
@@ -207,16 +250,16 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrevrank("key", "three").should be == 0
-      @client.zrevrank("key", "four").should be_nil
+      expect(@client.zrevrank("key", "three")).to eq(0)
+      expect(@client.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
-      @client.zrank("no_such_key", "no_suck_id").should be_nil
+      expect(@client.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
-      @client.zrevrank("no_such_key", "no_suck_id").should be_nil
+      expect(@client.zrevrank("no_such_key", "no_suck_id")).to be_nil
     end
 
     describe "#zinterstore" do
@@ -231,66 +274,82 @@ module FakeRedis
       end
 
       it "should intersect two keys with custom scores" do
-        @client.zinterstore("out", ["key1", "key2"]).should be == 2
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [['two', (2 + 5)], ['three', (3 + 7)]]
+        expect(@client.zinterstore("out", ["key1", "key2"])).to eq(2)
+        expect(@client.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
-        @client.zinterstore("out", ["key1", "key3"]).should be == 2
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [['one', (1 + 1)], ['two', (2 + 1)]]
+        expect(@client.zinterstore("out", ["key1", "key3"])).to eq(2)
+        expect(@client.zrange("out", 0, -1, :with_scores => true)).to eq([['one', (1 + 1)], ['two', (2 + 1)]])
       end
 
       it "should intersect more than two keys" do
-        @client.zinterstore("out", ["key1", "key2", "key3"]).should be == 1
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [['two', (2 + 5 + 1)]]
+        expect(@client.zinterstore("out", ["key1", "key2", "key3"])).to eq(1)
+        expect(@client.zrange("out", 0, -1, :with_scores => true)).to eq([['two', (2 + 5 + 1)]])
       end
 
       it "should not intersect an unknown key" do
-        @client.zinterstore("out", ["key1", "no_key"]).should be == 0
-        @client.zrange("out", 0, -1, :with_scores => true).should be == []
+        expect(@client.zinterstore("out", ["key1", "no_key"])).to eq(0)
+        expect(@client.zrange("out", 0, -1, :with_scores => true)).to eq([])
       end
 
       it "should intersect two keys by minimum values" do
-        @client.zinterstore("out", ["key1", "key2"], :aggregate => :min).should be == 2
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["two", 2], ["three", 3]]
+        expect(@client.zinterstore("out", ["key1", "key2"], :aggregate => :min)).to eq(2)
+        expect(@client.zrange("out", 0, -1, :with_scores => true)).to eq([["two", 2], ["three", 3]])
       end
 
       it "should intersect two keys by maximum values" do
-        @client.zinterstore("out", ["key1", "key2"], :aggregate => :max).should be == 2
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["two", 5], ["three", 7]]
+        expect(@client.zinterstore("out", ["key1", "key2"], :aggregate => :max)).to eq(2)
+        expect(@client.zrange("out", 0, -1, :with_scores => true)).to eq([["two", 5], ["three", 7]])
       end
 
       it "should intersect two keys by explicitly summing values" do
-        @client.zinterstore("out", %w(key1 key2), :aggregate => :sum).should be == 2
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["two", (2 + 5)], ["three", (3 + 7)]]
+        expect(@client.zinterstore("out", %w(key1 key2), :aggregate => :sum)).to eq(2)
+        expect(@client.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
-        @client.zinterstore("out", %w(key1 key2), :weights => [10, 1]).should be == 2
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["two", (2 * 10 + 5)], ["three", (3 * 10 + 7)]]
+        expect(@client.zinterstore("out", %w(key1 key2), :weights => [10, 1])).to eq(2)
+        expect(@client.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
-        @client.zinterstore("out", %w(key1 key2), :weights => [10, 1], :aggregate => :min).should be == 2
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["two", 5], ["three", 7]]
+        expect(@client.zinterstore("out", %w(key1 key2), :weights => [10, 1], :aggregate => :min)).to eq(2)
+        expect(@client.zrange("out", 0, -1, :with_scores => true)).to eq([["two", 5], ["three", 7]])
       end
 
       it "should intersect two keys with weighted maximum values" do
-        @client.zinterstore("out", %w(key1 key2), :weights => [10, 1], :aggregate => :max).should be == 2
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["two", (2 * 10)], ["three", (3 * 10)]]
+        expect(@client.zinterstore("out", %w(key1 key2), :weights => [10, 1], :aggregate => :max)).to eq(2)
+        expect(@client.zrange("out", 0, -1, :with_scores => true)).to eq([["two", (2 * 10)], ["three", (3 * 10)]])
       end
 
       it "should error without enough weights given" do
-        lambda { @client.zinterstore("out", %w(key1 key2), :weights => []) }.should raise_error(Redis::CommandError, "ERR syntax error")
-        lambda { @client.zinterstore("out", %w(key1 key2), :weights => [10]) }.should raise_error(Redis::CommandError, "ERR syntax error")
+        expect { @client.zinterstore("out", %w(key1 key2), :weights => []) }.to raise_error(Redis::CommandError, "ERR syntax error")
+        expect { @client.zinterstore("out", %w(key1 key2), :weights => [10]) }.to raise_error(Redis::CommandError, "ERR syntax error")
       end
 
       it "should error with too many weights given" do
-        lambda { @client.zinterstore("out", %w(key1 key2), :weights => [10, 1, 1]) }.should raise_error(Redis::CommandError, "ERR syntax error")
+        expect { @client.zinterstore("out", %w(key1 key2), :weights => [10, 1, 1]) }.to raise_error(Redis::CommandError, "ERR syntax error")
       end
 
       it "should error with an invalid aggregate" do
-        lambda { @client.zinterstore("out", %w(key1 key2), :aggregate => :invalid) }.should raise_error(Redis::CommandError, "ERR syntax error")
+        expect { @client.zinterstore("out", %w(key1 key2), :aggregate => :invalid) }.to raise_error(Redis::CommandError, "ERR syntax error")
+      end
+
+      it 'stores nothing when there are no members in common' do
+        @client.zadd("k1", 1, "1")
+        @client.zadd("k1", 1, "2")
+        @client.sadd("k2", "a")
+        @client.sadd("k3", "b")
+
+        expect(@client.zinterstore("out", %w(k1 k2 k3))).to eq(0)
+        expect(@client.zrange("out", 0, -1)).to eq([])
+      end
+
+      it 'handles range start being higher than number of members' do
+        @client.zadd("key", 1, "1")
+
+        expect(@client.zrange("key", 10, 10)).to eq([])
       end
     end
 
@@ -300,23 +359,23 @@ module FakeRedis
         @client.zadd("key", 2, "two")
         @client.zadd("key", 3, "three")
 
-        @client.zremrangebyscore("key", 0, 2).should be == 2
-        @client.zcard("key").should be == 1
+        expect(@client.zremrangebyscore("key", 0, 2)).to eq(2)
+        expect(@client.zcard("key")).to eq(1)
       end
 
       it "should remove items by score with infinity" do # Issue #50
         @client.zadd("key", 10.0, "one")
         @client.zadd("key", 20.0, "two")
         @client.zadd("key", 30.0, "three")
-        @client.zremrangebyscore("key", "-inf", "+inf").should be == 3
-        @client.zcard("key").should be == 0
-        @client.zscore("key", "one").should be_nil
-        @client.zscore("key", "two").should be_nil
-        @client.zscore("key", "three").should be_nil
+        expect(@client.zremrangebyscore("key", "-inf", "+inf")).to eq(3)
+        expect(@client.zcard("key")).to eq(0)
+        expect(@client.zscore("key", "one")).to be_nil
+        expect(@client.zscore("key", "two")).to be_nil
+        expect(@client.zscore("key", "three")).to be_nil
       end
 
       it "should return 0 if the key didn't exist" do
-        @client.zremrangebyscore("key", 0, 2).should be == 0
+        expect(@client.zremrangebyscore("key", 0, 2)).to eq(0)
       end
     end
 
@@ -326,8 +385,8 @@ module FakeRedis
         @client.zadd("key", 2, "two")
         @client.zadd("key", 3, "three")
 
-        @client.zremrangebyrank("key", 0, 1).should be == 2
-        @client.zcard('key').should be == 1
+        expect(@client.zremrangebyrank("key", 0, 1)).to eq(2)
+        expect(@client.zcard('key')).to eq(1)
       end
 
       it 'handles out of range requests' do
@@ -335,12 +394,12 @@ module FakeRedis
         @client.zadd("key", 2, "two")
         @client.zadd("key", 3, "three")
 
-        @client.zremrangebyrank("key", 25, -1).should be == 0
-        @client.zcard('key').should be == 3
+        expect(@client.zremrangebyrank("key", 25, -1)).to eq(0)
+        expect(@client.zcard('key')).to eq(3)
       end
 
       it "should return 0 if the key didn't exist" do
-        @client.zremrangebyrank("key", 0, 1).should be == 0
+        expect(@client.zremrangebyrank("key", 0, 1)).to eq(0)
       end
     end
 
@@ -356,66 +415,66 @@ module FakeRedis
       end
 
       it "should union two keys with custom scores" do
-        @client.zunionstore("out", %w(key1 key2)).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", 1], ["val2", (2 + 5)], ["val3", (3 + 7)]]
+        expect(@client.zunionstore("out", %w(key1 key2))).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 key3)).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", (1 + 1)], ["val2", (2 + 1)], ["val3", 3]]
+        expect(@client.zunionstore("out", %w(key1 key3))).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 key2 key3)).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", (1 + 1)], ["val2", (2 + 5 + 1)], ["val3", (3 + 7)]]
+        expect(@client.zunionstore("out", %w(key1 key2 key3))).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 no_key)).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", 1], ["val2", 2], ["val3", 3]]
+        expect(@client.zunionstore("out", %w(key1 no_key))).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 key2), :aggregate => :min).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", 1], ["val2", 2], ["val3", 3]]
+        expect(@client.zunionstore("out", %w(key1 key2), :aggregate => :min)).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 key2), :aggregate => :max).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", 1], ["val2", 5], ["val3", 7]]
+        expect(@client.zunionstore("out", %w(key1 key2), :aggregate => :max)).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 key2), :aggregate => :sum).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", 1], ["val2", (2 + 5)], ["val3", (3 + 7)]]
+        expect(@client.zunionstore("out", %w(key1 key2), :aggregate => :sum)).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 key2), :weights => [10, 1]).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", (1 * 10)], ["val2", (2 * 10 + 5)], ["val3", (3 * 10 + 7)]]
+        expect(@client.zunionstore("out", %w(key1 key2), :weights => [10, 1])).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 key2), :weights => [10, 1], :aggregate => :min).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val2", 5], ["val3", 7], ["val1", (1 * 10)]]
+        expect(@client.zunionstore("out", %w(key1 key2), :weights => [10, 1], :aggregate => :min)).to eq(3)
+        expect(@client.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
-        @client.zunionstore("out", %w(key1 key2), :weights => [10, 1], :aggregate => :max).should be == 3
-        @client.zrange("out", 0, -1, :with_scores => true).should be == [["val1", (1 * 10)], ["val2", (2 * 10)], ["val3", (3 * 10)]]
+        expect(@client.zunionstore("out", %w(key1 key2), :weights => [10, 1], :aggregate => :max)).to eq(3)
+        expect(@client.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
-        lambda { @client.zunionstore("out", %w(key1 key2), :weights => []) }.should raise_error(Redis::CommandError, "ERR syntax error")
-        lambda { @client.zunionstore("out", %w(key1 key2), :weights => [10]) }.should raise_error(Redis::CommandError, "ERR syntax error")
+        expect { @client.zunionstore("out", %w(key1 key2), :weights => []) }.to raise_error(Redis::CommandError, "ERR syntax error")
+        expect { @client.zunionstore("out", %w(key1 key2), :weights => [10]) }.to raise_error(Redis::CommandError, "ERR syntax error")
       end
 
       it "should error with too many weights given" do
-        lambda { @client.zunionstore("out", %w(key1 key2), :weights => [10, 1, 1]) }.should raise_error(Redis::CommandError, "ERR syntax error")
+        expect { @client.zunionstore("out", %w(key1 key2), :weights => [10, 1, 1]) }.to raise_error(Redis::CommandError, "ERR syntax error")
       end
 
       it "should error with an invalid aggregate" do
-        lambda { @client.zunionstore("out", %w(key1 key2), :aggregate => :invalid) }.should raise_error(Redis::CommandError, "ERR syntax error")
+        expect { @client.zunionstore("out", %w(key1 key2), :aggregate => :invalid) }.to raise_error(Redis::CommandError, "ERR syntax error")
       end
     end
 
@@ -434,7 +493,280 @@ module FakeRedis
     it "zrem should remove members add by zadd" do
       @client.zadd("key1", 1, 3)
       @client.zrem("key1", 3)
-      @client.zscore("key1", 3).should be_nil
+      expect(@client.zscore("key1", 3)).to be_nil
+    end
+
+    describe "#zscan" do
+      before { 50.times { |x| @client.zadd("key", x, "key #{x}") } }
+
+      it 'with no arguments should return 10 numbers in ascending order' do
+        result = @client.zscan("key", 0)[1]
+        expect(result).to eq(result.sort { |x, y| x[1] <=> y[1] })
+        expect(result.count).to eq(10)
+      end
+
+      it 'with a count should return that number of members' do
+        expect(@client.zscan("key", 0, count: 2)).to eq(["2", [["key 0", 0.0], ["key 1", 1.0]]])
+      end
+
+      it 'with a count greater than the number of members, returns all the members in asc order' do
+        result = @client.zscan("key", 0, count: 1000)[1]
+        expect(result).to eq(result.sort { |x, y| x[1] <=> y[1] })
+        expect(result.size).to eq(50)
+      end
+
+      it 'with match, should return key-values where the key matches' do
+        @client.zadd("key", 1.0, "blah")
+        @client.zadd("key", 2.0, "bluh")
+        result = @client.zscan("key", 0, count: 100, match: "key*")[1]
+        expect(result).to_not include(["blah", 1.0])
+        expect(result).to_not include(["bluh", 2.0])
+      end
+    end
+
+    describe "#zscan_each" do
+      before { 50.times { |x| @client.zadd("key", x, "key #{x}") } }
+
+      it 'enumerates over the items in the sorted set' do
+        expect(@client.zscan_each("key").to_a).to eq(@client.zscan("key", 0, count: 50)[1])
+      end
+    end
+
+    describe '#zrangebylex' do
+      before { @client.zadd "myzset", [0, 'a', 0, 'b', 0, 'd', 0, 'c'] }
+
+      it "should return empty list for '+'..'-' range" do
+        ranged = @client.zrangebylex "myzset", "+", "-"
+        expect(ranged).to be_empty
+      end
+
+      it "should return all elements for '-'..'+' range" do
+        ranged = @client.zrangebylex "myzset", "-", "+"
+        expect(ranged).to eq %w(a b c d)
+      end
+
+      it "should include values starting with [ symbol" do
+        ranged = @client.zrangebylex "myzset", "-", "[c"
+        expect(ranged).to eq %w(a b c)
+      end
+
+      it "should exclude values with ( symbol" do
+        ranged = @client.zrangebylex "myzset", "-", "(c"
+        expect(ranged).to eq %w(a b)
+      end
+
+      it "should work with both [ and ( properly" do
+        ranged = @client.zrangebylex "myzset", "[aaa", "(d"
+        expect(ranged).to eq %w(b c)
+      end
+
+      it "should return empty array if key is not exist" do
+        ranged = @client.zrangebylex "puppies", "-", "+"
+        expect(ranged).to be_empty
+      end
+
+      it 'should raise error for invalid range when range is invalid' do
+        expect{ @client.zrangebylex "myzset", "-", "d" }.to raise_error(Redis::CommandError, "ERR min or max not valid string range item")
+      end
+
+      it "should limit and offset values as 4th argument" do
+        ranged = @client.zrangebylex "myzset", "-", "+", limit: [1, 3]
+        expect(ranged).to eq %w(b c d)
+      end
+    end
+
+    describe "#zrevrangebylex" do
+      before { @client.zadd "myzset", [0, 'a', 0, 'b', 0, 'd', 0, 'c'] }
+
+      it "should return empty list for '-'..'+' range" do
+        ranged = @client.zrevrangebylex "myzset", "-", "+"
+        expect(ranged).to be_empty
+      end
+
+      it "should return all elements for '+'..'-' range in descending order" do
+        ranged = @client.zrevrangebylex "myzset", "+", "-"
+        expect(ranged).to eq %w(d c b a)
+      end
+
+      it "should include values starting with [ symbol" do
+        ranged = @client.zrevrangebylex "myzset", "[c", "-"
+        expect(ranged).to eq %w(c b a)
+      end
+
+      it "should exclude values with ( symbol" do
+        ranged = @client.zrevrangebylex "myzset", "+", "(c"
+        expect(ranged).to eq %w(d)
+      end
+
+      it "should work with both [ and ( properly" do
+        ranged = @client.zrevrangebylex "myzset", "(d", "[aaa"
+        expect(ranged).to eq %w(c b)
+      end
+
+      it "should return empty array if key does not exist" do
+        ranged = @client.zrevrangebylex "puppies", "+", "-"
+        expect(ranged).to be_empty
+      end
+
+      it 'should raise error for invalid range when range is invalid' do
+        expect { @client.zrevrangebylex "myzset", "-", "d" }.to raise_error(Redis::CommandError, "ERR min or max not valid string range item")
+      end
+
+      it "should limit and offset values as 4th argument" do
+        pending "current stable (3.2.0) redis-rb doesn't support limit option"
+
+        ranged = @client.zrevrangebylex "myzset", "+", "-", limit: [0, 3]
+        expect(ranged).to eq %w(d c b)
+      end
+    end
+
+    describe "#zadd" do
+      context "with {incr: true}" do
+        before { @client.zadd("key", 1, "existing") }
+        it "should increment the element's score with the provided value" do
+          @client.zadd("key", 99, "existing", incr: true)
+          expect(@client.zscore("key", "existing")).to eq(100.0)
+
+          @client.zadd("key", 2, "new", incr: true)
+          expect(@client.zscore("key", "new")).to eq(2.0)
+        end
+
+        it "should error when trying to add multiple increment-element pairs" do
+          expect {
+            @client.zadd("key", [1, "member1", 2, "member2"], incr: true)
+          }.to raise_error(Redis::CommandError, "ERR INCR option supports a single increment-element pair")
+        end
+      end
+
+      context "with {nx: true}" do
+        before { @client.zadd("key", [1, "existing1", 2, "existing2"]) }
+        it "should add new elements but not update the scores of existing elements" do
+          @client.zadd("key", [101, "existing1", 3, "new"], nx: true)
+
+          expect(@client.zscore("key", "existing1")).to eq(1.0)
+          expect(@client.zscore("key", "new")).to eq(3.0)
+
+          @client.zadd("key", 102, "existing2", nx: true)
+          expect(@client.zscore("key", "existing2")).to eq(2.0)
+        end
+      end
+
+      context "with {xx: true}" do
+        before { @client.zadd("key", 1, "existing") }
+        it "should not add new elements" do
+          expect(@client.zadd("key", 1, "new1", xx: true)).to eq(false)
+          expect(@client.zscore("key", "new1")).to be_nil
+
+          expect(@client.zadd("key", [11, "existing", 2, "new2"], xx: true)).to eq(0)
+          expect(@client.zscore("key", "existing")).to eq(11.0)
+          expect(@client.zscore("key", "new2")).to be_nil
+        end
+      end
+
+      context "with {ch: true}" do
+        it "should return the number of new elements added plus the number of existing elements for which the score was updated" do
+          expect(@client.zadd("key", 1, "first", ch: true)).to eq(true)
+
+          expect(@client.zadd("key", [1, "first", 2, "second"], ch: true)).to eq(1.0)
+          expect(@client.zadd("key", [11, "first", 2, "second"], ch: true)).to eq(1.0)
+          expect(@client.zadd("key", [99, "first", 99, "second"], ch: true)).to eq(2.0)
+          expect(@client.zadd("key", [111, "first", 22, "second", 3, "third"], ch: true)).to eq(3.0)
+        end
+      end
+
+      context "with {nx: true, xx: true}" do
+        it "should error" do
+          expect{
+            @client.zadd("key", 1, "value", nx: true, xx: true)
+          }.to raise_error(Redis::CommandError, "ERR XX and NX options at the same time are not compatible")
+        end
+      end
+
+      context "with {nx: true, incr: true}" do
+        let(:options) { {nx: true, incr: true} }
+        it "should increment to the provided score only if the element is new and return the element's score" do
+          expect(@client.zadd("key", 1, "first", options)).to eq(1.0)
+          expect(@client.zscore("key", "first")).to eq(1.0)
+
+          expect(@client.zadd("key", 2, "second", options)).to eq(2.0)
+          expect(@client.zscore("key", "second")).to eq(2.0)
+
+          expect(@client.zadd("key", 99, "first", options)).to be_nil
+          expect(@client.zscore("key", "first")).to eq(1.0)
+        end
+      end
+
+      context "with {nx: true, ch: true}" do
+        let(:options) { {nx: true, ch: true} }
+        it "should add only new elements, not update existing elements, and return the number of added elements" do
+          expect(@client.zadd("key", 1, "first", options)).to eq(true)
+          expect(@client.zadd("key", 1, "first", options)).to eq(false)
+
+          # add two new elements
+          expect(@client.zadd("key", [99, "first", 2, "second", 3, "third"], options)).to eq(2)
+          expect(@client.zscore("key", "first")).to eq(1.0)
+        end
+      end
+
+      context "with {nx: true, incr: true, ch: true}" do
+        let(:options) { {nx: true, incr: true, ch: true} }
+
+        it "should add only new elements" do
+          expect(@client.zadd("key", 1, "first", options)).to eq(1.0)
+          expect(@client.zadd("key", 99, "first", options)).to be_nil
+          expect(@client.zscore("key", "first")).to eq(1.0)
+        end
+
+        # when INCR is present, return value is always the new score of member
+        it "should return the score of the new member" do
+          expect(@client.zadd("key", 2, "second", options)).to eq(2.0)
+        end
+
+        it "should return nil when the member already exists" do
+          @client.zadd("key", 1, "first")
+          expect(@client.zadd("key", 99, "first", options)).to be_nil
+        end
+      end
+
+      context "with {xx: true, incr: true}" do
+        let(:options) { {xx: true, incr: true} }
+        before { @client.zadd("key", 1, "existing") }
+
+        it "should return nil if the member does not already exist" do
+          expect(@client.zadd("key", 1, "new1", options)).to be_nil
+          expect(@client.zscore("key", "new1")).to be_nil
+        end
+
+        it "should increment only existing elements" do
+          expect(@client.zadd("key", [11, "existing"], options)).to eq(12.0)
+          expect(@client.zscore("key", "existing")).to eq(12.0)
+        end
+      end
+
+      context "with {xx: true, ch: true}" do
+        let(:options) { {xx: true, ch: true} }
+        it "should return the number of updated elements and not add new members" do
+          @client.zadd("key", 1, "first")
+
+          expect(@client.zadd("key", 99, "first", options)).to eq(true)
+          expect(@client.zadd("key", [100, "first", 2, "second"], options)).to eq(1.0)
+          expect(@client.zscore("key", "second")).to be_nil
+        end
+      end
+
+      context "with {xx: true, incr: true, ch: true}" do
+        let(:options) { {xx: true, incr: true, ch: true} }
+        before { @client.zadd("key", 1, "existing") }
+
+        # when INCR is present, return value is always the new score of member
+        it "should return the new score of the inserted member" do
+          expect(@client.zadd("key", 2, "existing", options)).to eq(3.0)
+        end
+
+        it "should increment only existing elements" do
+          expect(@client.zadd("key", 1, "new", options)).to be_nil
+        end
+      end
     end
   end
 end