fakeredis 0.7.0 → 0.9.0

data/spec/keys_spec.rb

@@ -7,26 +7,38 @@ 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")
 
-      expect(@client.get("key1")).to eq(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"])
 
-      expect(@client.get("key1")).to eq(nil)
-      expect(@client.get("key2")).to eq(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
     end
 
-    it "should error deleting no keys" do
-      expect { @client.del }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
-      expect { @client.del [] }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
+    it "should return 0 when deleting no keys" do
+      expect(@client.del).to eq(0)
+      expect(@client.del([])).to eq(0)
+    end
+
+    it "should error when unlinking no keys" do
+      expect { @client.unlink }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'unlink' command")
+      expect { @client.unlink([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'unlink' command")
     end
 
     it "should return true when setnx keys that don't exist" do
@@ -56,13 +68,6 @@ module FakeRedis
       expect(@client.pexpire("key1", 1)).to eq(false)
     end
 
-    it "should determine if a key exists" do
-      @client.set("key1", "1")
-
-      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)
@@ -127,7 +132,14 @@ module FakeRedis
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
 
-      expect(@client.exists("key1")).to 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
@@ -348,14 +360,14 @@ module FakeRedis
       it "uses ex option to set the expire time, in seconds" do
         ttl = 7
 
-        expect(@client.set("key1", "1", { :ex => ttl })).to eq("OK")
+        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
 
-        expect(@client.set("key1", "1", { :px => ttl })).to eq("OK")
+        expect(@client.set("key1", "1", px: ttl)).to eq("OK")
         expect(@client.ttl("key1")).to eq(ttl / 1000)
       end
 
@@ -365,37 +377,37 @@ module FakeRedis
         ttl_px = 6000
         ttl_ex = 10
 
-        @client.set("key1", "1", { :px => ttl_px, :ex => ttl_ex })
+        @client.set("key1", "1", px: ttl_px, ex: ttl_ex)
         expect(@client.ttl("key1")).to eq(ttl_px / 1000)
 
-        @client.set("key1", "1", { :ex => ttl_ex, :px => ttl_px })
+        @client.set("key1", "1", ex: ttl_ex, px: ttl_px)
         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
-        expect(@client.set("key1", "1", { :nx => true })).to eq(true)
-        expect(@client.set("key1", "2", { :nx => true })).to eq(false)
+        expect(@client.set("key1", "1", nx: true)).to eq(true)
+        expect(@client.set("key1", "2", nx: true)).to eq(false)
 
         expect(@client.get("key1")).to eq("1")
       end
 
       it "uses xx option to only set the key if it already exists" do
-        expect(@client.set("key2", "1", { :xx => true })).to eq(false)
+        expect(@client.set("key2", "1", xx: true)).to eq(false)
         @client.set("key2", "2")
-        expect(@client.set("key2", "1", { :xx => true })).to eq(true)
+        expect(@client.set("key2", "1", xx: true)).to eq(true)
 
         expect(@client.get("key2")).to eq("1")
       end
 
       it "does not set the key if both xx and nx option are specified" do
-        expect(@client.set("key2", "1", { :nx => true, :xx => true })).to eq(false)
+        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.exists?("key1")).to be false
         expect(@client.dump("key1")).to be nil
       end
 
@@ -431,7 +443,7 @@ module FakeRedis
           @dumped_value = @client.dump("key1")
 
           @client.del("key1")
-          expect(@client.exists("key1")).to be false
+          expect(@client.exists?("key1")).to be false
         end
 
         it "restores to a new key successfully" do
@@ -483,6 +495,52 @@ module FakeRedis
       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 raise an error if a non-integer is provided as the expiration" do
+        expect { @client.psetex("key", 100.5, "value") }.to raise_error(Redis::CommandError)
+      end
+
+      it "should return 'OK'" do
+        expect(@client.psetex("key", 1000, "value")).to eq("OK")
+      end
+    end
+
+    describe "#exists" do
+      it "returns 0 if none of the keys exist" do
+        expect(@client.exists("key1", "key2")).to eq 0
+      end
+
+      it "returns number of the keys that exist" do
+        @client.set("key2", "val2")
+        @client.set("key3", "val3")
+        expect(@client.exists("key1", "key2", "key3")).to eq 2
+      end
+
+      it "keys mentioned and existing multiple times counted multiple times" do
+        @client.set("key2", "val")
+        expect(@client.exists("key2", "key2")).to eq 2
+      end
+    end
+
+    describe "#exists?" do
+      it "should return true if any of the key exists" do
+        @client.set("key1", "1")
+
+        expect(@client.exists?("key1")).to eq(true)
+        expect(@client.exists?("key1", "key2")).to eq(true)
+      end
+
+      it "should return false if none of the key exists" do
+        expect(@client.exists?("key2")).to eq(false)
+        expect(@client.exists?("key2", "key3")).to eq(false)
+      end
+    end
   end
 end
 

data/spec/lists_spec.rb

@@ -119,7 +119,7 @@ module FakeRedis
     end
 
     it "should return 0 if key does not map to a list" do
-      expect(@client.exists("nonexistant")).to eq(false)
+      expect(@client.exists?("nonexistant")).to eq(false)
       expect(@client.lrem("nonexistant", 0, "value")).to eq(0)
     end
 
@@ -129,7 +129,7 @@ module FakeRedis
       @client.lrem("key1", 1, "v1")
       @client.lrem("key1", 1, "v2")
 
-      expect(@client.exists("key1")).to eq(false)
+      expect(@client.exists?("key1")).to eq(false)
     end
 
     it "should set the value of an element in a list by its index" do
@@ -196,7 +196,7 @@ module FakeRedis
       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
+    it "rpoplpush 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")
@@ -207,12 +207,29 @@ module FakeRedis
       expect(@client.lrange("key2", 0, -1)).to eq(["three"])
     end
 
+    it "brpoplpush 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")
+
+      expect(@client.brpoplpush("key1", "key2")).to eq("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")
 
         expect(@client.lrange("destination", 0, -1)).to eq([])
       end
+
+      it 'brpoplpush does not add anything to the destination list' do
+        expect(@client.brpoplpush("source", "destination")).to be_nil
+
+        expect(@client.lrange("destination", 0, -1)).to eq([])
+      end
     end
 
     it "should append a value to a list" do

data/spec/memory_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe FakeRedis do
       cursor = 0
 
       loop do
-        cursor, keys = redis.scan(cursor, match_arguments)
+        cursor, keys = redis.scan(cursor, **match_arguments)
         returned_keys += keys
         break if cursor == '0'
       end
@@ -86,16 +86,12 @@ RSpec.describe FakeRedis do
   end
 
   describe '#client' do
-    it 'returns 1 when command is :setname' do
-      expect(redis.write([:client, :setname])).to eq 1
+    it 'returns OK when command is :setname' do
+      expect(redis.client(:setname, 'my-client-01')).to eq 'OK'
     end
 
     it 'returns nil when command is :getname' do
-      expect(redis.write([:client, :getname])).to eq nil
-    end
-
-    it 'returns true when the comment is :client with an argument' do
-      expect(redis.write([:client, :client, :list])).to eq 1
+      expect(redis.client(:getname)).to eq nil
     end
 
     it 'raises error for other commands' do

data/spec/server_spec.rb

@@ -45,13 +45,13 @@ module FakeRedis
 
         @client.select(0)
         expect(@client.dbsize).to eq(2)
-        expect(@client.exists("key1")).to be true
-        expect(@client.exists("key3")).to be false
+        expect(@client.exists?("key1")).to be true
+        expect(@client.exists?("key3")).to be false
 
         @client.select(1)
         expect(@client.dbsize).to eq(3)
-        expect(@client.exists("key4")).to be true
-        expect(@client.exists("key2")).to be false
+        expect(@client.exists?("key4")).to be true
+        expect(@client.exists?("key2")).to be false
 
         @client.flushall
         expect(@client.dbsize).to eq(0)
@@ -97,4 +97,18 @@ module FakeRedis
       end
     end
   end
+
+  describe 'custom options' do
+    describe 'version' do
+      it 'reports default Redis version when not provided' do
+        client = Redis.new
+        expect(client.info['redis_version']).to eq Redis::Connection::DEFAULT_REDIS_VERSION
+      end
+
+      it 'creates with and reports properly' do
+        client = Redis.new(version: '3.3.0')
+        expect(client.info['redis_version']).to eq '3.3.0'
+      end
+    end
+  end
 end

data/spec/sets_spec.rb

@@ -19,6 +19,7 @@ module FakeRedis
       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")
+      expect { @client.srem("key", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'srem' command")
 
       expect(@client.smembers("key")).to be_empty
     end
@@ -29,6 +30,13 @@ module FakeRedis
       expect(@client.smembers("key")).to match_array(["value", "other", "something", "more", "and", "additional", "values"])
     end
 
+    it "should return the number added to a set when an array is passed in" do
+      expect(@client.sadd("key", %w(value other something more))).to eq(4)
+      expect(@client.sadd("key", %w(more value additional))).to eq(1)
+      expect(@client.sadd("key", %w(additional))).to eq(0)
+      expect(@client.smembers("key")).to match_array(["value", "other", "something", "more", "additional"])
+    end
+
     it "should get the number of members in a set" do
       @client.sadd("key", "val1")
       @client.sadd("key", "val2")
@@ -74,6 +82,19 @@ module FakeRedis
       expect(@client.smembers("new_key")).to match_array(["b", "d"])
     end
 
+    it "should return integer on sdiffstore" do
+      @client.sadd("key1", "a")
+      @client.sadd("key1", "b")
+      @client.sadd("key1", "c")
+      @client.sadd("key1", "d")
+      @client.sadd("key2", "c")
+      @client.sadd("key3", "a")
+      @client.sadd("key3", "c")
+      @client.sadd("key3", "e")
+
+      expect(@client.sdiffstore("key", "key1", "key2", "key3")).to eq(2)
+    end
+
     it "should intersect multiple sets" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
@@ -187,7 +208,7 @@ module FakeRedis
       @client.srem("key1", "b")
       @client.srem("key1", "a")
 
-      expect(@client.exists("key1")).to eq(false)
+      expect(@client.exists?("key1")).to eq(false)
     end
 
     it "should add multiple sets" do
@@ -242,7 +263,7 @@ module FakeRedis
         it 'is an array of one random element from the set' do
           random_elements = @client.srandmember("key1", 1)
 
-          expect([['a'], ['b'], ['c']].include?(@client.srandmember("key1", 1))).to be true
+          expect([['a'], ['b'], ['c']].include?(random_elements)).to be true
         end
       end
 

data/spec/sorted_sets_spec.rb

@@ -100,7 +100,35 @@ module FakeRedis
     it "should remove sorted set's key when it is empty" do
       @client.zadd("key", 1, "val")
       @client.zrem("key", "val")
-      expect(@client.exists("key")).to eq(false)
+      expect(@client.exists?("key")).to eq(false)
+    end
+
+    it "should pop members with the highest scores from sorted set" do
+      @client.zadd("key", [1, "val1", 2, "val2", 3, "val3"])
+      expect(@client.zpopmax("key")).to eq(["val3", 3.0])
+      expect(@client.zpopmax("key", 3)).to eq([["val2", 2.0], ["val1", 1.0]])
+      expect(@client.zpopmax("nonexistent")).to eq(nil)
+    end
+
+    it "should pop members with the lowest scores from sorted set" do
+      @client.zadd("key", [1, "val1", 2, "val2", 3, "val3"])
+      expect(@client.zpopmin("key")).to eq(["val1", 1.0])
+      expect(@client.zpopmin("key", 3)).to eq([["val2", 2.0], ["val3", 3.0]])
+      expect(@client.zpopmin("nonexistent")).to eq(nil)
+    end
+
+    it "should pop members with the highest score from first sorted set that is non-empty" do
+      @client.zadd("key1", [1, "val1", 2, "val2"])
+      @client.zadd("key2", [3, "val3"])
+      expect(@client.bzpopmax("nonexistent", "key1", "key2", 0)).to eq(["key1", "val2", 2.0])
+      expect(@client.bzpopmax("nonexistent")).to eq(nil)
+    end
+
+    it "should pop members with the lowest score from first sorted set that is non-empty" do
+      @client.zadd("key1", [1, "val1", 2, "val2"])
+      @client.zadd("key2", [3, "val3"])
+      expect(@client.bzpopmin("nonexistent", "key1", "key2", 0)).to eq(["key1", "val1", 1.0])
+      expect(@client.bzpopmin("nonexistent")).to eq(nil)
     end
 
     it "should get the number of members in a sorted set" do
@@ -147,6 +175,7 @@ module FakeRedis
 
       expect(@client.zrange("key", 0, -1)).to eq(["one", "two", "three"])
       expect(@client.zrange("key", 1, 2)).to eq(["two", "three"])
+      expect(@client.zrange("key", -50, -2)).to eq(["one", "two"])
       expect(@client.zrange("key", 0, -1, :withscores => true)).to eq([["one", 1], ["two", 2], ["three", 3]])
       expect(@client.zrange("key", 1, 2, :with_scores => true)).to eq([["two", 2], ["three", 3]])
     end
@@ -574,7 +603,7 @@ module FakeRedis
         expect(ranged).to eq %w(c b)
       end
 
-      it "should return empty array if key is not exist" do
+      it "should return empty array if key does not exist" do
         ranged = @client.zrevrangebylex "puppies", "+", "-"
         expect(ranged).to be_empty
       end
@@ -590,5 +619,154 @@ module FakeRedis
         expect(ranged).to eq %w(d c b)
       end
     end
+
+    describe "#zadd" do
+      context "with {incr: true}" do
+        before { @client.zadd("key", 1, "existing") }
+        it "should increment the element's score with the provided value" do
+          @client.zadd("key", 99, "existing", incr: true)
+          expect(@client.zscore("key", "existing")).to eq(100.0)
+
+          @client.zadd("key", 2, "new", incr: true)
+          expect(@client.zscore("key", "new")).to eq(2.0)
+        end
+
+        it "should error when trying to add multiple increment-element pairs" do
+          expect {
+            @client.zadd("key", [1, "member1", 2, "member2"], incr: true)
+          }.to raise_error(Redis::CommandError, "ERR INCR option supports a single increment-element pair")
+        end
+      end
+
+      context "with {nx: true}" do
+        before { @client.zadd("key", [1, "existing1", 2, "existing2"]) }
+        it "should add new elements but not update the scores of existing elements" do
+          @client.zadd("key", [101, "existing1", 3, "new"], nx: true)
+
+          expect(@client.zscore("key", "existing1")).to eq(1.0)
+          expect(@client.zscore("key", "new")).to eq(3.0)
+
+          @client.zadd("key", 102, "existing2", nx: true)
+          expect(@client.zscore("key", "existing2")).to eq(2.0)
+        end
+      end
+
+      context "with {xx: true}" do
+        before { @client.zadd("key", 1, "existing") }
+        it "should not add new elements" do
+          expect(@client.zadd("key", 1, "new1", xx: true)).to eq(false)
+          expect(@client.zscore("key", "new1")).to be_nil
+
+          expect(@client.zadd("key", [11, "existing", 2, "new2"], xx: true)).to eq(0)
+          expect(@client.zscore("key", "existing")).to eq(11.0)
+          expect(@client.zscore("key", "new2")).to be_nil
+        end
+      end
+
+      context "with {ch: true}" do
+        it "should return the number of new elements added plus the number of existing elements for which the score was updated" do
+          expect(@client.zadd("key", 1, "first", ch: true)).to eq(true)
+
+          expect(@client.zadd("key", [1, "first", 2, "second"], ch: true)).to eq(1.0)
+          expect(@client.zadd("key", [11, "first", 2, "second"], ch: true)).to eq(1.0)
+          expect(@client.zadd("key", [99, "first", 99, "second"], ch: true)).to eq(2.0)
+          expect(@client.zadd("key", [111, "first", 22, "second", 3, "third"], ch: true)).to eq(3.0)
+        end
+      end
+
+      context "with {nx: true, xx: true}" do
+        it "should error" do
+          expect{
+            @client.zadd("key", 1, "value", nx: true, xx: true)
+          }.to raise_error(Redis::CommandError, "ERR XX and NX options at the same time are not compatible")
+        end
+      end
+
+      context "with {nx: true, incr: true}" do
+        let(:options) { {nx: true, incr: true} }
+        it "should increment to the provided score only if the element is new and return the element's score" do
+          expect(@client.zadd("key", 1, "first", **options)).to eq(1.0)
+          expect(@client.zscore("key", "first")).to eq(1.0)
+
+          expect(@client.zadd("key", 2, "second", **options)).to eq(2.0)
+          expect(@client.zscore("key", "second")).to eq(2.0)
+
+          expect(@client.zadd("key", 99, "first", **options)).to be_nil
+          expect(@client.zscore("key", "first")).to eq(1.0)
+        end
+      end
+
+      context "with {nx: true, ch: true}" do
+        let(:options) { {nx: true, ch: true} }
+        it "should add only new elements, not update existing elements, and return the number of added elements" do
+          expect(@client.zadd("key", 1, "first", **options)).to eq(true)
+          expect(@client.zadd("key", 1, "first", **options)).to eq(false)
+
+          # add two new elements
+          expect(@client.zadd("key", [99, "first", 2, "second", 3, "third"], **options)).to eq(2)
+          expect(@client.zscore("key", "first")).to eq(1.0)
+        end
+      end
+
+      context "with {nx: true, incr: true, ch: true}" do
+        let(:options) { {nx: true, incr: true, ch: true} }
+
+        it "should add only new elements" do
+          expect(@client.zadd("key", 1, "first", **options)).to eq(1.0)
+          expect(@client.zadd("key", 99, "first", **options)).to be_nil
+          expect(@client.zscore("key", "first")).to eq(1.0)
+        end
+
+        # when INCR is present, return value is always the new score of member
+        it "should return the score of the new member" do
+          expect(@client.zadd("key", 2, "second", **options)).to eq(2.0)
+        end
+
+        it "should return nil when the member already exists" do
+          @client.zadd("key", 1, "first")
+          expect(@client.zadd("key", 99, "first", **options)).to be_nil
+        end
+      end
+
+      context "with {xx: true, incr: true}" do
+        let(:options) { {xx: true, incr: true} }
+        before { @client.zadd("key", 1, "existing") }
+
+        it "should return nil if the member does not already exist" do
+          expect(@client.zadd("key", 1, "new1", **options)).to be_nil
+          expect(@client.zscore("key", "new1")).to be_nil
+        end
+
+        it "should increment only existing elements" do
+          expect(@client.zadd("key", [11, "existing"], **options)).to eq(12.0)
+          expect(@client.zscore("key", "existing")).to eq(12.0)
+        end
+      end
+
+      context "with {xx: true, ch: true}" do
+        let(:options) { {xx: true, ch: true} }
+        it "should return the number of updated elements and not add new members" do
+          @client.zadd("key", 1, "first")
+
+          expect(@client.zadd("key", 99, "first", **options)).to eq(true)
+          expect(@client.zadd("key", [100, "first", 2, "second"], **options)).to eq(1.0)
+          expect(@client.zscore("key", "second")).to be_nil
+        end
+      end
+
+      context "with {xx: true, incr: true, ch: true}" do
+        let(:options) { {xx: true, incr: true, ch: true} }
+        before { @client.zadd("key", 1, "existing") }
+
+        # when INCR is present, return value is always the new score of member
+        it "should return the new score of the inserted member" do
+          expect(@client.zadd("key", 2, "existing", **options)).to eq(3.0)
+        end
+
+        it "should increment only existing elements" do
+          expect(@client.zadd("key", 1, "new", **options)).to be_nil
+        end
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,31 +1,17 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
-require 'fakeredis'
-require "fakeredis/rspec"
 
-require "support/shared_examples/sortable"
-require "support/shared_examples/bitwise_operation"
+$LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
+$LOAD_PATH.unshift(File.join(__dir__, '..'))
+Dir['spec/support/**/*.rb'].each { |f| require f }
 
+require 'fakeredis'
+require "fakeredis/rspec"
 
 RSpec.configure do |config|
   # Enable memory adapter
   config.before(:each) { FakeRedis.enable }
 
-  # replaces -b -fdoc --color in .rspec
-  config.color = true
-  config.default_formatter = "doc"
   config.backtrace_exclusion_patterns = []
-
-  config.mock_with :rspec do |c|
-    # TODO: upgrade should syntax to expect syntax
-    c.syntax = [:should, :expect]
-  end
-
-  config.expect_with :rspec do |c|
-    # TODO: upgrade should syntax to expect syntax
-    c.syntax = [:should, :expect]
-  end
 end
 
 def fakeredis?