fakeredis 0.4.3 → 0.5.0

data/spec/hashes_spec.rb

@@ -9,7 +9,7 @@ module FakeRedis
     it "should delete a hash field" do
       @client.hset("key1", "k1", "val1")
       @client.hset("key1", "k2", "val2")
-      @client.hdel("key1", "k1")
+      @client.hdel("key1", "k1").should be(1)
 
       @client.hget("key1", "k1").should be_nil
       @client.hget("key1", "k2").should be == "val2"
@@ -18,8 +18,8 @@ module FakeRedis
     it "should remove a hash with no keys left" do
       @client.hset("key1", "k1", "val1")
       @client.hset("key1", "k2", "val2")
-      @client.hdel("key1", "k1")
-      @client.hdel("key1", "k2")
+      @client.hdel("key1", "k1").should be(1)
+      @client.hdel("key1", "k2").should be(1)
 
       @client.exists("key1").should be == false
     end
@@ -43,8 +43,8 @@ module FakeRedis
     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
+      @client.hexists("key1", "index").should be true
+      @client.hexists("key2", "i2").should be false
     end
 
     it "should get the value of a hash field" do
@@ -71,6 +71,17 @@ module FakeRedis
       @client.hincrby("key1", "cont2", "5").should be == 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"
+    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
+    end
+
     it "should get all the fields in a hash" do
       @client.hset("key1", "i1", "val1")
       @client.hset("key1", "i2", "val2")
@@ -91,6 +102,8 @@ module FakeRedis
       @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]
+
       @client.hmget("key2", "i1", "i2").should be == [nil, nil]
     end
 
@@ -100,13 +113,13 @@ module FakeRedis
 
     it "should reject an empty list of values" do
       lambda { @client.hmset("key") }.should raise_error(Redis::CommandError)
-      @client.exists("key").should be_false
+      @client.exists("key").should 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
+      @client.exists("key").should be false
     end
 
     it "should reject the wrong number of arguments" do
@@ -171,7 +184,7 @@ module FakeRedis
 
     it "should convert a integer field name to string for hexists" do
       @client.hset("key1", "1", 1)
-      @client.hexists("key1", 1).should be_true
+      @client.hexists("key1", 1).should be true
     end
 
     it "should convert a integer field name to string for hincrby" do

data/spec/keys_spec.rb

@@ -29,6 +29,15 @@ module FakeRedis
       lambda { @client.del [] }.should raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
     end
 
+    it "should return true when setting expires on keys that exist" do
+      @client.set("key1", "1")
+      @client.expire("key1", 1).should == true
+    end
+
+    it "should return false when attempting to set expires on a key that does not exist" do
+      @client.expire("key1", 1).should == false
+    end
+
     it "should determine if a key exists" do
       @client.set("key1", "1")
 
@@ -92,7 +101,7 @@ module FakeRedis
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
 
-      @client.exists("key1").should be_false
+      @client.exists("key1").should be false
     end
 
     it "should find all keys matching the given pattern" do
@@ -145,10 +154,6 @@ module FakeRedis
       @client.get("key4").should be == "3"
     end
 
-    it "should sort the elements in a list, set or sorted set" do
-      pending "SORT Command not implemented yet"
-    end
-
     it "should determine the type stored at key" do
       # Non-existing key
       @client.type("key0").should be == "none"
@@ -265,5 +270,102 @@ module FakeRedis
       @client.select(0)
       @client.get("key1").should be == "1"
     end
+
+    it "should scan all keys in the database" do
+      100.times do |x|
+        @client.set("key#{x}", "#{x}")
+      end
+
+      cursor = 0
+      all_keys = []
+      loop {
+        cursor, keys = @client.scan(cursor)
+        all_keys += keys
+        break if cursor == "0"
+      }
+
+      all_keys.uniq.size.should == 100
+      all_keys[0].should =~ /key\d+/
+    end
+
+    it "should match keys to a pattern when scanning" do
+      50.times do |x|
+        @client.set("key#{x}", "#{x}")
+      end
+
+      @client.set("miss_me", 1)
+      @client.set("pass_me", 2)
+
+      cursor = 0
+      all_keys = []
+      loop {
+        cursor, keys = @client.scan(cursor, :match => "key*")
+        all_keys += keys
+        break if cursor == "0"
+      }
+
+      all_keys.uniq.size.should == 50
+    end
+
+    it "should specify doing more work when scanning" do
+      100.times do |x|
+        @client.set("key#{x}", "#{x}")
+      end
+
+      cursor, all_keys = @client.scan(cursor, :count => 100)
+
+      cursor.should == "0"
+      all_keys.uniq.size.should == 100
+    end
+
+    context "with extended options" do
+      it "uses ex option to set the expire time, in seconds" do
+        ttl = 7
+
+        @client.set("key1", "1", { :ex => ttl }).should == "OK"
+        @client.ttl("key1").should == ttl
+      end
+
+      it "uses px option to set the expire time, in miliseconds" do
+        ttl = 7000
+
+        @client.set("key1", "1", { :px => ttl }).should == "OK"
+        @client.ttl("key1").should == (ttl / 1000)
+      end
+
+      # Note that the redis-rb implementation will always give PX last.
+      # Redis seems to process each expiration option and the last one wins.
+      it "prefers the finer-grained PX expiration option over EX" do
+        ttl_px = 6000
+        ttl_ex = 10
+
+        @client.set("key1", "1", { :px => ttl_px, :ex => ttl_ex })
+        @client.ttl("key1").should == (ttl_px / 1000)
+
+        @client.set("key1", "1", { :ex => ttl_ex, :px => ttl_px })
+        @client.ttl("key1").should == (ttl_px / 1000)
+      end
+
+      it "uses nx option to only set the key if it does not already exist" do
+        @client.set("key1", "1", { :nx => true }).should == true
+        @client.set("key1", "2", { :nx => true }).should == false
+
+        @client.get("key1").should == "1"
+      end
+
+      it "uses xx option to only set the key if it already exists" do
+        @client.set("key2", "1", { :xx => true }).should == false
+        @client.set("key2", "2")
+        @client.set("key2", "1", { :xx => true }).should == true
+
+        @client.get("key2").should == "1"
+      end
+
+      it "does not set the key if both xx and nx option are specified" do
+        @client.set("key2", "1", { :nx => true, :xx => true }).should == false
+        @client.get("key2").should be_nil
+      end
+    end
   end
 end
