fakeredis 0.5.0 → 0.6.0

data/spec/bitop_command_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe "#bitop" do
+    before(:all) do
+      @client = Redis.new
+    end
+
+    before(:each) do
+      @client.discard rescue nil
+    end
+
+    it 'raises an argument error when passed unsupported operation' do
+      lambda { @client.bitop("meh", "dest1", "key1") }.should raise_error(Redis::CommandError)
+    end
+
+    describe "or" do
+      it_should_behave_like "a bitwise operation", "or"
+
+      it "should apply bitwise or operation" do
+        @client.setbit("key1", 0, 0)
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 2, 1)
+        @client.setbit("key1", 3, 0)
+
+        @client.setbit("key2", 0, 1)
+        @client.setbit("key2", 1, 1)
+        @client.setbit("key2", 2, 0)
+        @client.setbit("key2", 3, 0)
+
+        @client.bitop("or", "dest1", "key1", "key2").should be == 1
+        @client.bitcount("dest1").should be == 3
+        @client.getbit("dest1", 0).should be == 1
+        @client.getbit("dest1", 1).should be == 1
+        @client.getbit("dest1", 2).should be == 1
+        @client.getbit("dest1", 3).should be == 0
+      end
+
+      it "should apply bitwise or operation with empty values" do
+        @client.setbit("key1", 1, 1)
+
+        @client.bitop("or", "dest1", "key1", "nothing_here1", "nothing_here2").should be == 1
+        @client.bitcount("dest1").should be == 1
+        @client.getbit("dest1", 0).should be == 0
+        @client.getbit("dest1", 1).should be == 1
+        @client.getbit("dest1", 2).should be == 0
+      end
+
+      it "should apply bitwise or operation with multiple keys" do
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 3, 1)
+
+        @client.setbit("key2", 5, 1)
+        @client.setbit("key2", 10, 1)
+
+        @client.setbit("key3", 13, 1)
+        @client.setbit("key3", 15, 1)
+
+        @client.bitop("or", "dest1", "key1", "key2", "key3").should be == 2
+        @client.bitcount("dest1").should be == 6
+        @client.getbit("dest1", 1).should be == 1
+        @client.getbit("dest1", 3).should be == 1
+        @client.getbit("dest1", 5).should be == 1
+        @client.getbit("dest1", 10).should be == 1
+        @client.getbit("dest1", 13).should be == 1
+        @client.getbit("dest1", 15).should be == 1
+        @client.getbit("dest1", 2).should be == 0
+        @client.getbit("dest1", 12).should be == 0
+      end
+    end
+
+    describe "and" do
+      it_should_behave_like "a bitwise operation", "and"
+
+      it "should apply bitwise and operation" do
+        @client.setbit("key1", 0, 1)
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 2, 0)
+
+        @client.setbit("key2", 0, 0)
+        @client.setbit("key2", 1, 1)
+        @client.setbit("key2", 2, 1)
+
+        @client.bitop("and", "dest1", "key1", "key2").should be == 1
+        @client.bitcount("dest1").should be == 1
+        @client.getbit("dest1", 0).should be == 0
+        @client.getbit("dest1", 1).should be == 1
+        @client.getbit("dest1", 2).should be == 0
+      end
+
+      it "should apply bitwise and operation with empty values" do
+        @client.setbit("key1", 1, 1)
+
+        @client.bitop("and", "dest1", "key1", "nothing_here").should be == 1
+        @client.bitcount("dest1").should be == 1
+        @client.getbit("dest1", 0).should be == 0
+        @client.getbit("dest1", 1).should be == 1
+        @client.getbit("dest1", 2).should be == 0
+      end
+
+      it "should apply bitwise and operation with multiple keys" do
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 2, 1)
+        @client.setbit("key1", 3, 1)
+        @client.setbit("key1", 4, 1)
+
+        @client.setbit("key2", 2, 1)
+        @client.setbit("key2", 3, 1)
+        @client.setbit("key2", 4, 1)
+        @client.setbit("key2", 5, 1)
+
+        @client.setbit("key3", 2, 1)
+        @client.setbit("key3", 4, 1)
+        @client.setbit("key3", 5, 1)
+        @client.setbit("key3", 6, 1)
+
+        @client.bitop("and", "dest1", "key1", "key2", "key3").should be == 1
+        @client.bitcount("dest1").should be == 2
+        @client.getbit("dest1", 1).should be == 0
+        @client.getbit("dest1", 2).should be == 1
+        @client.getbit("dest1", 3).should be == 0
+        @client.getbit("dest1", 4).should be == 1
+        @client.getbit("dest1", 5).should be == 0
+        @client.getbit("dest1", 6).should be == 0
+      end
+    end
+
+    describe "xor" do
+      it_should_behave_like "a bitwise operation", "xor"
+
+      it "should apply bitwise xor operation" do
+        @client.setbit("key1", 0, 0)
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 2, 0)
+        @client.setbit("key1", 3, 0)
+
+        @client.setbit("key2", 0, 1)
+        @client.setbit("key2", 1, 1)
+        @client.setbit("key2", 2, 1)
+        @client.setbit("key2", 3, 0)
+
+        @client.bitop("xor", "dest1", "key1", "key2").should be == 1
+        @client.bitcount("dest1").should be == 2
+        @client.getbit("dest1", 0).should be == 1
+        @client.getbit("dest1", 1).should be == 0
+        @client.getbit("dest1", 2).should be == 1
+        @client.getbit("dest1", 3).should be == 0
+      end
+
+      it "should apply bitwise xor operation with empty values" do
+        @client.setbit("key1", 1, 1)
+
+        @client.bitop("xor", "dest1", "key1", "nothing_here1", "nothing_here2").should be == 1
+        @client.bitcount("dest1").should be == 1
+        @client.getbit("dest1", 0).should be == 0
+        @client.getbit("dest1", 1).should be == 1
+        @client.getbit("dest1", 2).should be == 0
+      end
+
+      it "should apply bitwise xor operation with multiple keys" do
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 3, 1)
+        @client.setbit("key1", 5, 1)
+        @client.setbit("key1", 6, 1)
+
+        @client.setbit("key2", 2, 1)
+        @client.setbit("key2", 3, 1)
+        @client.setbit("key2", 4, 1)
+        @client.setbit("key2", 6, 1)
+
+        @client.bitop("xor", "dest1", "key1", "key2").should be == 1
+        @client.bitcount("dest1").should be == 4
+        @client.getbit("dest1", 1).should be == 1
+        @client.getbit("dest1", 2).should be == 1
+        @client.getbit("dest1", 3).should be == 0
+        @client.getbit("dest1", 4).should be == 1
+        @client.getbit("dest1", 5).should be == 1
+        @client.getbit("dest1", 6).should be == 0
+      end
+    end
+
+    describe "not" do
+      it 'raises an argument error when not passed any keys' do
+        lambda { @client.bitop("not", "destkey") }.should raise_error(Redis::CommandError)
+      end
+
+      it 'raises an argument error when not passed too many keys' do
+        lambda { @client.bitop("not", "destkey", "key1", "key2") }.should raise_error(Redis::CommandError)
+      end
+
+      it "should apply bitwise negation operation" do
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 3, 1)
+        @client.setbit("key1", 5, 1)
+
+        @client.bitop("not", "dest1", "key1").should be == 1
+        @client.bitcount("dest1").should be == 5
+        @client.getbit("dest1", 0).should be == 1
+        @client.getbit("dest1", 1).should be == 0
+        @client.getbit("dest1", 2).should be == 1
+        @client.getbit("dest1", 3).should be == 0
+        @client.getbit("dest1", 4).should be == 1
+        @client.getbit("dest1", 5).should be == 0
+        @client.getbit("dest1", 6).should be == 1
+        @client.getbit("dest1", 7).should be == 1
+      end
+    end
+  end
+end

