fakeredis 0.4.1 → 0.4.2

data/spec/lists_spec.rb

@@ -10,9 +10,9 @@ module FakeRedis
       @client.lpush("key1", "val1")
       @client.lpush("key1", "val2")
 
-      @client.lindex("key1", 0).should == "val2"
-      @client.lindex("key1", -1).should == "val1"
-      @client.lindex("key1", 3).should == nil
+      @client.lindex("key1", 0).should be == "val2"
+      @client.lindex("key1", -1).should be == "val1"
+      @client.lindex("key1", 3).should be == nil
     end
 
     it "should insert an element before or after another element in a list" do
@@ -20,17 +20,17 @@ module FakeRedis
       @client.rpush("key1", "v3")
       @client.linsert("key1", :before, "v3", "v2")
 
-      @client.lrange("key1", 0, -1).should == ["v1", "v2", "v3"]
+      @client.lrange("key1", 0, -1).should be == ["v1", "v2", "v3"]
     end
-    
+
     it 'should allow multiple values to be added to a list in a single rpush' do
       @client.rpush('key1', [1, 2, 3])
-      @client.lrange('key1', 0, -1).should == ['1', '2', '3']
+      @client.lrange('key1', 0, -1).should be == ['1', '2', '3']
     end
-    
+
     it 'should allow multiple values to be added to a list in a single lpush' do
       @client.lpush('key1', [1, 2, 3])
-      @client.lrange('key1', 0, -1).should == ['3', '2', '1']
+      @client.lrange('key1', 0, -1).should be == ['3', '2', '1']
     end
 
     it "should error if an invalid where argument is given" do
@@ -43,8 +43,8 @@ module FakeRedis
       @client.rpush("key1", "v1")
       @client.rpush("key1", "v2")
 
-      @client.llen("key1").should == 2
-      @client.llen("key2").should == 0
+      @client.llen("key1").should be == 2
+      @client.llen("key2").should be == 0
     end
 
     it "should remove and get the first element in a list" do
@@ -52,15 +52,15 @@ module FakeRedis
       @client.rpush("key1", "v2")
       @client.rpush("key1", "v3")
 
-      @client.lpop("key1").should == "v1"
-      @client.lrange("key1", 0, -1).should == ["v2", "v3"]
+      @client.lpop("key1").should be == "v1"
+      @client.lrange("key1", 0, -1).should be == ["v2", "v3"]
     end
 
     it "should prepend a value to a list" do
       @client.rpush("key1", "v1")
       @client.rpush("key1", "v2")
 
-      @client.lrange("key1", 0, -1).should == ["v1", "v2"]
+      @client.lrange("key1", 0, -1).should be == ["v1", "v2"]
     end
 
     it "should prepend a value to a list, only if the list exists" do
@@ -69,8 +69,8 @@ module FakeRedis
       @client.lpushx("key1", "v2")
       @client.lpushx("key2", "v3")
 
-      @client.lrange("key1", 0, -1).should == ["v2", "v1"]
-      @client.llen("key2").should == 0
+      @client.lrange("key1", 0, -1).should be == ["v2", "v1"]
+      @client.llen("key2").should be == 0
     end
 
     it "should get a range of elements from a list" do
@@ -78,7 +78,7 @@ module FakeRedis
       @client.rpush("key1", "v2")
       @client.rpush("key1", "v3")
 
-      @client.lrange("key1", 1, -1).should == ["v2", "v3"]
+      @client.lrange("key1", 1, -1).should be == ["v2", "v3"]
     end
 
     it "should remove elements from a list" do
@@ -88,9 +88,9 @@ module FakeRedis
       @client.rpush("key1", "v2")
       @client.rpush("key1", "v1")
 
-      @client.lrem("key1", 1, "v1").should == 1
-      @client.lrem("key1", -2, "v2").should == 2
-      @client.llen("key1").should == 2
+      @client.lrem("key1", 1, "v1").should be == 1
+      @client.lrem("key1", -2, "v2").should be == 2
+      @client.llen("key1").should be == 2
     end
 
     it "should remove list's key when list is empty" do
@@ -99,7 +99,7 @@ module FakeRedis
       @client.lrem("key1", 1, "v1")
       @client.lrem("key1", 1, "v2")
 
-      @client.exists("key1").should == false
+      @client.exists("key1").should be == false
     end
 
     it "should set the value of an element in a list by its index" do
@@ -109,7 +109,9 @@ module FakeRedis
 
       @client.lset("key1", 0, "four")
       @client.lset("key1", -2, "five")
