fakeredis 0.5.0 → 0.6.0

data/spec/lists_spec.rb

@@ -10,41 +10,51 @@ module FakeRedis
       @client.lpush("key1", "val1")
       @client.lpush("key1", "val2")
 
-      @client.lindex("key1", 0).should be == "val2"
-      @client.lindex("key1", -1).should be == "val1"
-      @client.lindex("key1", 3).should be == nil
+      expect(@client.lindex("key1", 0)).to eq("val2")
+      expect(@client.lindex("key1", -1)).to eq("val1")
+      expect(@client.lindex("key1", 3)).to eq(nil)
     end
 
     it "should insert an element before or after another element in a list" do
       @client.rpush("key1", "v1")
       @client.rpush("key1", "v3")
       @client.linsert("key1", :before, "v3", "v2")
+      @client.linsert("key1", :after, "v3", 100)
+      @client.linsert("key1", :before, 100, 99)
 
-      @client.lrange("key1", 0, -1).should be == ["v1", "v2", "v3"]
+      expect(@client.lrange("key1", 0, -1)).to eq(["v1", "v2", "v3", "99", "100"])
+    end
+
+    it "should not insert if after/before index not found" do
+      @client.rpush("key", "v1")
+      expect(@client.linsert("key", :before, "unknown", "v2")).to eq(-1)
+      expect(@client.linsert("key", :after, "unknown", "v3")).to eq(-1)
+
+      expect(@client.lrange("key", 0, -1)).to eq(["v1"])
     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 be == ['1', '2', '3']