data/spec/compatibility_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module FakeRedis
   describe "Compatibility" do
     it "should be accessible through FakeRedis::Redis" do
-      lambda { FakeRedis::Redis.new }.should_not raise_error
+      expect { FakeRedis::Redis.new }.not_to raise_error
     end
   end
 end

data/spec/connection_spec.rb

@@ -9,7 +9,7 @@ module FakeRedis
 
   if fakeredis?
     it "should authenticate to the server" do
-      @client.auth("pass").should be == "OK"
+      expect(@client.auth("pass")).to eq("OK")
     end
 
     it "should re-use the same instance with the same host & port" do
@@ -18,40 +18,40 @@ module FakeRedis
       @client3 = Redis.new(:host => "localhost", :port => 5678)
 
       @client1.set("key1", "1")
-      @client2.get("key1").should be == "1"
-      @client3.get("key1").should be_nil
+      expect(@client2.get("key1")).to eq("1")
+      expect(@client3.get("key1")).to be_nil
 
       @client2.set("key2", "2")
-      @client1.get("key2").should be == "2"
-      @client3.get("key2").should be_nil
+      expect(@client1.get("key2")).to eq("2")
+      expect(@client3.get("key2")).to be_nil
 
       @client3.set("key3", "3")
-      @client1.get("key3").should be_nil
-      @client2.get("key3").should be_nil
+      expect(@client1.get("key3")).to be_nil
+      expect(@client2.get("key3")).to be_nil
 