-      @client.lrange("key1", 0, -1).should == ["four", "five", "three"]
+      @client.lrange("key1", 0, -1).should be == ["four", "five", "three"]
+
+      lambda { @client.lset("key1", 4, "six") }.should raise_error(Redis::CommandError, "ERR index out of range")
     end
 
     it "should trim a list to the specified range" do
@@ -118,33 +120,34 @@ module FakeRedis
       @client.rpush("key1", "three")
 
       @client.ltrim("key1", 1, -1)
-      @client.lrange("key1", 0, -1).should == ["two", "three"]
+      @client.lrange("key1", 0, -1).should be == ["two", "three"]
     end
 
-    it "should remove and get the last element in a list" do
+    it "should remove and return the last element in a list" do
       @client.rpush("key1", "one")
       @client.rpush("key1", "two")
       @client.rpush("key1", "three")
 
-      @client.rpop("key1").should == "three"
-      @client.lrange("key1", 0, -1).should == ["one", "two"]
+      @client.rpop("key1").should be == "three"
+      @client.lrange("key1", 0, -1).should be == ["one", "two"]
     end
 
     it "should remove the last element in a list, append it to another list and return it" do
       @client.rpush("key1", "one")
       @client.rpush("key1", "two")
       @client.rpush("key1", "three")
-      @client.rpoplpush("key1", "key2")
 
-      @client.lrange("key1", 0, -1).should == ["one", "two"]
-      @client.lrange("key2", 0, -1).should == ["three"]
+      @client.rpoplpush("key1", "key2").should be == "three"
+
+      @client.lrange("key1", 0, -1).should be == ["one", "two"]
+      @client.lrange("key2", 0, -1).should be == ["three"]
     end
 
     it "should append a value to a list" do
       @client.rpush("key1", "one")
       @client.rpush("key1", "two")
 
-      @client.lrange("key1", 0, -1).should == ["one", "two"]
+      @client.lrange("key1", 0, -1).should be == ["one", "two"]
     end
 
     it "should append a value to a list, only if the list exists" do
@@ -152,8 +155,8 @@ module FakeRedis
       @client.rpushx("key1", "two")
       @client.rpushx("key2", "two")
 
-      @client.lrange("key1", 0, -1).should == ["one", "two"]
-      @client.lrange("key2", 0, -1).should == []
+      @client.lrange("key1", 0, -1).should be == ["one", "two"]
+      @client.lrange("key2", 0, -1).should be == []
     end
   end
 end

data/spec/server_spec.rb

@@ -12,11 +12,89 @@ module FakeRedis
       @client.set("key2", "2")
       @client.set("key2", "two")
 
-      @client.dbsize.should == 2
+      @client.dbsize.should be == 2
     end
 
     it "should get information and statistics about the server" do
-      @client.info.key?("redis_version").should == true
+      @client.info.key?("redis_version").should be == true
+    end
+
+    it "should handle non-existent methods" do
+      lambda { @client.idontexist }.should raise_error(Redis::CommandError, "ERR unknown command 'idontexist'")
+    end
+
+    describe "multiple databases" do
+      it "should default to database 0" do
+        @client.inspect.should =~ %r#/0>$#
+      end
+
+      it "should select another database" do
+        @client.select(1)
+        @client.inspect.should =~ %r#/1>$#
+      end
+
+      it "should store keys separately in each database" do
+        @client.select(0).should be == "OK"
+        @client.set("key1", "1")
+        @client.set("key2", "2")
+
+        @client.select(1)
+        @client.set("key3", "3")
+        @client.set("key4", "4")
+        @client.set("key5", "5")
+
+        @client.select(0)
+        @client.dbsize.should be == 2
+        @client.exists("key1").should be_true
+        @client.exists("key3").should be_false
+
+        @client.select(1)
+        @client.dbsize.should be == 3
+        @client.exists("key4").should be_true
+        @client.exists("key2").should be_false
+
+        @client.flushall
+        @client.dbsize.should be == 0
+
+        @client.select(0)
+        @client.dbsize.should be == 0
+      end
+
+      it "should flush a database" do
+        @client.select(0)
+        @client.set("key1", "1")
+        @client.set("key2", "2")
+        @client.dbsize.should be == 2
+
+        @client.select(1)
+        @client.set("key3", "3")
+        @client.set("key4", "4")
+        @client.dbsize.should be == 2
+
+        @client.flushdb.should be == "OK"
+
+        @client.dbsize.should be == 0
+        @client.select(0)
+        @client.dbsize.should be == 2
+      end
+
+      it "should flush all databases" do
+        @client.select(0)
+        @client.set("key3", "3")
+        @client.set("key4", "4")
+        @client.dbsize.should be == 2
+
+        @client.select(1)
+        @client.set("key3", "3")
+        @client.set("key4", "4")
+        @client.dbsize.should be == 2
+
+        @client.flushall.should be == "OK"
+
+        @client.dbsize.should be == 0
+        @client.select(0)
+        @client.dbsize.should be == 0
+      end
     end
   end
 end

