fakeredis 0.5.0 → 0.8.0

data/spec/hashes_spec.rb

@@ -9,168 +9,194 @@ module FakeRedis
     it "should delete a hash field" do
       @client.hset("key1", "k1", "val1")
       @client.hset("key1", "k2", "val2")
-      @client.hdel("key1", "k1").should be(1)
+      expect(@client.hdel("key1", "k1")).to be(1)
 
-      @client.hget("key1", "k1").should be_nil
-      @client.hget("key1", "k2").should be == "val2"
+      expect(@client.hget("key1", "k1")).to be_nil
+      expect(@client.hget("key1", "k2")).to eq("val2")
+    end
+
+    it "should delete array of fields" do
+      @client.hset("key1", "k1", "val1")
+      @client.hset("key1", "k2", "val2")
+      @client.hset("key1", "k3", "val3")
+      expect(@client.hdel("key1", ["k1", "k2"])).to be(2)
+
+      expect(@client.hget("key1", "k1")).to be_nil
+      expect(@client.hget("key1", "k2")).to be_nil
+      expect(@client.hget("key1", "k3")).to eq("val3")
     end
 
     it "should remove a hash with no keys left" do
       @client.hset("key1", "k1", "val1")
       @client.hset("key1", "k2", "val2")
-      @client.hdel("key1", "k1").should be(1)
-      @client.hdel("key1", "k2").should be(1)
+      expect(@client.hdel("key1", "k1")).to be(1)
+      expect(@client.hdel("key1", "k2")).to be(1)
 
-      @client.exists("key1").should be == false
+      expect(@client.exists("key1")).to eq(false)
     end
 
     it "should convert key to a string for hset" do
       m = double("key")
-      m.stub(:to_s).and_return("foo")
+      allow(m).to receive(:to_s).and_return("foo")
 
       @client.hset("key1", m, "bar")
-      @client.hget("key1", "foo").should be == "bar"
+      expect(@client.hget("key1", "foo")).to eq("bar")
     end
 
     it "should convert key to a string for hget" do
       m = double("key")
-      m.stub(:to_s).and_return("foo")
+      allow(m).to receive(:to_s).and_return("foo")
 
       @client.hset("key1", "foo", "bar")
-      @client.hget("key1", m).should be == "bar"
+      expect(@client.hget("key1", m)).to eq("bar")
     end
 
     it "should determine if a hash field exists" do
       @client.hset("key1", "index", "value")
 
-      @client.hexists("key1", "index").should be true
-      @client.hexists("key2", "i2").should be false
+      expect(@client.hexists("key1", "index")).to be true
+      expect(@client.hexists("key2", "i2")).to be false
     end
 
     it "should get the value of a hash field" do
       @client.hset("key1", "index", "value")
 