-      @client1.dbsize.should be == 2
-      @client2.dbsize.should be == 2
-      @client3.dbsize.should be == 1
+      expect(@client1.dbsize).to eq(2)
+      expect(@client2.dbsize).to eq(2)
+      expect(@client3.dbsize).to eq(1)
     end
 
     it "should connect to a specific database" do
       @client1 = Redis.new(:host => "localhost", :port => 1234, :db => 0)
       @client1.set("key1", "1")
       @client1.select(0)
-      @client1.get("key1").should be == "1"
+      expect(@client1.get("key1")).to eq("1")
 
       @client2 = Redis.new(:host => "localhost", :port => 1234, :db => 1)
       @client2.set("key1", "1")
       @client2.select(1)
-      @client2.get("key1").should == "1"
+      expect(@client2.get("key1")).to eq("1")
     end
 
     it "should not error with shutdown" do
-      lambda { @client.shutdown }.should_not raise_error
+      expect { @client.shutdown }.not_to raise_error
     end
 
     it "should not error with quit" do
-      lambda { @client.quit }.should_not raise_error
+      expect { @client.quit }.not_to raise_error
     end
   end
 
@@ -60,26 +60,26 @@ module FakeRedis
       @client2 = Redis.new(:host => "localhost", :port => 6379, :db => 2)
 
       @client1.set("key1", "one")
-      @client1.get("key1").should be == "one"
+      expect(@client1.get("key1")).to eq("one")
 
       @client2.set("key2", "two")
-      @client2.get("key2").should be == "two"
+      expect(@client2.get("key2")).to eq("two")
 
-      @client1.get("key1").should be == "one"
+      expect(@client1.get("key1")).to eq("one")
     end
 
     it "should not error with a disconnected client" do
       @client1 = Redis.new
       @client1.client.disconnect
-      @client1.get("key1").should be_nil
+      expect(@client1.get("key1")).to be_nil
     end
 
     it "should echo the given string" do
-      @client.echo("something").should == "something"
+      expect(@client.echo("something")).to eq("something")
     end
 
     it "should ping the server" do
-      @client.ping.should == "PONG"
+      expect(@client.ping).to eq("PONG")
     end
   end
 end

data/spec/hashes_spec.rb

@@ -9,168 +9,179 @@ 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 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 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 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 +190,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