data/spec/sets_spec.rb

@@ -7,15 +7,15 @@ module FakeRedis
     end
 
     it "should add a member to a set" do
-      @client.sadd("key", "value").should == true
-      @client.sadd("key", "value").should == false
+      @client.sadd("key", "value").should be == true
+      @client.sadd("key", "value").should be == false
 
-      @client.smembers("key").should == ["value"]
+      @client.smembers("key").should be == ["value"]
     end
 
     it "should add multiple members to a set" do
-      @client.sadd("key", %w(value other something more)).should == 4
-      @client.sadd("key", %w(and additional values)).should == 3
+      @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"]
     end
 
@@ -23,7 +23,7 @@ module FakeRedis
       @client.sadd("key", "val1")
       @client.sadd("key", "val2")
 
-      @client.scard("key").should == 2
+      @client.scard("key").should be == 2
     end
 
     it "should subtract multiple sets" do
@@ -63,7 +63,7 @@ module FakeRedis
       @client.sadd("key3", "c")
       @client.sadd("key3", "e")
 
-      @client.sinter("key1", "key2", "key3").should == ["c"]
+      @client.sinter("key1", "key2", "key3").should be == ["c"]
     end
 
     it "should intersect multiple sets and store the resulting set in a key" do
@@ -76,15 +76,15 @@ module FakeRedis
       @client.sadd("key3", "c")
       @client.sadd("key3", "e")
       @client.sinterstore("key", "key1", "key2", "key3")
-      @client.smembers("key").should == ["c"]
+      @client.smembers("key").should be == ["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 == true
-      @client.sismember("key1", "b").should == false
-      @client.sismember("key2", "a").should == false
+      @client.sismember("key1", "a").should be == true
+      @client.sismember("key1", "b").should be == false
+      @client.sismember("key2", "a").should be == false
     end
 
     it "should get all the members in a set" do
@@ -100,10 +100,10 @@ module FakeRedis
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
       @client.sadd("key2", "c")
-      @client.smove("key1", "key2", "a").should == true
-      @client.smove("key1", "key2", "a").should == false
+      @client.smove("key1", "key2", "a").should be == true
+      @client.smove("key1", "key2", "a").should be == false
 
-      @client.smembers("key1").should == ["b"]
+      @client.smembers("key1").should be == ["b"]
       @client.smembers("key2").should =~ ["c", "a"]
     end
 
@@ -126,10 +126,10 @@ module FakeRedis
     it "should remove a member from a set" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
-      @client.srem("key1", "a").should == true
-      @client.srem("key1", "a").should == false
+      @client.srem("key1", "a").should be == true
+      @client.srem("key1", "a").should be == false
 
-      @client.smembers("key1").should == ["b"]
+      @client.smembers("key1").should be == ["b"]
     end
 
     it "should remove the set's key once it's empty" do
@@ -138,7 +138,7 @@ module FakeRedis
       @client.srem("key1", "b")
       @client.srem("key1", "a")
 
-      @client.exists("key1").should == false
+      @client.exists("key1").should be == false
     end
 
     it "should add multiple sets" do

data/spec/sorted_sets_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 module FakeRedis
+  Infinity = 1.0/0.0
+
   describe "SortedSetsMethods" do
     before(:each) do
       @client = Redis.new
@@ -8,10 +10,28 @@ module FakeRedis
 
     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 == 1.0
+      @client.zscore("key", "val").should be == 1.0
 
       @client.zadd("key", 2, "val").should be(false)
-      @client.zscore("key", "val").should == 2.0
+      @client.zscore("key", "val").should be == 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
+
+      @client.zadd("key3", "+inf", "val").should be == true
+      @client.zscore("key3", "val").should be == Infinity
+
+      @client.zadd("key4", "-inf", "val").should be == true
+      @client.zscore("key4", "val").should be == -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
     end
 
     it "should add multiple members to a sorted set, or update its score if it already exists" do
@@ -36,10 +56,10 @@ module FakeRedis
 
     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 == 4.321
+      @client.zscore("key", "val").should be == 4.321
 
       @client.zadd("key", 54.3210, "val").should be(false)
-      @client.zscore("key", "val").should == 54.321
+      @client.zscore("key", "val").should be == 54.321
     end
 
     it "should remove members from sorted sets" do
@@ -48,10 +68,21 @@ module FakeRedis
       @client.zrem("key", "val").should 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
+
+      @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
+    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 == false
+      @client.exists("key").should be == false
     end
 
     it "should get the number of members in a sorted set" do
@@ -59,7 +90,7 @@ module FakeRedis
       @client.zadd("key", 2, "val1")
       @client.zadd("key", 5, "val3")
 
-      @client.zcard("key").should == 3
+      @client.zcard("key").should be == 3
     end
 
     it "should count the members in a sorted set with scores within the given values" do
@@ -67,34 +98,48 @@ module FakeRedis
       @client.zadd("key", 2, "val2")
       @client.zadd("key", 3, "val3")
 
-      @client.zcount("key", 2, 3).should == 2
+      @client.zcount("key", 2, 3).should be == 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 == 3
-      @client.zscore("key", "val1").should == 3
+      @client.zincrby("key", 2, "val1").should be == 3
+      @client.zscore("key", "val1").should be == 3
     end
 
     it "initializes the sorted set if the key wasnt already set" do
-      @client.zincrby("key", 1, "val1").should == 1
+      @client.zincrby("key", 1, "val1").should be == 1
     end
 
     it "should convert the key to a string for zscore" do
       @client.zadd("key", 1, 1)
-      @client.zscore("key", 1).should == 1
+      @client.zscore("key", 1).should be == 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
     end
-    #it "should intersect multiple sorted sets and store the resulting sorted set in a new key"
 
     it "should return a range of members in a sorted set, by index" do
       @client.zadd("key", 1, "one")
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrange("key", 0, -1).should == ["one", "two", "three"]
-      @client.zrange("key", 1, 2).should == ["two", "three"]
-      @client.zrange("key", 0, -1, :withscores => true).should == [["one", 1], ["two", 2], ["three", 3]]
-      @client.zrange("key", 1, 2, :with_scores => true).should == [["two", 2], ["three", 3]]
+      @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]]
+    end
+
+    it "should sort zrange results logically" do
+      @client.zadd("key", 5, "val2")
+      @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]]
     end
 
     it "should return a reversed range of members in a sorted set, by index" do
