fakeredis 0.3.2 → 0.3.3

data/spec/compatibility_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module FakeRedis
   describe "Compatibility" do
-    it "should be accessible throught FakeRedis::Redis" do
-      lambda { redis = FakeRedis::Redis.new }.should_not raise_error
+    it "should be accessible through FakeRedis::Redis" do
+      lambda { FakeRedis::Redis.new }.should_not raise_error
     end
   end
 end

data/spec/connection_spec.rb

@@ -7,16 +7,26 @@ module FakeRedis
       @client = Redis.new
     end
 
+  if fakeredis?
     it "should authenticate to the server" do
-      @client.auth("pass").should == "OK"
+      @client.auth("pass").should be == "OK"
     end
 
+    it "should not error with shutdown" do
+      lambda { @client.shutdown }.should_not raise_error
+    end
+
+    it "should not error with quit" do
+      lambda { @client.quit }.should_not raise_error
+    end
+  end
+
     it "should echo the given string" do
-      @client.echo("something").should == "something"
+      @client.echo("something").should be == "something"
     end
 
     it "should ping the server" do
-      @client.ping.should == "PONG"
+      @client.ping.should be == "PONG"
     end
   end
 end

data/spec/hashes_spec.rb

@@ -12,7 +12,7 @@ module FakeRedis
       @client.hdel("key1", "k1")
 
       @client.hget("key1", "k1").should be_nil
-      @client.hget("key1", "k2").should == "val2"
+      @client.hget("key1", "k2").should be == "val2"
     end
 
     it "should remove a hash with no keys left" do
@@ -21,23 +21,23 @@ module FakeRedis
       @client.hdel("key1", "k1")
       @client.hdel("key1", "k2")
 
-      @client.exists("key1").should == false
+      @client.exists("key1").should be == false
     end
 
-    it "should convert key to a string via to_s for hset" do
+    it "should convert key to a string for hset" do
       m = double("key")
       m.stub(:to_s).and_return("foo")
 
       @client.hset("key1", m, "bar")
-      @client.hget("key1", "foo").should == "bar"
+      @client.hget("key1", "foo").should be == "bar"
     end
 
-    it "should convert key to a string via to_s for hget" do
+    it "should convert key to a string for hget" do
       m = double("key")
       m.stub(:to_s).and_return("foo")
 
       @client.hset("key1", "foo", "bar")
-      @client.hget("key1", m).should == "bar"
+      @client.hget("key1", m).should be == "bar"
     end
 
     it "should determine if a hash field exists" do
@@ -50,25 +50,25 @@ module FakeRedis
     it "should get the value of a hash field" do
       @client.hset("key1", "index", "value")
 
-      @client.hget("key1", "index").should == "value"
+      @client.hget("key1", "index").should be == "value"
     end
 
     it "should get all the fields and values in a hash" do
       @client.hset("key1", "i1", "val1")
       @client.hset("key1", "i2", "val2")
 
-      @client.hgetall("key1").should == {"i1" => "val1", "i2" => "val2"}
+      @client.hgetall("key1").should be == {"i1" => "val1", "i2" => "val2"}
     end
 
     it "should increment the integer value of a hash field by the given number" do
       @client.hset("key1", "cont1", "5")
-      @client.hincrby("key1", "cont1", "5").should == 10
-      @client.hget("key1", "cont1").should == "10"
+      @client.hincrby("key1", "cont1", "5").should be == 10
+      @client.hget("key1", "cont1").should be == "10"
     end
 
     it "should increment non existing hash keys" do
       @client.hget("key1", "cont2").should be_nil
-      @client.hincrby("key1", "cont2", "5").should == 5
+      @client.hincrby("key1", "cont2", "5").should be == 5
     end
 
     it "should get all the fields in a hash" do
@@ -76,14 +76,14 @@ module FakeRedis
       @client.hset("key1", "i2", "val2")
 
       @client.hkeys("key1").should =~ ["i1", "i2"]
-      @client.hkeys("key2").should == []
+      @client.hkeys("key2").should be == []
     end
 
     it "should get the number of fields in a hash" do
       @client.hset("key1", "i1", "val1")
       @client.hset("key1", "i2", "val2")
 
-      @client.hlen("key1").should == 2
+      @client.hlen("key1").should be == 2
     end
 
     it "should get the values of all the given hash fields" do
@@ -91,48 +91,59 @@ module FakeRedis
       @client.hset("key1", "i2", "val2")
 
       @client.hmget("key1", "i1", "i2", "i3").should =~ ["val1", "val2", nil]
-      @client.hmget("key2", "i1", "i2").should == [nil, nil]
+      @client.hmget("key2", "i1", "i2").should be == [nil, nil]
     end
 
