fakeredis 0.5.0 → 0.8.0

data/spec/lists_spec.rb

@@ -10,41 +10,63 @@ 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 "inserts with case-insensitive position token" do
+      @client.rpush("key1", "v1")
+      @client.rpush("key1", "v4")
+
+      @client.linsert("key1", :BEFORE, "v4", "v2")
+      @client.linsert("key1", "Before", "v4", "v3")
+      @client.linsert("key1", :AFTER, "v4", "v5")
+      @client.linsert("key1", "After", "v5", "v6")
+
+      expect(@client.lrange("key1", 0, -1)).to eq(%w(v1 v2 v3 v4 v5 v6))
+    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 +74,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 +91,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 +100,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 +110,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 +129,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 +139,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 +150,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 +162,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 +181,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,26 +192,43 @@ 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
+    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")
 
-      @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
+
+    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")
 
-        @client.lrange("destination", 0, -1).should be == []
+        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
 
@@ -188,7 +236,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 +244,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,28 +1,101 @@
 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 '#write' do
+    it 'should not send unexpected arguments' do
+      expect { redis.write(['info', 'server']) }.not_to raise_error
+    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
+
+  describe '#client' do
+    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.client(:getname)).to eq nil
+    end
+
+    it 'raises error for other commands' do
+      expect { redis.write([:client, :wrong]) }.to raise_error(Redis::CommandError, "ERR unknown command 'wrong'")
+    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,70 @@ 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
+
+  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