@@ -102,10 +147,10 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrevrange("key", 0, -1).should == ["three", "two", "one"]
-      @client.zrevrange("key", 1, 2).should == ["two", "one"]
-      @client.zrevrange("key", 0, -1, :withscores => true).should == [["three", 3], ["two", 2], ["one", 1]]
-      @client.zrevrange("key", 0, -1, :with_scores => true).should == [["three", 3], ["two", 2], ["one", 1]]
+      @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]]
     end
 
     it "should return a range of members in a sorted set, by score" do
@@ -113,16 +158,16 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrangebyscore("key", 0, 100).should == ["one", "two", "three"]
-      @client.zrangebyscore("key", 1, 2).should == ["one", "two"]
-      @client.zrangebyscore("key", 0, 100, :withscores => true).should == [["one", 1], ["two", 2], ["three", 3]]
-      @client.zrangebyscore("key", 1, 2, :with_scores => true).should == [["one", 1], ["two", 2]]
-      @client.zrangebyscore("key", 0, 100, :limit => [0, 1]).should == ["one"]
-      @client.zrangebyscore("key", 0, 100, :limit => [0, -1]).should == ["one", "two", "three"]
-      @client.zrangebyscore("key", 0, 100, :limit => [1, -1], :with_scores => true).should == [["two", 2], ["three", 3]]
-      @client.zrangebyscore("key", '-inf', '+inf').should == ["one", "two", "three"]
-      @client.zrangebyscore("key", 2, '+inf').should == ["two", "three"]
-      @client.zrangebyscore("key", '-inf', 2).should == ['one', "two"]
+      @client.zrangebyscore("key", 0, 100).should be == ["one", "two", "three"]
+      @client.zrangebyscore("key", 1, 2).should be == ["one", "two"]
+      @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"]
     end
 
     it "should return a reversed range of members in a sorted set, by score" do
@@ -130,13 +175,13 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrevrangebyscore("key", 100, 0).should == ["three", "two", "one"]
-      @client.zrevrangebyscore("key", 2, 1).should == ["two", "one"]
-      @client.zrevrangebyscore("key", 1, 2).should == []
-      @client.zrevrangebyscore("key", 2, 1, :with_scores => true).should == [["two", 2], ["one", 1]]
-      @client.zrevrangebyscore("key", 100, 0, :limit => [0, 1]).should == ["three"]
-      @client.zrevrangebyscore("key", 100, 0, :limit => [0, -1]).should == ["three", "two", "one"]
-      @client.zrevrangebyscore("key", 100, 0, :limit => [1, -1], :with_scores => true).should == [["two", 2], ["one", 1]]
+      @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], ["one", 1]]
+      @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], ["one", 1]]
     end
 
     it "should determine the index of a member in a sorted set" do