+      expect(@client.lrange('key1', 0, -1)).to eq(['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 be == ['3', '2', '1']
+      expect(@client.lrange('key1', 0, -1)).to eq(['3', '2', '1'])
     end
 
     it "should error if an invalid where argument is given" do
       @client.rpush("key1", "v1")
       @client.rpush("key1", "v3")
-      lambda { @client.linsert("key1", :invalid, "v3", "v2") }.should raise_error(Redis::CommandError, "ERR syntax error")
+      expect { @client.linsert("key1", :invalid, "v3", "v2") }.to raise_error(Redis::CommandError, "ERR syntax error")
     end
 
     it "should get the length of a list" do
       @client.rpush("key1", "v1")
       @client.rpush("key1", "v2")
 
-      @client.llen("key1").should be == 2
-      @client.llen("key2").should be == 0
+      expect(@client.llen("key1")).to eq(2)
+      expect(@client.llen("key2")).to eq(0)
     end
 
     it "should remove and get the first element in a list" do
@@ -52,15 +62,15 @@ module FakeRedis
       @client.rpush("key1", "v2")
       @client.rpush("key1", "v3")
 
-      @client.lpop("key1").should be == "v1"
-      @client.lrange("key1", 0, -1).should be == ["v2", "v3"]
+      expect(@client.lpop("key1")).to eq("v1")
+      expect(@client.lrange("key1", 0, -1)).to eq(["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 be == ["v1", "v2"]
+      expect(@client.lrange("key1", 0, -1)).to eq(["v1", "v2"])
     end
 
     it "should prepend a value to a list, only if the list exists" do
@@ -69,8 +79,8 @@ module FakeRedis
       @client.lpushx("key1", "v2")
       @client.lpushx("key2", "v3")
 
-      @client.lrange("key1", 0, -1).should be == ["v2", "v1"]
-      @client.llen("key2").should be == 0
+      expect(@client.lrange("key1", 0, -1)).to eq(["v2", "v1"])
+      expect(@client.llen("key2")).to eq(0)
     end
 
     it "should get a range of elements from a list" do
@@ -78,7 +88,8 @@ module FakeRedis
       @client.rpush("key1", "v2")
       @client.rpush("key1", "v3")
 
-      @client.lrange("key1", 1, -1).should be == ["v2", "v3"]
+      expect(@client.lrange("key1", 1, -1)).to eq(["v2", "v3"])
+      expect(@client.lrange("key1", -999, -1)).to eq(["v1", "v2", "v3"])
     end
 
     it "should remove elements from a list" do
@@ -87,10 +98,17 @@ module FakeRedis
       @client.rpush("key1", "v2")
       @client.rpush("key1", "v2")
       @client.rpush("key1", "v1")
+      @client.rpush("key1", 42)
+
+      expect(@client.lrem("key1", 1, "v1")).to eq(1)
+      expect(@client.lrem("key1", -2, "v2")).to eq(2)
+      expect(@client.lrem("key1", 0, 42)).to eq(1)
+      expect(@client.llen("key1")).to eq(2)
+    end
 
-      @client.lrem("key1", 1, "v1").should be == 1
-      @client.lrem("key1", -2, "v2").should be == 2
-      @client.llen("key1").should be == 2
+    it "should return 0 if key does not map to a list" do
+      expect(@client.exists("nonexistant")).to eq(false)
+      expect(@client.lrem("nonexistant", 0, "value")).to eq(0)
     end
 
     it "should remove list's key when list is empty" do
@@ -99,7 +117,7 @@ module FakeRedis
       @client.lrem("key1", 1, "v1")
       @client.lrem("key1", 1, "v2")
 
-      @client.exists("key1").should be == false
+      expect(@client.exists("key1")).to eq(false)
     end
 
     it "should set the value of an element in a list by its index" do
@@ -109,9 +127,10 @@ module FakeRedis
 
       @client.lset("key1", 0, "four")
       @client.lset("key1", -2, "five")
-      @client.lrange("key1", 0, -1).should be == ["four", "five", "three"]
+      @client.lset("key1", 2, 6)
 
-      lambda { @client.lset("key1", 4, "six") }.should raise_error(Redis::CommandError, "ERR index out of range")
+      expect(@client.lrange("key1", 0, -1)).to eq(["four", "five", "6"])
+      expect { @client.lset("key1", 4, "seven") }.to raise_error(Redis::CommandError, "ERR index out of range")
     end
 
     it "should trim a list to the specified range" do
@@ -119,8 +138,8 @@ module FakeRedis
       @client.rpush("key1", "two")
       @client.rpush("key1", "three")
 
-      @client.ltrim("key1", 1, -1).should be == "OK"
-      @client.lrange("key1", 0, -1).should be == ["two", "three"]
+      expect(@client.ltrim("key1", 1, -1)).to eq("OK")
+      expect(@client.lrange("key1", 0, -1)).to eq(["two", "three"])
     end
 
 
@@ -131,7 +150,7 @@ module FakeRedis
         before { @client.ltrim("listOfOne", -5, -1) }
 
         it "returns the unmodified list" do
-          @client.lrange("listOfOne", 0, -1).should be == ["one"]
+          expect(@client.lrange("listOfOne", 0, -1)).to eq(["one"])
         end
       end
     end
@@ -150,7 +169,7 @@ module FakeRedis
         before { @client.ltrim("maxTest", -5, -1) }
 
         it "should trim a list to the specified maximum size" do
-          @client.lrange("maxTest", 0, -1).should be == ["two","three", "four", "five", "six"]
+          expect(@client.lrange("maxTest", 0, -1)).to eq(["two","three", "four", "five", "six"])
         end
       end
     end
@@ -161,8 +180,8 @@ module FakeRedis
       @client.rpush("key1", "two")
       @client.rpush("key1", "three")
 
-      @client.rpop("key1").should be == "three"
-      @client.lrange("key1", 0, -1).should be == ["one", "two"]
+      expect(@client.rpop("key1")).to eq("three")
+      expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
     end
 
     it "should remove the last element in a list, append it to another list and return it" do
@@ -170,17 +189,17 @@ module FakeRedis
       @client.rpush("key1", "two")
       @client.rpush("key1", "three")
 
-      @client.rpoplpush("key1", "key2").should be == "three"
+      expect(@client.rpoplpush("key1", "key2")).to eq("three")
 
-      @client.lrange("key1", 0, -1).should be == ["one", "two"]
-      @client.lrange("key2", 0, -1).should be == ["three"]
+      expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
+      expect(@client.lrange("key2", 0, -1)).to eq(["three"])
     end
 
     context 'when the source list is empty' do
       it 'rpoplpush does not add anything to the destination list' do
         @client.rpoplpush("source", "destination")
 
-        @client.lrange("destination", 0, -1).should be == []
+        expect(@client.lrange("destination", 0, -1)).to eq([])
       end
     end
 
@@ -188,7 +207,7 @@ module FakeRedis
       @client.rpush("key1", "one")
       @client.rpush("key1", "two")
 
-      @client.lrange("key1", 0, -1).should be == ["one", "two"]
+      expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
     end
 
     it "should append a value to a list, only if the list exists" do
@@ -196,8 +215,16 @@ module FakeRedis
       @client.rpushx("key1", "two")
       @client.rpushx("key2", "two")
 
-      @client.lrange("key1", 0, -1).should be == ["one", "two"]
-      @client.lrange("key2", 0, -1).should be == []
+      expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
+      expect(@client.lrange("key2", 0, -1)).to eq([])
+    end
+
+    it 'should not allow pushing empty list of objects' do
+      expect { @client.lpush("key1", []) }.to raise_error(Redis::CommandError, /lpush[^x]/)
+      expect { @client.lpush("key1", 1); @client.lpushx("key1", []) }.to raise_error(Redis::CommandError, /lpushx/)
+
+      expect { @client.rpush("key1", []) }.to raise_error(Redis::CommandError, /rpush[^x]/)
+      expect { @client.rpush("key1", 1); @client.rpushx("key1", []) }.to raise_error(Redis::CommandError, /rpushx/)
     end
   end
 end

data/spec/memory_spec.rb

@@ -1,27 +1,80 @@
 require 'spec_helper'
 
-module FakeRedis
+RSpec.describe FakeRedis do
+  let(:redis) { Redis.new }
+
+  def populate_keys_in_redis(num)
+    num.times do |count|
+      redis.set("key#{count}", count)
+    end
+  end
+
+  describe '#scan' do
+    def result
+      returned_keys = []
+      cursor = 0
+
+      loop do
+        cursor, keys = redis.scan(cursor, match_arguments)
+        returned_keys += keys
+        break if cursor == '0'
+      end
+      returned_keys
+    end
+
+    before do
+      populate_keys_in_redis(11)
+    end
+
+    context('when deleting') do
+      it('preverves cursor') do
+        cursor, keys = redis.scan('0')
+        keys.each { |key| redis.del(key) }
+        _, keys = redis.scan(cursor)
+        expect(keys).to eq(%w(key10))
+      end
+    end
+
+    context 'with one namespace' do
+      let(:match_arguments) { {} }
+
+      it 'returns the expected array of keys' do
+        expect(result).to match_array(redis.keys)
+      end
+    end
+
+    context 'with multiple namespaces' do
+      let(:namespaced_key) { 'test' }
+      let(:match_arguments) { { match: namespaced_key } }
+
+      before { redis.set(namespaced_key, 12) }
+
+      it 'returns the expected array of keys' do
+        expect(result).to match_array([namespaced_key])
+      end
+    end
+  end
+
   describe 'time' do
     before(:each) do
-      @client = Redis.new
-      Time.stub_chain(:now, :to_f).and_return(1397845595.5139461)
+      allow(Time).to receive_message_chain(:now, :to_f).and_return(1397845595.5139461)
     end
 
     it 'is an array' do
-      expect(@client.time).to be_an_instance_of(Array)
+      expect(redis.time).to be_an_instance_of(Array)
     end
 
     it 'has two elements' do
-      expect(@client.time.count).to eql 2
+      expect(redis.time.count).to eql 2
     end
 
     if fakeredis?
       it 'has the current time in seconds' do
-        expect(@client.time.first).to eql 1397845595
+        expect(redis.time.first).to eql 1397845595
       end
 
       it 'has the current leftover microseconds' do
-        expect(@client.time.last).to eql 513946
+        expect(redis.time.last).to eql 513946
       end
     end
   end

data/spec/server_spec.rb

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

data/spec/sets_spec.rb

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