kuende-fakeredis 0.6.0

data/spec/lists_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe "ListsMethods" do
+    before(:each) do
+      @client = Redis.new
+    end
+
+    it "should get an element from a list by its index" do
+      @client.lpush("key1", "val1")
+      @client.lpush("key1", "val2")
+
+      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)
+
+      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])
+      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])
+      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")
+      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")
+
+      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
+      @client.rpush("key1", "v1")
+      @client.rpush("key1", "v2")
+      @client.rpush("key1", "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")
+
+      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
+      @client.lpush("key1", "v1")
+
+      @client.lpushx("key1", "v2")
+      @client.lpushx("key2", "v3")
+
+      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
+      @client.rpush("key1", "v1")
+      @client.rpush("key1", "v2")
+      @client.rpush("key1", "v3")
+
+      expect(@client.lrange("key1", 1, -1)).to eq(["v2", "v3"])
+    end
+
+    it "should remove elements from a list" do
+      @client.rpush("key1", "v1")
+      @client.rpush("key1", "v2")
+      @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
+
+    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
+      @client.rpush("key1", "v1")
+      @client.rpush("key1", "v2")
+      @client.lrem("key1", 1, "v1")
+      @client.lrem("key1", 1, "v2")
+
+      expect(@client.exists("key1")).to eq(false)
+    end
+
+    it "should set the value of an element in a list by its index" do
+      @client.rpush("key1", "one")
+      @client.rpush("key1", "two")
+      @client.rpush("key1", "three")
+
+      @client.lset("key1", 0, "four")
+      @client.lset("key1", -2, "five")
+      @client.lset("key1", 2, 6)
+
+      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
+      @client.rpush("key1", "one")
+      @client.rpush("key1", "two")
+      @client.rpush("key1", "three")
+
+      expect(@client.ltrim("key1", 1, -1)).to eq("OK")
+      expect(@client.lrange("key1", 0, -1)).to eq(["two", "three"])
+    end
+
+
+    context "when the list is smaller than the requested trim" do
+      before { @client.rpush("listOfOne", "one") }
+
+      context "trimming with a negative start (specifying a max)" do
+        before { @client.ltrim("listOfOne", -5, -1) }
+
+        it "returns the unmodified list" do
+          expect(@client.lrange("listOfOne", 0, -1)).to eq(["one"])
+        end
+      end
+    end
+
+    context "when the list is larger than the requested trim" do
+      before do
+        @client.rpush("maxTest", "one")
+        @client.rpush("maxTest", "two")
+        @client.rpush("maxTest", "three")
+        @client.rpush("maxTest", "four")
+        @client.rpush("maxTest", "five")
+        @client.rpush("maxTest", "six")
+      end
+
+      context "trimming with a negative start (specifying a max)" do
+        before { @client.ltrim("maxTest", -5, -1) }
+
+        it "should trim a list to the specified maximum size" do
+          expect(@client.lrange("maxTest", 0, -1)).to eq(["two","three", "four", "five", "six"])
+        end
+      end
+    end
+
+
+    it "should remove and return the last element in a list" do
+      @client.rpush("key1", "one")
+      @client.rpush("key1", "two")
+      @client.rpush("key1", "three")
+
+      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
+      @client.rpush("key1", "one")
+      @client.rpush("key1", "two")
+      @client.rpush("key1", "three")
+
+      expect(@client.rpoplpush("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
+    end
+
+    it "should append a value to a list" do
+      @client.rpush("key1", "one")
+      @client.rpush("key1", "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
+      @client.rpush("key1", "one")
+      @client.rpushx("key1", "two")
+      @client.rpushx("key2", "two")
+
+      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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe 'time' do
+    before(:each) do
+      @client = Redis.new
+      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)
+    end
+
+    it 'has two elements' do
+      expect(@client.time.count).to eql 2
+    end
+
+    if fakeredis?
+      it 'has the current time in seconds' do
+        expect(@client.time.first).to eql 1397845595
+      end
+
+      it 'has the current leftover microseconds' do
+        expect(@client.time.last).to eql 513946
+      end
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe "ServerMethods" do
+
+    before(:each) do
+      @client = Redis.new
+    end
+
+    it "should return the number of keys in the selected database" do
+      @client.set("key1", "1")
+      @client.set("key2", "2")
+      @client.set("key2", "two")
+
+      expect(@client.dbsize).to eq(2)
+    end
+
+    it "should get information and statistics about the server" do
+      expect(@client.info.key?("redis_version")).to eq(true)
+    end
+
+    it "should handle non-existent methods" do
+      expect { @client.idontexist }.to raise_error(Redis::CommandError, "ERR unknown command 'idontexist'")
+    end
+
+    describe "multiple databases" do
+      it "should default to database 0" do
+        expect(@client.inspect).to match(%r#/0>$#)
+      end
+
+      it "should select another database" do
+        @client.select(1)
+        expect(@client.inspect).to match(%r#/1>$#)
+      end
+
+      it "should store keys separately in each database" do
+        expect(@client.select(0)).to eq("OK")
+        @client.set("key1", "1")
+        @client.set("key2", "2")
+
+        @client.select(1)
+        @client.set("key3", "3")
+        @client.set("key4", "4")
+        @client.set("key5", "5")
+
+        @client.select(0)
+        expect(@client.dbsize).to eq(2)
+        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
+
+        @client.flushall
+        expect(@client.dbsize).to eq(0)
+
+        @client.select(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")
+        expect(@client.dbsize).to eq(2)
+
+        @client.select(1)
+        @client.set("key3", "3")
+        @client.set("key4", "4")
+        expect(@client.dbsize).to eq(2)
+
+        expect(@client.flushdb).to eq("OK")
+
+        expect(@client.dbsize).to eq(0)
+        @client.select(0)
+        expect(@client.dbsize).to eq(2)
+      end
+
+      it "should flush all databases" do
+        @client.select(0)
+        @client.set("key3", "3")
+        @client.set("key4", "4")
+        expect(@client.dbsize).to eq(2)
+
+        @client.select(1)
+        @client.set("key3", "3")
+        @client.set("key4", "4")
+        expect(@client.dbsize).to eq(2)
+
+        expect(@client.flushall).to eq("OK")
+
+        expect(@client.dbsize).to eq(0)
+        @client.select(0)
+        expect(@client.dbsize).to eq(0)
+      end
+    end
+  end
+end

data/spec/sets_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe "SetsMethods" do
+    before(:each) do
+      @client = Redis.new
+    end
+
+    it "should add a member to a set" do
+      expect(@client.sadd("key", "value")).to eq(true)
+      expect(@client.sadd("key", "value")).to eq(false)
+
+      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")
+
+      expect(@client.smembers("key")).to be_empty
+    end
+
+    it "should add multiple members to a set" do
+      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")
+
+      expect(@client.scard("key")).to eq(2)
+    end
+
+    it "should subtract multiple sets" 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.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")
+
+      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
+      @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")
+      @client.sdiffstore("key", "key1", "key2", "key3")
+      @client.sdiffstore("new_key", "key1", ["key2", "key3"])
+
+      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
+      @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.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
+      @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")
+      @client.sinterstore("key", "key1", "key2", "key3")
+      @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")
+
+      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
+      @client.sadd("key", "a")
+      @client.sadd("key", "b")
+      @client.sadd("key", "c")
+      @client.sadd("key", "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")
+      expect(@client.smove("key1", "key2", "a")).to eq(true)
+      expect(@client.smove("key1", "key2", "a")).to eq(false)
+
+      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")
+
+      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")
+
+      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")
+      expect(@client.srem("key1", "a")).to eq(true)
+      expect(@client.srem("key1", "a")).to eq(false)
+
+      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")
+
+      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
+      @client.sadd("key1", "a")
+      @client.sadd("key1", "b")
+      @client.srem("key1", "b")
+      @client.srem("key1", "a")
+
+      expect(@client.exists("key1")).to eq(false)
+    end
+
+    it "should add multiple sets" 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.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
+      @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")
+      @client.sunionstore("key", "key1", "key2", "key3")
+
+      expect(@client.smembers("key")).to match_array(["a", "b", "c", "d", "e"])
+    end
+  end
+
+  describe 'srandmember' do
+    before(:each) do
+      @client = Redis.new
+    end
+
+    context 'with a set that has three elements' do
+      before do
+        @client.sadd("key1", "a")
+        @client.sadd("key1", "b")
+        @client.sadd("key1", "c")
+      end
+
+      context 'when called without the optional number parameter' do
+        it 'is a random element from the set' do
+          random_element = @client.srandmember("key1")
+
+          expect(['a', 'b', 'c'].include?(random_element)).to be true
+        end
+      end
+
+      context 'when called with the optional number parameter of 1' do
+        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
+        end
+      end
+
+      context 'when called with the optional number parameter of 2' do
+        it 'is an array of two unique, random elements from the set' do
+          random_elements = @client.srandmember("key1", 2)
+
+          expect(random_elements.count).to eq(2)
+          expect(random_elements.uniq.count).to eq(2)
+          random_elements.all? do |element|
+            expect(['a', 'b', 'c'].include?(element)).to be true
+          end
+        end
+      end
+
+      context 'when called with an optional parameter of -100' do
+        it 'is an array of 100 random elements from the set, some of which are repeated' do
+          random_elements = @client.srandmember("key1", -100)
+
+          expect(random_elements.count).to eq(100)
+          expect(random_elements.uniq.count).to be <= 3
+          random_elements.all? do |element|
+            expect(['a', 'b', 'c'].include?(element)).to be true
+          end
+        end
+      end
+
+      context 'when called with an optional parameter of 100' do
+        it 'is an array of all of the elements from the set, none of which are repeated' do
+          random_elements = @client.srandmember("key1", 100)
+
+          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
+
+    context 'with an empty set' do
+      before { @client.del("key1") }
+
+      it 'is nil without the extra parameter' do
+        expect(@client.srandmember("key1")).to be_nil
+      end
+
+      it 'is an empty array with an extra parameter' do
+        expect(@client.srandmember("key1", 1)).to eq([])
+      end
+    end
+  end
+end