-    it "throws an argument error when you don't ask for any keys" do
-      lambda { @client.hmget("key1") }.should raise_error(ArgumentError)
+    it "should throw an argument error when you don't ask for any keys" do
+      lambda { @client.hmget("key1") }.should raise_error(RuntimeError, "ERR wrong number of arguments for 'hmget' command")
     end
 
     it "should reject an empty list of values" do
-      lambda { @client.hmset("key") }.should raise_error(ArgumentError)
+      lambda { @client.hmset("key") }.should raise_error(RuntimeError, "ERR wrong number of arguments for 'hmset' command")
       @client.exists("key").should be_false
     end
 
-    it 'rejects an insert with a key but no value' do
-      lambda { @client.hmset("key", 'foo') }.should raise_error(ArgumentError)
-      lambda { @client.hmset("key", 'foo', 3, 'bar') }.should raise_error(ArgumentError)
+    it "rejects an insert with a key but no value" do
+      lambda { @client.hmset("key", 'foo') }.should raise_error(RuntimeError, "ERR wrong number of arguments for 'hmset' command")
+      lambda { @client.hmset("key", 'foo', 3, 'bar') }.should raise_error(RuntimeError, "ERR wrong number of arguments for HMSET")
       @client.exists("key").should be_false
     end
 
+    it "should reject the wrong number of arguments" do
+      lambda { @client.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3") }.should raise_error(RuntimeError, "ERR wrong number of arguments for HMSET")
+    end
+
     it "should set multiple hash fields to multiple values" do
       @client.hmset("key", "k1", "value1", "k2", "value2")
 
-      @client.hget("key", "k1").should == "value1"
-      @client.hget("key", "k2").should == "value2"
+      @client.hget("key", "k1").should be == "value1"
+      @client.hget("key", "k2").should be == "value2"
+    end
+
+    it "should set multiple hash fields from a ruby hash to multiple values" do
+      @client.mapped_hmset("foo", :k1 => "value1", :k2 => "value2")
+
+      @client.hget("foo", "k1").should be == "value1"
+      @client.hget("foo", "k2").should be == "value2"
     end
 
     it "should set the string value of a hash field" do
-      @client.hset("key1", "k1", "val1").should == true
-      @client.hset("key1", "k1", "val1").should == false
+      @client.hset("key1", "k1", "val1").should be == true
+      @client.hset("key1", "k1", "val1").should be == false
 
-      @client.hget("key1", "k1").should == "val1"
+      @client.hget("key1", "k1").should be == "val1"
     end
 
     it "should set the value of a hash field, only if the field does not exist" do
       @client.hset("key1", "k1", "val1")
-      @client.hsetnx("key1", "k1", "value").should == false
-      @client.hsetnx("key1", "k2", "val2").should == true
-      @client.hsetnx("key1", :k1, "value").should == false
-      @client.hsetnx("key1", :k3, "val3").should == true
-
-      @client.hget("key1", "k1").should == "val1"
-      @client.hget("key1", "k2").should == "val2"
-      @client.hget("key1", "k3").should == "val3"
+      @client.hsetnx("key1", "k1", "value").should be == false
+      @client.hsetnx("key1", "k2", "val2").should be == true
+      @client.hsetnx("key1", :k1, "value").should be == false
+      @client.hsetnx("key1", :k3, "val3").should be == true
+
+      @client.hget("key1", "k1").should be == "val1"
+      @client.hget("key1", "k2").should be == "val2"
+      @client.hget("key1", "k3").should be == "val3"
     end
 
     it "should get all the values in a hash" do

data/spec/keys_spec.rb

@@ -12,45 +12,45 @@ module FakeRedis
       @client.set("key2", "2")
       @client.del("key1", "key2")
 
-      @client.get("key1").should == nil
+      @client.get("key1").should be == nil
     end
 
     it "should determine if a key exists" do
       @client.set("key1", "1")
 
-      @client.exists("key1").should == true
-      @client.exists("key2").should == false
+      @client.exists("key1").should be == true
+      @client.exists("key2").should be == false
     end
 
     it "should set a key's time to live in seconds" do
       @client.set("key1", "1")
       @client.expire("key1", 1)
 
-      @client.ttl("key1").should == 1
+      @client.ttl("key1").should be == 1
     end
 
     it "should set the expiration for a key as a UNIX timestamp" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i + 2)
 
-      @client.ttl("key1").should == 2
+      @client.ttl("key1").should be == 2
     end
 
-    it 'should not have an expiration after re-set' do
+    it "should not have an expiration after re-set" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i + 2)
       @client.set("key1", "1")
 
-      @client.ttl("key1").should == -1
+      @client.ttl("key1").should be == -1
     end
 
     it "should not have a ttl if expired" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.ttl("key1").should == -1
+      @client.ttl("key1").should be == -1
     end
-    
+
     it "should not find a key if expired" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
@@ -63,7 +63,7 @@ module FakeRedis
       @client.set("key2", "2")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.mget("key1", "key2").should == [nil, "2"]