+

data/spec/lists_spec.rb

@@ -119,7 +119,7 @@ module FakeRedis
       @client.rpush("key1", "two")
       @client.rpush("key1", "three")
 
-      @client.ltrim("key1", 1, -1)
+      @client.ltrim("key1", 1, -1).should be == "OK"
       @client.lrange("key1", 0, -1).should be == ["two", "three"]
     end
 
@@ -176,6 +176,14 @@ module FakeRedis
       @client.lrange("key2", 0, -1).should be == ["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 == []
+      end
+    end
+
     it "should append a value to a list" do
       @client.rpush("key1", "one")
       @client.rpush("key1", "two")

data/spec/memory_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe 'time' do
+    before(:each) do
+      @client = Redis.new
+      Time.stub_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

@@ -45,13 +45,13 @@ module FakeRedis
 
         @client.select(0)
         @client.dbsize.should be == 2
-        @client.exists("key1").should be_true
-        @client.exists("key3").should be_false
+        @client.exists("key1").should be true
+        @client.exists("key3").should be false
 
         @client.select(1)
         @client.dbsize.should be == 3
-        @client.exists("key4").should be_true
-        @client.exists("key2").should be_false
+        @client.exists("key4").should be true
+        @client.exists("key2").should be false
 
         @client.flushall
         @client.dbsize.should be == 0

data/spec/sets_spec.rb

@@ -125,8 +125,8 @@ module FakeRedis
       @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
+      ["a", "b"].include?(@client.spop("key1")).should be true
+      ["a", "b"].include?(@client.spop("key1")).should be true
       @client.spop("key1").should be_nil
     end
 
@@ -134,7 +134,7 @@ module FakeRedis
       @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
     end
 
     it "should remove a member from a set" do
@@ -146,6 +146,14 @@ module FakeRedis
       @client.smembers("key1").should be == ["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
+    end
+
     it "should remove the set's key once it's empty" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
@@ -182,4 +190,80 @@ module FakeRedis
       @client.smembers("key").should =~ ["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")
+
+          ['a', 'b', 'c'].include?(random_element).should 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)
+
+          [['a'], ['b'], ['c']].include?(@client.srandmember("key1", 1)).should 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)
+
+          random_elements.count.should == 2
+          random_elements.uniq.count.should == 2
+          random_elements.all? do |element|
+            ['a', 'b', 'c'].include?(element).should 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)
+
+          random_elements.count.should == 100
+          random_elements.uniq.count.should <= 3
+          random_elements.all? do |element|
+            ['a', 'b', 'c'].include?(element).should 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)
+
+          random_elements.count.should == 3
+          random_elements.uniq.count.should == 3
+          random_elements.should =~ ['a', 'b', 'c']
+        end
+      end
+    end
+
+    context 'with an empty set' do
+      before { @client.del("key1") }
+
+      it 'is nil without the extra parameter' do
+        @client.srandmember("key1").should be_nil
+      end
+
+      it 'is an empty array with an extra parameter' do
+        @client.srandmember("key1", 1).should == []
+      end
+    end
+  end
 end

data/spec/sort_method_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe "#sort" do
+    before(:each) do
+      @client = Redis.new
+
+      @client.set('fake-redis-test:values_1', 'a')
+      @client.set('fake-redis-test:values_2', 'b')
+
+      @client.set('fake-redis-test:weight_1', '2')
+      @client.set('fake-redis-test:weight_2', '1')
+
+      @client.hset('fake-redis-test:hash_1', 'key', 'x')
+      @client.hset('fake-redis-test:hash_2', 'key', 'y')
+    end
+
+    context "WRONGTYPE Operation" do
+      it "should not allow #sort on Strings" do
+        @client.set("key1", "Hello")
+        expect {
+          @client.sort("key1")
+        }.to raise_error(Redis::CommandError)
+      end
+
+      it "should not allow #sort on Hashes" do
+        @client.hset("key1", "k1", "val1")
+        @client.hset("key1", "k2", "val2")
+        expect {
+          @client.sort("key1")
+        }.to raise_error(Redis::CommandError)
+      end
+    end
+
+    context "list" do
+      before do
+        @key = "fake-redis-test:list_sort"
+
+        @client.rpush(@key, '1')
+        @client.rpush(@key, '2')
+      end
+
+      it_should_behave_like "a sortable"
+    end
+
+    context "set" do
+      before do
+        @key = "fake-redis-test:set_sort"
+
+        @client.sadd(@key, '1')
+        @client.sadd(@key, '2')
+      end
+
+      it_should_behave_like "a sortable"
+    end
+
+    context "zset" do
+      before do
+        @key = "fake-redis-test:zset_sort"
+
+        @client.zadd(@key, 100, '1')
+        @client.zadd(@key, 99, '2')
+      end
+
+      it_should_behave_like "a sortable"
+    end
+  end
+end