-      @client.hget("key1", "index").should be == "value"
+      expect(@client.hget("key1", "index")).to eq("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 be == {"i1" => "val1", "i2" => "val2"}
+      expect(@client.hgetall("key1")).to eq({"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 be == 10
-      @client.hget("key1", "cont1").should be == "10"
+      expect(@client.hincrby("key1", "cont1", "5")).to eq(10)
+      expect(@client.hget("key1", "cont1")).to eq("10")
     end
 
     it "should increment non existing hash keys" do
-      @client.hget("key1", "cont2").should be_nil
-      @client.hincrby("key1", "cont2", "5").should be == 5
+      expect(@client.hget("key1", "cont2")).to be_nil
+      expect(@client.hincrby("key1", "cont2", "5")).to eq(5)
     end
 
     it "should increment the float value of a hash field by the given float" do
       @client.hset("key1", "cont1", 5.0)
-      @client.hincrbyfloat("key1", "cont1", 4.1).should be == 9.1
-      @client.hget("key1", "cont1").should be == "9.1"
+      expect(@client.hincrbyfloat("key1", "cont1", 4.1)).to eq(9.1)
+      expect(@client.hget("key1", "cont1")).to eq("9.1")
     end
 
     it "should increment non existing hash keys" do
-      @client.hget("key1", "cont2").should be_nil
-      @client.hincrbyfloat("key1", "cont2", 5.5).should be == 5.5
+      expect(@client.hget("key1", "cont2")).to be_nil
+      expect(@client.hincrbyfloat("key1", "cont2", 5.5)).to eq(5.5)
     end
 
     it "should get all the fields in a hash" do
       @client.hset("key1", "i1", "val1")
       @client.hset("key1", "i2", "val2")
 
-      @client.hkeys("key1").should =~ ["i1", "i2"]
-      @client.hkeys("key2").should be == []
+      expect(@client.hkeys("key1")).to match_array(["i1", "i2"])
+      expect(@client.hkeys("key2")).to eq([])
     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 be == 2
+      expect(@client.hlen("key1")).to eq(2)
+    end
+
+    it "should get the string length of the value associated with field in a hash" do
+      @client.hset("key1", "i1", "val1")
+      expect(@client.hstrlen("key1", "i1")).to eq(4)
+      expect(@client.hstrlen("key1", "nonexistent")).to eq(0)
+      expect(@client.hstrlen("nonexistent", "field")).to eq(0)
     end
 
     it "should get the values of all the given hash fields" do
       @client.hset("key1", "i1", "val1")
       @client.hset("key1", "i2", "val2")
 
-      @client.hmget("key1", "i1", "i2", "i3").should =~ ["val1", "val2", nil]
-      @client.hmget("key1", ["i1", "i2", "i3"]).should =~ ["val1", "val2", nil]
+      expect(@client.hmget("key1", "i1", "i2", "i3")).to match_array(["val1", "val2", nil])
+      expect(@client.hmget("key1", ["i1", "i2", "i3"])).to match_array(["val1", "val2", nil])
 
-      @client.hmget("key2", "i1", "i2").should be == [nil, nil]
+      expect(@client.hmget("key2", "i1", "i2")).to eq([nil, nil])
     end
 
     it "should throw an argument error when you don't ask for any keys" do
-      lambda { @client.hmget("key1") }.should raise_error(Redis::CommandError)
+      expect { @client.hmget("key1") }.to raise_error(Redis::CommandError)
+    end
+
+    it "should throw an argument error when the list of keys you ask for is empty" do
+      expect { @client.hmget("key1", []) }.to raise_error(Redis::CommandError)
     end
 
     it "should reject an empty list of values" do
-      lambda { @client.hmset("key") }.should raise_error(Redis::CommandError)
-      @client.exists("key").should be false
+      expect { @client.hmset("key") }.to raise_error(Redis::CommandError)
+      expect(@client.exists("key")).to be false
     end
 
     it "rejects an insert with a key but no value" do
-      lambda { @client.hmset("key", 'foo') }.should raise_error(Redis::CommandError)
-      lambda { @client.hmset("key", 'foo', 3, 'bar') }.should raise_error(Redis::CommandError)
-      @client.exists("key").should be false
+      expect { @client.hmset("key", 'foo') }.to raise_error(Redis::CommandError)
+      expect { @client.hmset("key", 'foo', 3, 'bar') }.to raise_error(Redis::CommandError)
+      expect(@client.exists("key")).to be false
     end
 
     it "should reject the wrong number of arguments" do
-      lambda { @client.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3") }.should raise_error(Redis::CommandError, "ERR wrong number of arguments for HMSET")
+      expect { @client.hmset("hash", "foo1", "bar1", "foo2", "bar2", "foo3") }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for HMSET")
+    end
+
+    it "should return OK on success" do
+      expect(@client.hmset("key", "k1", "value1")).to eq("OK")
     end
 
     it "should set multiple hash fields to multiple values" do
       @client.hmset("key", "k1", "value1", "k2", "value2")
 
-      @client.hget("key", "k1").should be == "value1"
-      @client.hget("key", "k2").should be == "value2"
+      expect(@client.hget("key", "k1")).to eq("value1")
+      expect(@client.hget("key", "k2")).to eq("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"
+      expect(@client.hget("foo", "k1")).to eq("value1")
+      expect(@client.hget("foo", "k2")).to eq("value2")
     end
 
     it "should set the string value of a hash field" do
-      @client.hset("key1", "k1", "val1").should be == true
-      @client.hset("key1", "k1", "val1").should be == false
+      expect(@client.hset("key1", "k1", "val1")).to eq(true)
+      expect(@client.hset("key1", "k1", "val1")).to eq(false)
 
-      @client.hget("key1", "k1").should be == "val1"
+      expect(@client.hget("key1", "k1")).to eq("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 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"
+      expect(@client.hsetnx("key1", "k1", "value")).to eq(false)
+      expect(@client.hsetnx("key1", "k2", "val2")).to eq(true)
+      expect(@client.hsetnx("key1", :k1, "value")).to eq(false)
+      expect(@client.hsetnx("key1", :k3, "val3")).to eq(true)
+
+      expect(@client.hget("key1", "k1")).to eq("val1")
+      expect(@client.hget("key1", "k2")).to eq("val2")
+      expect(@client.hget("key1", "k3")).to eq("val3")
     end
 
     it "should get all the values in a hash" do
       @client.hset("key1", "k1", "val1")
       @client.hset("key1", "k2", "val2")
 
-      @client.hvals("key1").should =~ ["val1", "val2"]
+      expect(@client.hvals("key1")).to match_array(["val1", "val2"])
     end
 
     it "should accept a list of array pairs as arguments and not throw an invalid argument number error" do
       @client.hmset("key1", [:k1, "val1"], [:k2, "val2"], [:k3, "val3"])
-      @client.hget("key1", :k1).should be == "val1"
-      @client.hget("key1", :k2).should be == "val2"
-      @client.hget("key1", :k3).should be == "val3"
+      expect(@client.hget("key1", :k1)).to eq("val1")
+      expect(@client.hget("key1", :k2)).to eq("val2")
+      expect(@client.hget("key1", :k3)).to eq("val3")
     end
 
     it "should reject a list of arrays that contain an invalid number of arguments" do
@@ -179,17 +205,72 @@ module FakeRedis
 
     it "should convert a integer field name to string for hdel" do
       @client.hset("key1", "1", 1)
-      @client.hdel("key1", 1).should be(1)
+      expect(@client.hdel("key1", 1)).to be(1)
     end
 
     it "should convert a integer field name to string for hexists" do
       @client.hset("key1", "1", 1)
-      @client.hexists("key1", 1).should be true
+      expect(@client.hexists("key1", 1)).to be true
     end
 
     it "should convert a integer field name to string for hincrby" do
       @client.hset("key1", 1, 0)
-      @client.hincrby("key1", 1, 1).should be(1)
+      expect(@client.hincrby("key1", 1, 1)).to be(1)
+    end
+
+    describe "#hscan" do
+      it 'with no arguments and few items, returns all items' do
+        @client.hmset('hash', 'name', 'Jack', 'age', '33')
+        result = @client.hscan('hash', 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.hmset('hash',
+                      'a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'
+        )
+        result = @client.hscan('hash', 0, count: 3)
+        expect(result[0]).to eq('3')
+        expect(result[1]).to eq([
+                                  ['a', '1'],
+                                  ['b', '2'],
+                                  ['c', '3'],
+                                ])
+      end
+
+      it 'returns items starting at the provided cursor' do
+        @client.hmset('hash',
+                      'a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'
+        )
+        result = @client.hscan('hash', 2, count: 3)
+        expect(result[0]).to eq('5')
+        expect(result[1]).to eq([
+                                  ['c', '3'],
+                                  ['d', '4'],
+                                  ['e', '5']
+                                ])
+      end
+
+      it 'with match, returns items matching the given pattern' do
+        @client.hmset('hash',
+                      'aa', '1', 'b', '2', 'cc', '3', 'd', '4', 'ee', '5', 'f', '6', 'gg', '7'
+        )
+        result = @client.hscan('hash', 2, count: 3, match: '??')
+        expect(result[0]).to eq('5')
+        expect(result[1]).to eq([
+                                  ['cc', '3'],
+                                  ['ee', '5']
+                                ])
+      end
+
+      it 'returns an empty result if the key is not found' do
+        result = @client.hscan('hash', 0)
+
+        expect(result[0]).to eq('0')
+        expect(result[1]).to eq([])
+      end
     end
   end
 end

data/spec/hyper_log_logs_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+module FakeRedis
+  describe "HyperLogLogsMethods" do
+    let(:redis) { Redis.new }
+
+    it "should add item to hyperloglog" do
+      expect(redis.pfadd("hll", "val")).to eq(true)
+      expect(redis.pfcount("hll")).to eq(1)
+    end
+
+    it "should not add duplicated item to hyperloglog" do
+      redis.pfadd("hll", "val")
+      expect(redis.pfadd("hll", "val")).to eq(false)
+      expect(redis.pfcount("hll")).to eq(1)
+    end
+
+    it "should not add multiple items to hyperloglog" do
+      expect(redis.pfadd("hll", ["val1", "val2"])).to eq(true)
+      expect(redis.pfcount("hll")).to eq(2)
+    end
+
+    it "should return zero as cardinality for nonexistent key" do
+      expect(redis.pfcount("nonexistent")).to eq(0)
+    end
+
+    it "should return cardinality of union of hyperloglogs" do
+      redis.pfadd("hll1", ["val1", "val2"])
+      redis.pfadd("hll2", ["val2", "val3"])
+      expect(redis.pfcount("hll1", "hll2")).to eq(3)
+    end
+
+    it "should error if an empty list of keys is given" do
+      expect { redis.pfcount([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'pfcount' command")
+    end
+
+    it "should merge hyperloglogs" do
+      redis.pfadd("hll1", ["val1", "val2"])
+      redis.pfadd("hll2", ["val2", "val3"])
+      expect(redis.pfmerge("hll3", "hll1", "hll2")).to eq(true)
+      expect(redis.pfcount("hll3")).to eq(3)
+    end
+
+    it "should merge nonexistent hyperloglogs with others" do
+      redis.pfadd("hll1", "val")
+      expect(redis.pfmerge("hll3", "hll1", "nonexistent")).to eq(true)
+      expect(redis.pfcount("hll3")).to eq(1)
+    end
+  end
+end

data/spec/keys_spec.rb

@@ -7,56 +7,89 @@ module FakeRedis
       @client = Redis.new
     end
 
-    it "should delete a key" do
-      @client.set("key1", "1")
-      @client.set("key2", "2")
-      @client.del("key1", "key2")
+    [:del, :unlink].each do |command|
+      it "should #{command} a key" do
+        @client.set("key1", "1")
+        @client.set("key2", "2")
+        @client.public_send(command, "key1", "key2")
 
-      @client.get("key1").should be == nil
-    end
+        expect(@client.get("key1")).to eq(nil)
+      end
 
-    it "should delete multiple keys" do
-      @client.set("key1", "1")
-      @client.set("key2", "2")
-      @client.del(["key1", "key2"])
+      it "should #{command} multiple keys" do
+        @client.set("key1", "1")
+        @client.set("key2", "2")
+        @client.public_send(command, ["key1", "key2"])
 
-      @client.get("key1").should be == nil
-      @client.get("key2").should be == nil
+        expect(@client.get("key1")).to eq(nil)
+        expect(@client.get("key2")).to eq(nil)
+      end
+
+      it "should return the number of '#{command}'ed keys" do
+        @client.set("key1", "1")
+        expect(@client.public_send(command, ["key1", "key2"])).to eq(1)
+      end
+
+      it "should error '#{command}'ing no keys" do
+        expect { @client.public_send(command) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for '#{command}' command")
+        expect { @client.public_send(command, []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for '#{command}' command")
+      end
+    end
+
+    it "should return true when setnx keys that don't exist" do
+      expect(@client.setnx("key1", "1")).to eq(true)
     end
 
-    it "should error deleting no keys" do
-      lambda { @client.del }.should raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
-      lambda { @client.del [] }.should raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
+    it "should return false when setnx keys exist" do
+      @client.set("key1", "1")
+      expect(@client.setnx("key1", "1")).to eq(false)
     end
 
     it "should return true when setting expires on keys that exist" do
       @client.set("key1", "1")
-      @client.expire("key1", 1).should == true
+      expect(@client.expire("key1", 1)).to eq(true)
+    end
+
+    it "should return true when setting pexpires on keys that exist" do
+      @client.set("key1", "1")
+      expect(@client.pexpire("key1", 1)).to eq(true)
     end
 
     it "should return false when attempting to set expires on a key that does not exist" do
-      @client.expire("key1", 1).should == false
+      expect(@client.expire("key1", 1)).to eq(false)
+    end
+
+    it "should return false when attempting to set pexpires on a key that does not exist" do
+      expect(@client.pexpire("key1", 1)).to eq(false)
     end
 
     it "should determine if a key exists" do
       @client.set("key1", "1")
 
-      @client.exists("key1").should be == true
-      @client.exists("key2").should be == false
+      expect(@client.exists("key1")).to eq(true)
+      expect(@client.exists("key2")).to eq(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 be == 1
+      expect(@client.ttl("key1")).to eq(1)
+    end
+
+    it "should set a key's time to live in miliseconds" do
+      allow(Time).to receive(:now).and_return(1000)
+      @client.set("key1", "1")
+      @client.pexpire("key1", 2200)
+      expect(@client.pttl("key1")).to be_within(0.1).of(2200)
+      allow(Time).to receive(:now).and_call_original
     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 be == 2
+      expect(@client.ttl("key1")).to eq(2)
     end
 
     it "should not have an expiration after re-set" do
@@ -64,21 +97,21 @@ module FakeRedis
       @client.expireat("key1", Time.now.to_i + 2)
       @client.set("key1", "1")
 
-      @client.ttl("key1").should be == -1
+      expect(@client.ttl("key1")).to eq(-1)
     end
 
     it "should not have a ttl if expired (and thus key does not exist)" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.ttl("key1").should be == -2
+      expect(@client.ttl("key1")).to eq(-2)
     end
 
     it "should not find a key if expired" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.get("key1").should be_nil
+      expect(@client.get("key1")).to be_nil
     end
 
     it "should not find multiple keys if expired" do
@@ -86,7 +119,7 @@ module FakeRedis
       @client.set("key2", "2")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.mget("key1", "key2").should be == [nil, "2"]
+      expect(@client.mget("key1", "key2")).to eq([nil, "2"])
     end
 
     it "should only find keys that aren't expired" do
@@ -94,14 +127,21 @@ module FakeRedis
       @client.set("key2", "2")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.keys.should be == ["key2"]
+      expect(@client.keys).to eq(["key2"])
     end
 
     it "should not exist if expired" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.exists("key1").should be false
+      expect(@client.exists("key1")).to be false
+    end
+
+    it "should get integer and string keys" do
+      @client.set("key1", "1")
+      @client.set(2, "2")
+
+      expect(@client.mget("key1", 2)).to eq(["1", "2"])
     end
 
     it "should find all keys matching the given pattern" do
@@ -113,32 +153,32 @@ module FakeRedis
 
       @client.mset("database", 1, "above", 2, "suitability", 3, "able", 4)
 
-      @client.keys("key:*").should =~ ["key:a", "key:b", "key:c"]
-      @client.keys("ab*").should =~ ["above", "able"]
+      expect(@client.keys("key:*")).to match_array(["key:a", "key:b", "key:c"])
+      expect(@client.keys("ab*")).to match_array(["above", "able"])
     end
 
     it "should remove the expiration from a key" do
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i + 1)
-      @client.persist("key1").should be == true
-      @client.persist("key1").should be == false
+      expect(@client.persist("key1")).to eq(true)
+      expect(@client.persist("key1")).to eq(false)
 
-      @client.ttl("key1").should be == -1
+      expect(@client.ttl("key1")).to eq(-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 be == true
+      expect(["key1", "key2"].include?(@client.randomkey)).to eq(true)
     end
 
     it "should rename a key" do
       @client.set("key1", "2")
       @client.rename("key1", "key2")
 
-      @client.get("key1").should be == nil
-      @client.get("key2").should be == "2"
+      expect(@client.get("key1")).to eq(nil)
+      expect(@client.get("key2")).to eq("2")
     end
 
     it "should rename a key, only if new key does not exist" do
@@ -148,100 +188,100 @@ module FakeRedis
       @client.renamenx("key1", "key2")
       @client.renamenx("key3", "key4")
 
-      @client.get("key1").should be == "1"
-      @client.get("key2").should be == "2"
-      @client.get("key3").should be == nil
-      @client.get("key4").should be == "3"
+      expect(@client.get("key1")).to eq("1")
+      expect(@client.get("key2")).to eq("2")
+      expect(@client.get("key3")).to eq(nil)
+      expect(@client.get("key4")).to eq("3")
     end
 
     it "should determine the type stored at key" do
       # Non-existing key
-      @client.type("key0").should be == "none"
+      expect(@client.type("key0")).to eq("none")
 
       # String
       @client.set("key1", "1")
-      @client.type("key1").should be == "string"
+      expect(@client.type("key1")).to eq("string")
 
       # List
       @client.lpush("key2", "1")
-      @client.type("key2").should be == "list"
+      expect(@client.type("key2")).to eq("list")
 
       # Set
       @client.sadd("key3", "1")
-      @client.type("key3").should be == "set"
+      expect(@client.type("key3")).to eq("set")
 
       # Sorted Set
       @client.zadd("key4", 1.0, "1")
-      @client.type("key4").should be == "zset"
+      expect(@client.type("key4")).to eq("zset")
 
       # Hash
       @client.hset("key5", "a", "1")
-      @client.type("key5").should be == "hash"
+      expect(@client.type("key5")).to eq("hash")
     end
 
     it "should convert the value into a string before storing" do
       @client.set("key1", 1)
-      @client.get("key1").should be == "1"
+      expect(@client.get("key1")).to eq("1")
 
       @client.setex("key2", 30, 1)
-      @client.get("key2").should be == "1"
+      expect(@client.get("key2")).to eq("1")
 
       @client.getset("key3", 1)
-      @client.get("key3").should be == "1"
+      expect(@client.get("key3")).to eq("1")
     end
 
     it "should return 'OK' for the setex command" do
-      @client.setex("key4", 30, 1).should be == "OK"
+      expect(@client.setex("key4", 30, 1)).to eq("OK")
     end
 
     it "should convert the key into a string before storing" do
       @client.set(123, "foo")
-      @client.keys.should include("123")
-      @client.get("123").should be == "foo"
+      expect(@client.keys).to include("123")
+      expect(@client.get("123")).to eq("foo")
 
       @client.setex(456, 30, "foo")
-      @client.keys.should include("456")
-      @client.get("456").should be == "foo"
+      expect(@client.keys).to include("456")
+      expect(@client.get("456")).to eq("foo")
 
       @client.getset(789, "foo")
-      @client.keys.should include("789")
-      @client.get("789").should be == "foo"
+      expect(@client.keys).to include("789")
+      expect(@client.get("789")).to eq("foo")
     end
 
     it "should only operate against keys containing string values" do
       @client.sadd("key1", "one")
-      lambda { @client.get("key1") }.should raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
-      lambda { @client.getset("key1", 1) }.should raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
+      expect { @client.get("key1") }.to raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
+      expect { @client.getset("key1", 1) }.to raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
 
       @client.hset("key2", "one", "two")
-      lambda { @client.get("key2") }.should raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
-      lambda { @client.getset("key2", 1) }.should raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
+      expect { @client.get("key2") }.to raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
+      expect { @client.getset("key2", 1) }.to raise_error(Redis::CommandError, "WRONGTYPE Operation against a key holding the wrong kind of value")
     end
 
     it "should move a key from one database to another successfully" do
       @client.select(0)
       @client.set("key1", "1")
 
-      @client.move("key1", 1).should be == true
+      expect(@client.move("key1", 1)).to eq(true)
 
       @client.select(0)
-      @client.get("key1").should be_nil
+      expect(@client.get("key1")).to be_nil
 
       @client.select(1)
-      @client.get("key1").should be == "1"
+      expect(@client.get("key1")).to eq("1")
     end
 
     it "should fail to move a key that does not exist in the source database" do
       @client.select(0)
-      @client.get("key1").should be_nil
+      expect(@client.get("key1")).to be_nil
 
-      @client.move("key1", 1).should be == false
+      expect(@client.move("key1", 1)).to eq(false)
 
       @client.select(0)
-      @client.get("key1").should be_nil
+      expect(@client.get("key1")).to be_nil
 
       @client.select(1)
-      @client.get("key1").should be_nil
+      expect(@client.get("key1")).to be_nil
     end
 
     it "should fail to move a key that exists in the destination database" do
@@ -252,23 +292,23 @@ module FakeRedis
       @client.set("key1", "2")
 
       @client.select(0)
-      @client.move("key1", 1).should be == false
+      expect(@client.move("key1", 1)).to eq(false)
 
       @client.select(0)
-      @client.get("key1").should be == "1"
+      expect(@client.get("key1")).to eq("1")
 
       @client.select(1)
-      @client.get("key1").should be == "2"
+      expect(@client.get("key1")).to eq("2")
     end
 
     it "should fail to move a key to the same database" do
       @client.select(0)
       @client.set("key1", "1")
 
-      lambda { @client.move("key1", 0) }.should raise_error(Redis::CommandError, "ERR source and destination objects are the same")
+      expect { @client.move("key1", 0) }.to raise_error(Redis::CommandError, "ERR source and destination objects are the same")
 
       @client.select(0)
-      @client.get("key1").should be == "1"
+      expect(@client.get("key1")).to eq("1")
     end
 
     it "should scan all keys in the database" do
@@ -284,8 +324,8 @@ module FakeRedis
         break if cursor == "0"
       }
 
-      all_keys.uniq.size.should == 100
-      all_keys[0].should =~ /key\d+/
+      expect(all_keys.uniq.size).to eq(100)
+      expect(all_keys[0]).to match(/key\d+/)
     end
 
     it "should match keys to a pattern when scanning" do
@@ -304,7 +344,7 @@ module FakeRedis
         break if cursor == "0"
       }
 
-      all_keys.uniq.size.should == 50
+      expect(all_keys.uniq.size).to eq(50)
     end
 
     it "should specify doing more work when scanning" do
@@ -314,23 +354,23 @@ module FakeRedis
 
       cursor, all_keys = @client.scan(cursor, :count => 100)
 
-      cursor.should == "0"
-      all_keys.uniq.size.should == 100
+      expect(cursor).to eq("0")
+      expect(all_keys.uniq.size).to eq(100)
     end
 
     context "with extended options" do
       it "uses ex option to set the expire time, in seconds" do
         ttl = 7
 
-        @client.set("key1", "1", { :ex => ttl }).should == "OK"
-        @client.ttl("key1").should == ttl
+        expect(@client.set("key1", "1", { :ex => ttl })).to eq("OK")
+        expect(@client.ttl("key1")).to eq(ttl)
       end
 
       it "uses px option to set the expire time, in miliseconds" do
         ttl = 7000
 
-        @client.set("key1", "1", { :px => ttl }).should == "OK"
-        @client.ttl("key1").should == (ttl / 1000)
+        expect(@client.set("key1", "1", { :px => ttl })).to eq("OK")
+        expect(@client.ttl("key1")).to eq(ttl / 1000)
       end
 
       # Note that the redis-rb implementation will always give PX last.
@@ -340,30 +380,132 @@ module FakeRedis
         ttl_ex = 10
 
         @client.set("key1", "1", { :px => ttl_px, :ex => ttl_ex })
-        @client.ttl("key1").should == (ttl_px / 1000)
+        expect(@client.ttl("key1")).to eq(ttl_px / 1000)
 
         @client.set("key1", "1", { :ex => ttl_ex, :px => ttl_px })
-        @client.ttl("key1").should == (ttl_px / 1000)
+        expect(@client.ttl("key1")).to eq(ttl_px / 1000)
       end
 
       it "uses nx option to only set the key if it does not already exist" do
-        @client.set("key1", "1", { :nx => true }).should == true
-        @client.set("key1", "2", { :nx => true }).should == false
+        expect(@client.set("key1", "1", { :nx => true })).to eq(true)
+        expect(@client.set("key1", "2", { :nx => true })).to eq(false)
 
-        @client.get("key1").should == "1"
+        expect(@client.get("key1")).to eq("1")
       end
 
       it "uses xx option to only set the key if it already exists" do
-        @client.set("key2", "1", { :xx => true }).should == false
+        expect(@client.set("key2", "1", { :xx => true })).to eq(false)
         @client.set("key2", "2")
-        @client.set("key2", "1", { :xx => true }).should == true
+        expect(@client.set("key2", "1", { :xx => true })).to eq(true)
 
-        @client.get("key2").should == "1"
+        expect(@client.get("key2")).to eq("1")
       end
 
       it "does not set the key if both xx and nx option are specified" do
-        @client.set("key2", "1", { :nx => true, :xx => true }).should == false
-        @client.get("key2").should be_nil
+        expect(@client.set("key2", "1", { :nx => true, :xx => true })).to eq(false)
+        expect(@client.get("key2")).to be_nil
+      end
+    end
+
+    describe "#dump" do
+      it "returns nil for unknown key" do
+        expect(@client.exists("key1")).to be false
+        expect(@client.dump("key1")).to be nil
+      end
+
+      it "dumps a single known key successfully" do
+        @client.set("key1", "zomgwtf")
+
+        value = @client.dump("key1")
+        expect(value).not_to eq nil
+        expect(value).to be_a_kind_of(String)
+      end
+
+      it "errors with more than one argument" do
+        expect { @client.dump("key1", "key2") }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "#restore" do
+      it "errors with a missing payload" do
+        expect do
+          @client.restore("key1", 0, nil)
+        end.to raise_error(Redis::CommandError, "ERR DUMP payload version or checksum are wrong")
+      end
+
+      it "errors with an invalid payload" do
+        expect do
+          @client.restore("key1", 0, "zomgwtf not valid")
+        end.to raise_error(Redis::CommandError, "ERR DUMP payload version or checksum are wrong")
+      end
+
+      describe "with a dumped value" do
+        before do
+          @client.set("key1", "original value")
+          @dumped_value = @client.dump("key1")
+
+          @client.del("key1")
+          expect(@client.exists("key1")).to be false
+        end
+
+        it "restores to a new key successfully" do
+          response = @client.restore("key1", 0, @dumped_value)
+          expect(response).to eq "OK"
+        end
+
+        it "errors trying to restore to an existing key" do
+          @client.set("key1", "something else")
+
+          expect do
+            @client.restore("key1", 0, @dumped_value)
+          end.to raise_error(Redis::CommandError, "ERR Target key name is busy.")
+        end
+
+        it "restores successfully with a given expire time" do
+          @client.restore("key2", 2000, @dumped_value)
+
+          expect(@client.ttl("key2")).to eq 2
+        end
+
+        it "restores a list successfully" do
+          @client.lpush("key1", "val1")
+          @client.lpush("key1", "val2")
+
+          expect(@client.type("key1")).to eq "list"
+
+          dumped_value = @client.dump("key1")
+
+          response = @client.restore("key2", 0, dumped_value)
+          expect(response).to eq "OK"
+
+          expect(@client.type("key2")).to eq "list"
+        end
+
+        it "restores a set successfully" do
+          @client.sadd("key1", "val1")
+          @client.sadd("key1", "val2")
+
+          expect(@client.type("key1")).to eq "set"
+
+          dumped_value = @client.dump("key1")
+
+          response = @client.restore("key2", 0, dumped_value)
+          expect(response).to eq "OK"
+
+          expect(@client.type("key2")).to eq "set"
+        end
+      end
+    end
+
+    describe "#psetex" do
+      it "should set a key's time to live in milliseconds" do
+        allow(Time).to receive(:now).and_return(1000)
+        @client.psetex("key", 2200, "value")
+        expect(@client.pttl("key")).to be_within(0.1).of(2200)
+      end
+
+      it "should return 'OK'" do
+        expect(@client.psetex("key", 1000, "value")).to eq("OK")
       end
     end
   end