+      @client.mget("key1", "key2").should be == [nil, "2"]
     end
 
     it "should only find keys that aren't expired" do
@@ -71,7 +71,7 @@ module FakeRedis
       @client.set("key2", "2")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.keys.should == ["key2"]
+      @client.keys.should be == ["key2"]
     end
 
     it "should not exist if expired" do
@@ -88,31 +88,31 @@ module FakeRedis
       @client.set("akeyd", "4")
       @client.set("key1", "5")
 
-      @client.keys("key:").should =~ ["key:a", "key:b", "key:c"]
+      @client.keys("key:*").should =~ ["key:a", "key:b", "key:c"]
     end
 
     it "should remove the expiration from a key" do
       @client.set("key1", "1")
-      @client.expireat("key1", Time.now.to_i)
-      @client.persist("key1").should == true
-      @client.persist("key1").should == false
+      @client.expireat("key1", Time.now.to_i + 1)
+      @client.persist("key1").should be == true
+      @client.persist("key1").should be == false
 
-      @client.ttl("key1").should == -1
+      @client.ttl("key1").should be == -1
     end
 
     it "should return a random key from the keyspace" do
       @client.set("key1", "1")
       @client.set("key2", "2")
 
-      ["key1", "key2"].include?(@client.randomkey).should == true
+      ["key1", "key2"].include?(@client.randomkey).should be == true
     end
 
     it "should rename a key" do
       @client.set("key1", "2")
       @client.rename("key1", "key2")
 
-      @client.get("key1").should == nil
-      @client.get("key2").should == "2"
+      @client.get("key1").should be == nil
+      @client.get("key2").should be == "2"
     end
 
     it "should rename a key, only if new key does not exist" do
@@ -122,10 +122,10 @@ module FakeRedis
       @client.renamenx("key1", "key2")
       @client.renamenx("key3", "key4")
 
-      @client.get("key1").should == "1"
-      @client.get("key2").should == "2"
-      @client.get("key3").should == nil
-      @client.get("key4").should == "3"
+      @client.get("key1").should be == "1"
+      @client.get("key2").should be == "2"
+      @client.get("key3").should be == nil
+      @client.get("key4").should be == "3"
     end
 
     it "should sort the elements in a list, set or sorted set" do
@@ -135,16 +135,29 @@ module FakeRedis
     it "should determine the type stored at key" do
       @client.set("key1", "1")
 
-      @client.type("key1").should == "string"
-      @client.type("key0").should == "none"
+      @client.type("key1").should be == "string"
+      @client.type("key0").should be == "none"
     end
 
     it "should convert the value into a string before storing" do
       @client.set("key1", 1)
-      @client.get("key1").should == "1"
+      @client.get("key1").should be == "1"
 
       @client.setex("key2", 30, 1)
-      @client.get("key2").should == "1"
+      @client.get("key2").should be == "1"
+
+      @client.getset("key3", 1)
+      @client.get("key3").should be == "1"
+    end
+
+    it "should only operate against keys containing string values" do
+      @client.sadd("key1", "one")
+      lambda { @client.get("key1") }.should raise_error(RuntimeError, "ERR Operation against a key holding the wrong kind of value")
+      lambda { @client.getset("key1", 1) }.should raise_error(RuntimeError, "ERR Operation against a key holding the wrong kind of value")
+
+      @client.hset("key2", "one", "two")
+      lambda { @client.get("key2") }.should raise_error(RuntimeError, "ERR Operation against a key holding the wrong kind of value")
+      lambda { @client.getset("key2", 1) }.should raise_error(RuntimeError, "ERR Operation against a key holding the wrong kind of value")
     end
   end
 end

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,15 +20,27 @@ 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 not allow multiple values to be added to a list in a single rpush" do
+      # redis-rb v2.2.2 calls #to_s on the second argument
+      @client.rpush('key1', [1, 2, 3])
+      @client.lrange('key1', 0, -1).should be == [[1, 2, 3].to_s]
+    end
+
+    it "should allow multiple values to be added to a list in a single lpush" do
+      # redis-rb v2.2.2 calls #to_s on the second argument
+      @client.lpush('key1', [1, 2, 3])
+      @client.lrange('key1', 0, -1).should be == [[1, 2, 3].to_s]
     end
 
     it "should get the length of a list" do
       @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
@@ -36,15 +48,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
@@ -53,8 +65,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
@@ -62,7 +74,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
@@ -72,9 +84,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
@@ -83,7 +95,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
@@ -93,7 +105,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(RuntimeError, "ERR index out of range")
     end
 
     it "should trim a list to the specified range" do
@@ -102,33 +116,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
@@ -136,8 +151,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 == nil
+      @client.lrange("key1", 0, -1).should be == ["one", "two"]
+      @client.lrange("key2", 0, -1).should be == []
     end
   end
 end