@@ -144,7 +189,7 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrank("key", "three").should == 2
+      @client.zrank("key", "three").should be == 2
       @client.zrank("key", "four").should be_nil
     end
 
@@ -153,30 +198,83 @@ module FakeRedis
       @client.zadd("key", 2, "two")
       @client.zadd("key", 3, "three")
 
-      @client.zrevrank("key", "three").should == 0
+      @client.zrevrank("key", "three").should be == 0
       @client.zrevrank("key", "four").should be_nil
     end
 
-    it "should create intersections between multiple (sorted) sets and store the resulting sorted set in a new key" do
-      @client.zadd("key1", 1, "one")
-      @client.zadd("key1", 2, "two")
-      @client.zadd("key1", 3, "three")
-      @client.zadd("key2", 5, "two")
-      @client.zadd("key2", 7, "three")
-      @client.sadd("key3", 'one')
-      @client.sadd("key3", 'two')
+    describe "#zinterstore" do
+      before do
+        @client.zadd("key1", 1, "one")
+        @client.zadd("key1", 2, "two")
+        @client.zadd("key1", 3, "three")
+        @client.zadd("key2", 5, "two")
+        @client.zadd("key2", 7, "three")
+        @client.sadd("key3", 'one')
+        @client.sadd("key3", 'two')
+      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)]]
+      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)]]
+      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)]]
+      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 == []
+      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]]
+      end
 
-      @client.zinterstore("out", ["key1", "key2"]).should == 2
-      @client.zrange("out", 0, 100, :with_scores => true).should == [['two', 7], ['three', 10]]
+      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]]
+      end
 
-      @client.zinterstore("out", ["key1", "key3"]).should == 2
-      @client.zrange("out", 0, 100, :with_scores => true).should == [['one', 2], ['two', 3]]
+      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)]]
+      end
 
-      @client.zinterstore("out", ["key1", "key2", "key3"]).should == 1
-      @client.zrange("out", 0, 100, :with_scores => true).should == [['two', 8]]
+      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)]]
+      end
 
-      @client.zinterstore("out", ["key1", "no_key"]).should == 0
-      @client.zrange("out", 0, 100, :with_scores => true).should == []
+      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]]
+      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)]]
+      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")
+      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")
+      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")
+      end
     end
 
     context "zremrangebyscore" do
@@ -185,12 +283,23 @@ module FakeRedis
         @client.zadd("key", 2, "two")
         @client.zadd("key", 3, "three")
 
-        @client.zremrangebyscore("key", 0, 2).should == 2
-        @client.zcard("key").should == 1
+        @client.zremrangebyscore("key", 0, 2).should be == 2
+        @client.zcard("key").should be == 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
       end
 
       it "should return 0 if the key didn't exist" do
-        @client.zremrangebyscore("key", 0, 2).should == 0
+        @client.zremrangebyscore("key", 0, 2).should be == 0
       end
     end
 
@@ -200,8 +309,8 @@ module FakeRedis
         @client.zadd("key", 2, "two")
         @client.zadd("key", 3, "three")
 
-        @client.zremrangebyrank("key", 0, 1).should == 2
-        @client.zcard('key').should == 1
+        @client.zremrangebyrank("key", 0, 1).should be == 2
+        @client.zcard('key').should be == 1
       end
 
       it 'handles out of range requests' do
@@ -209,8 +318,83 @@ module FakeRedis
         @client.zadd("key", 2, "two")
         @client.zadd("key", 3, "three")
 
-        @client.zremrangebyrank("key", 25, -1).should == 0
-        @client.zcard('key').should == 3
+        @client.zremrangebyrank("key", 25, -1).should be == 0
+        @client.zcard('key').should be == 3
+      end
+    end
+
+    describe "#zunionstore" do
+      before do
+        @client.zadd("key1", 1, "val1")
+        @client.zadd("key1", 2, "val2")
+        @client.zadd("key1", 3, "val3")
+        @client.zadd("key2", 5, "val2")
+        @client.zadd("key2", 7, "val3")
+        @client.sadd("key3", "val1")
+        @client.sadd("key3", "val2")
+      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)]]
+      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]]
+      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)]]
+      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]]
+      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]]
+      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]]
+      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)]]
+      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)]]
+      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)]]
+      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)]]
+      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")
+      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")
+      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")
       end
     end