fakeredis 0.2.2 → 0.3.0

data/.travis.yml

@@ -6,4 +6,3 @@ rvm:
   - ree
   - jruby
   - rbx
-  - rbx-2.0

data/README.md

@@ -30,9 +30,24 @@ You can use FakeRedis without any changes:
 Read [redis-rb](https://github.com/ezmobius/redis-rb) documentation and
 [Redis](http://redis.io) homepage for more info about commands
 
+## Usage with RSpec
+
+Require this either in your Gemfile or in RSpec's support scripts. So either: 
+
+    # Gemfile
+    group :test do
+      gem "rspec"
+      gem "fakeredis", :require => "fakeredis/rspec"
+    end 
+
+Or:
+
+    # spec/support/fakeredis.rb
+    require 'fakeredis/rspec'
 
 ## Acknowledgements
 
+* [dim](https://github.com/dim)
 * [czarneckid](https://github.com/czarneckid)
 * [obrie](https://github.com/obrie)
 * [Travis-CI](http://travis-ci.org/) (Travis-CI also uses Fakeredis in its tests!!!)

data/Rakefile

@@ -10,6 +10,7 @@ require 'rspec/core'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.ruby_opts="-w"
 end
 
 task :default => :spec

data/lib/fakeredis/rspec.rb

@@ -0,0 +1,24 @@
+# Require this either in your Gemfile or in RSpec's 
+# support scripts. Examples: 
+#
+#   # Gemfile
+#   group :test do
+#     gem "rspec"
+#     gem "fakeredis", :require => "fakeredis/rspec"
+#   end 
+#
+#   # spec/support/fakeredis.rb
+#   require 'fakeredis/rspec'
+#
+
+require 'rspec/core'
+require 'fakeredis'
+
+RSpec.configure do |c|
+  
+  c.before do    
+    redis = Redis.current
+    redis.flushdb if redis.client.connection.is_a?(Redis::Connection::Memory)
+  end
+  
+end

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/redis/connection/memory.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'redis/connection/registry'
 require 'redis/connection/command_helper'
 
@@ -59,6 +60,9 @@ class Redis
         end
       end
 
+      class ZSet < Hash
+      end
+
       include Redis::Connection::CommandHelper
 
       def initialize
@@ -123,20 +127,8 @@ class Redis
       # * substr
       # * unwatch
       # * watch
-      # * zadd
-      # * zcard
-      # * zcount
-      # * zincrby
-      # * zinterstore
-      # * zrange
-      # * zrangescore
-      # * zrank
-      # * zrem
       # * zremrangebyrank
       # * zremrangebyscore
-      # * zrevrange
-      # * zrevrangebyscore
-      # * zscore
       # * zunionstore
       def flushdb
         @data = ExpiringHash.new
@@ -220,13 +212,14 @@ class Redis
       def hget(key, field)
         return unless @data[key]
         fail "Not a hash" unless @data[key].is_a?(Hash)
-        @data[key][field]
+        @data[key][field.to_s]
       end
 
       def hdel(key, field)
         return unless @data[key]
         fail "Not a hash" unless @data[key].is_a?(Hash)
         @data[key].delete(field)
+        remove_key_for_empty_collection(key)
       end
 
       def hkeys(key)
@@ -312,15 +305,18 @@ class Redis
         fail "Not a list" unless @data[key].is_a?(Array)
         return unless @data[key]
         old_size = @data[key].size
-        if count == 0
-          @data[key].delete(value)
-          old_size - @data[key].size
-        else
-          array = count > 0 ? @data[key].dup : @data[key].reverse
-          count.abs.times{ array.delete_at(array.index(value) || array.length) }
-          @data[key] = count > 0 ? array.dup : array.reverse
-          old_size - @data[key].size
-        end
+        diff =
+          if count == 0
+            @data[key].delete(value)
+            old_size - @data[key].size
+          else
+            array = count > 0 ? @data[key].dup : @data[key].reverse
+            count.abs.times{ array.delete_at(array.index(value) || array.length) }
+            @data[key] = count > 0 ? array.dup : array.reverse
+            old_size - @data[key].size
+          end
+        remove_key_for_empty_collection(key)
+        diff
       end
 
       def rpush(key, value)
@@ -384,24 +380,28 @@ class Redis
       def sadd(key, value)
         fail_unless_set(key)
         case set = @data[key]
-          when nil then @data[key] = Set.new([value.to_s])
-          when Set then set.add(value.to_s)
+          when nil then @data[key] = Set.new([value.to_s]); true
+          when Set then !!set.add?(value.to_s)
         end
       end
 
       def srem(key, value)
         fail_unless_set(key)
-        case set = @data[key]
-          when nil then return
-          when Set then set.delete(value.to_s)
-        end
+        deleted = 
+          case set = @data[key]
+            when nil then false
+            when Set then !!set.delete?(value.to_s)
+          end
+        
+        remove_key_for_empty_collection(key)
+        deleted
       end
 
       def smove(source, destination, value)
         fail_unless_set(destination)
-        if elem = self.srem(source, value)
-          self.sadd(destination, value)
-        end
+        result = self.srem(source, value)
+        self.sadd(destination, value) if result
+        result
       end
 
       def spop(key)
@@ -479,7 +479,12 @@ class Redis
       end
 
       def setnx(key, value)
-        set(key, value) unless @data.key?(key)
+        if exists(key)
+          false
+        else
+          set(key, value)
+          true
+        end
       end
 
       def rename(key, new_key)
@@ -490,7 +495,12 @@ class Redis
       end
 
       def renamenx(key, new_key)
-        rename(key, new_key) unless exists(new_key)
+        if exists(new_key)
+          false
+        else
+          rename(key, new_key)
+          true
+        end
       end
 
       def expire(key, ttl)
@@ -513,25 +523,27 @@ class Redis
       end
 
       def persist(key)
-        @data.expires.delete(key)
+        !!@data.expires.delete(key)
       end
 
       def hset(key, field, value)
+        field = field.to_s
         case hash = @data[key]
-          when nil then @data[key] = { field => value.to_s }
-          when Hash then hash[field] = value.to_s
+          when nil then @data[key] = { field => value.to_s }; true
+          when Hash then result = !hash.include?(field); hash[field] = value.to_s; result
           else fail "Not a hash"
         end
       end
 
       def hsetnx(key, field, value)
-        return if (@data[key][field] rescue false)
+        field = field.to_s
+        return false if (@data[key][field] rescue false)
         hset(key, field, value)
       end
 
       def hmset(key, *fields)
         @data[key] ||= {}
-        fail "Not a hash" unless @data[key].is_a?(Hash) 
+        fail "Not a hash" unless @data[key].is_a?(Hash)
         fields.each_slice(2) do |field|
           @data[key][field[0].to_s] = field[1].to_s
         end
@@ -540,7 +552,8 @@ class Redis
       def hmget(key, *fields)
         values = []
         fields.each do |field|
-          case hash = @data[key] 
+          field = field.to_s
+          case hash = @data[key]
             when nil then values << nil
             when Hash then values << hash[field]
             else fail "Not a hash"
@@ -567,10 +580,11 @@ class Redis
 
       def hincrby(key, field, increment)
         case hash = @data[key]
-          when nil then @data[key] = { field => value.to_s }
+          when nil then @data[key] = { field => increment.to_s }
           when Hash then hash[field] = (hash[field].to_i + increment.to_i).to_s
           else fail "Not a hash"
         end
+        @data[key][field].to_i
       end
 
       def hexists(key, field)
@@ -604,7 +618,7 @@ class Redis
       end
 
       def setex(key, seconds, value)
-        @data[key] = value
+        @data[key] = value.to_s
         expire(key, seconds)
       end
 
@@ -641,21 +655,25 @@ class Redis
       def incr(key)
         @data[key] = (@data[key] || "0")
         @data[key] = (@data[key].to_i + 1).to_s
+        @data[key].to_i
       end
 
       def incrby(key, by)
         @data[key] = (@data[key] || "0")
         @data[key] = (@data[key].to_i + by.to_i).to_s
+        @data[key].to_i
       end
 
       def decr(key)
         @data[key] = (@data[key] || "0")
         @data[key] = (@data[key].to_i - 1).to_s
+        @data[key].to_i
       end
 
       def decrby(key, by)
         @data[key] = (@data[key] || "0")
         @data[key] = (@data[key].to_i - by.to_i).to_s
+        @data[key].to_i
       end
 
       def type(key)
@@ -686,7 +704,126 @@ class Redis
         "OK"
       end
 
+      def zadd(key, score, value)
+        fail_unless_zset(key)
+        @data[key] ||= ZSet.new
+        exists = @data[key].key?(value.to_s)
+        @data[key][value.to_s] = score.to_i
+        !exists
+      end
+
+      def zrem(key, value)
+        fail_unless_zset(key)
+        exists = false
+        exists = @data[key].delete(value.to_s) if @data[key]
+        remove_key_for_empty_collection(key)
+        !!exists
+      end
+
+      def zcard(key)
+        fail_unless_zset(key)
+        @data[key] ? @data[key].size : 0
+      end
+
+      def zscore(key, value)
+        fail_unless_zset(key)
+        @data[key] && @data[key][value.to_s].to_s
+      end
+
+      def zcount(key, min, max)
+        fail_unless_zset(key)
+        return 0 unless @data[key]
+        zrange_select_by_score(key, min, max).size
+      end
+
+      def zincrby(key, num, value)
+        fail_unless_zset(key)
+        @data[key][value.to_s] ||= 0
+        @data[key][value.to_s] += num
+        @data[key][value.to_s].to_s
+      end
+
+      def zrank(key, value)
+        fail_unless_zset(key)
+        @data[key].keys.sort_by {|k| @data[key][k] }.index(value.to_s)
+      end
+
+      def zrevrank(key, value)
+        fail_unless_zset(key)
+        @data[key].keys.sort_by {|k| -@data[key][k] }.index(value.to_s)
+      end
+
+      def zrange(key, start, stop, with_scores = nil)
+        fail_unless_zset(key)
+        return [] unless @data[key]
+
+        if with_scores
+          @data[key].sort_by {|_,v| v }
+        else
+          @data[key].keys.sort_by {|k| @data[key][k] }
+        end[start..stop].flatten.map(&:to_s)
+      end
+
+      def zrevrange(key, start, stop, with_scores = nil)
+        fail_unless_zset(key)
+        return [] unless @data[key]
+
+        if with_scores
+          @data[key].sort_by {|_,v| -v }
+        else
+          @data[key].keys.sort_by {|k| -@data[key][k] }
+        end[start..stop].flatten.map(&:to_s)
+      end
+
+      def zrangebyscore(key, min, max, with_scores = nil)
+        fail_unless_zset(key)
+        return [] unless @data[key]
+
+        range = zrange_select_by_score(key, min, max)
+        if with_scores
+          range.sort_by {|_,v| v }
+        else
+          range.keys.sort_by {|k| range[k] }
+        end.flatten.map(&:to_s)
+      end
+
+      def zrevrangebyscore(key, max, min, with_scores = nil)
+        fail_unless_zset(key)
+        return [] unless @data[key]
+
+        range = zrange_select_by_score(key, min, max)
+        if with_scores
+          range.sort_by {|_,v| -v }
+        else
+          range.keys.sort_by {|k| -range[k] }
+        end.flatten.map(&:to_s)
+      end
+
+      def zinterstore(out, _, *keys)
+        fail_unless_zset(out)
+
+        hashes = keys.map do |src|
+          case @data[src]
+          when Set
+            Hash[@data[src].zip([0] * @data[src].size)]
+          when Hash
+            @data[src]
+          else
+            {}
+          end
+        end
+
+        @data[out] = ZSet.new
+        values = hashes.inject([]) {|r, h| r.empty? ? h.keys : r & h.keys }
+        values.each do |value|
+          @data[out][value] = hashes.inject(0) {|n, h| n + h[value].to_i }
+        end
+
+        @data[out].size
+      end
+
       private
+
         def is_a_set?(key)
           @data[key].is_a?(Set) || @data[key].nil?
         end
@@ -694,6 +831,22 @@ class Redis
         def fail_unless_set(key)
           fail "Not a set" unless is_a_set?(key)
         end
+
+        def is_a_zset?(key)
+          @data[key].is_a?(ZSet) || @data[key].nil?
+        end
+
+        def fail_unless_zset(key)
+          fail "Not a sorted set" unless is_a_zset?(key)
+        end
+
+        def zrange_select_by_score(key, min, max)
+          @data[key].reject {|_,v| v < min || v > max }
+        end
+
+        def remove_key_for_empty_collection(key)
+          del(key) if @data[key] && @data[key].empty?
+        end
     end
   end
 end

data/spec/hashes_spec.rb

@@ -15,6 +15,31 @@ module FakeRedis
       @client.hget("key1", "k2").should == "val2"
     end
 
+    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.exists("key1").should == false
+    end
+
+    it "should convert key to a string via to_s for hset" do
+      m = double("key")
+      m.stub(:to_s).and_return("foo")
+
+      @client.hset("key1", m, "bar")
+      @client.hget("key1", "foo").should == "bar"
+    end
+
+    it "should convert key to a string via to_s for hget" do
+      m = double("key")
+      m.stub(:to_s).and_return("foo")
+
+      @client.hset("key1", "foo", "bar")
+      @client.hget("key1", m).should == "bar"
+    end
+
     it "should determine if a hash field exists" do
       @client.hset("key1", "index", "value")
 
@@ -37,11 +62,15 @@ module FakeRedis
 
     it "should increment the integer value of a hash field by the given number" do
       @client.hset("key1", "cont1", "5")
-      @client.hincrby("key1", "cont1", "5")
-
+      @client.hincrby("key1", "cont1", "5").should == 10
       @client.hget("key1", "cont1").should == "10"
     end
 
+    it "should increment non existing hash keys" do
+      @client.hget("key1", "cont2").should be_nil
+      @client.hincrby("key1", "cont2", "5").should == 5
+    end
+
     it "should get all the fields in a hash" do
       @client.hset("key1", "i1", "val1")
       @client.hset("key1", "i2", "val2")
@@ -73,18 +102,22 @@ module FakeRedis
     end
 
     it "should set the string value of a hash field" do
-      @client.hset("key1", "k1", "val1")
+      @client.hset("key1", "k1", "val1").should == true
+      @client.hset("key1", "k1", "val1").should == false
 
       @client.hget("key1", "k1").should == "val1"
     end
 
     it "should set the value of a hash field, only if the field does not exist" do
       @client.hset("key1", "k1", "val1")
-      @client.hsetnx("key1", "k1", "value")
-      @client.hsetnx("key1", "k2", "val2")
+      @client.hsetnx("key1", "k1", "value").should == false
+      @client.hsetnx("key1", "k2", "val2").should == true
+      @client.hsetnx("key1", :k1, "value").should == false
+      @client.hsetnx("key1", :k3, "val3").should == true
 
       @client.hget("key1", "k1").should == "val1"
       @client.hget("key1", "k2").should == "val2"
+      @client.hget("key1", "k3").should == "val3"
     end
 
     it "should get all the values in a hash" do

data/spec/keys_spec.rb

@@ -18,7 +18,6 @@ module FakeRedis
     it "should determine if a key exists" do
       @client.set("key1", "1")
 
-puts "checking existence"
       @client.exists("key1").should == true
       @client.exists("key2").should == false
     end
@@ -94,7 +93,9 @@ puts "checking existence"
 
     it "should remove the expiration from a key" do
       @client.set("key1", "1")
-      @client.persist("key1")
+      @client.expireat("key1", Time.now.to_i)
+      @client.persist("key1").should == true
+      @client.persist("key1").should == false
 
       @client.ttl("key1").should == -1
     end
@@ -137,5 +138,13 @@ puts "checking existence"
       @client.type("key1").should == "string"
       @client.type("key0").should == "none"
     end
+
+    it "should convert the value into a string before storing" do
+      @client.set("key1", 1)
+      @client.get("key1").should == "1"
+
+      @client.setex("key2", 30, 1)
+      @client.get("key2").should == "1"
+    end
   end
 end

data/spec/lists_spec.rb

@@ -77,6 +77,15 @@ module FakeRedis
       @client.llen("key1").should == 2
     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")
+
+      @client.exists("key1").should == 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")

data/spec/sets_spec.rb

@@ -7,7 +7,8 @@ module FakeRedis
     end
 
     it "should add a member to a set" do
-      @client.sadd("key", "value")
+      @client.sadd("key", "value").should == true
+      @client.sadd("key", "value").should == false
 
       @client.smembers("key").should == ["value"]
     end
@@ -93,7 +94,8 @@ module FakeRedis
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
       @client.sadd("key2", "c")
-      @client.smove("key1", "key2", "a")
+      @client.smove("key1", "key2", "a").should == true
+      @client.smove("key1", "key2", "a").should == false
 
       @client.smembers("key1").should == ["b"]
       @client.smembers("key2").should =~ ["c", "a"]
@@ -118,11 +120,21 @@ module FakeRedis
     it "should remove a member from a set" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
-      @client.srem("key1", "a")
+      @client.srem("key1", "a").should == true
+      @client.srem("key1", "a").should == false
 
       @client.smembers("key1").should == ["b"]
     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")
+
+      @client.exists("key1").should == false
+    end
+
     it "should add multiple sets" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")

data/spec/sorted_sets_spec.rb

@@ -1,68 +1,142 @@
-#require 'spec_helper'
-
-#module FakeRedis
-  #describe "SortedSetsMethods" do
-    #before(:each) do
-      #@client = Redis.new
-    #end
-
-    #it "should add a member to a sorted set, or update its score if it already exists" do
-      #@client.zadd("key", 1, "val")
-
-      #@client.zcard("key").should == 1
-    #end
-
-    #it "should get the number of members in a sorted set" do
-      #@client.zadd("key", 1, "val2")
-      #@client.zadd("key", 2, "val1")
-      #@client.zadd("key", 5, "val3")
-
-      #@client.zcard("key").should == 3
-    #end
-
-    #it "should count the members in a sorted set with scores within the given values" do
-      #@client.zadd("key", 1, "val1")
-      #@client.zadd("key", 2, "val2")
-      #@client.zadd("key", 3, "val3")
-
-      #@client.zcount("key", 2, 3).should == 2
-    #end
-
-    #it "should increment the score of a member in a sorted set" do
-      #@client.zadd("key", 1, "val1")
-      #@client.zincrby("key", 2, "val1")
-
-      #@client.zscore("key", "val1").should == 3
-    #end
-
+require 'spec_helper'
+
+module FakeRedis
+  describe "SortedSetsMethods" do
+    before(:each) do
+      @client = Redis.new
+    end
+
+    it "should add a member to a sorted set, or update its score if it already exists" do
+      @client.zadd("key", 1, "val").should be(true)
+      @client.zscore("key", "val").should == "1"
+
+      @client.zadd("key", 2, "val").should be(false)
+      @client.zscore("key", "val").should == "2"
+    end
+
+    it "should remove members from sorted sets" do
+      @client.zrem("key", "val").should be(false)
+      @client.zadd("key", 1, "val").should be(true)
+      @client.zrem("key", "val").should be(true)
+    end
+
+    it "should remove sorted set's key when it is empty" do
+      @client.zadd("key", 1, "val")
+      @client.zrem("key", "val")
+      @client.exists("key").should == false
+    end
+
+    it "should get the number of members in a sorted set" do
+      @client.zadd("key", 1, "val2")
+      @client.zadd("key", 2, "val1")
+      @client.zadd("key", 5, "val3")
+
+      @client.zcard("key").should == 3
+    end
+
+    it "should count the members in a sorted set with scores within the given values" do
+      @client.zadd("key", 1, "val1")
+      @client.zadd("key", 2, "val2")
+      @client.zadd("key", 3, "val3")
+
+      @client.zcount("key", 2, 3).should == 2
+    end
+
+    it "should increment the score of a member in a sorted set" do
+      @client.zadd("key", 1, "val1")
+      @client.zincrby("key", 2, "val1").should == "3"
+      @client.zscore("key", "val1").should == "3"
+    end
+
+    it "should convert the key to a string for zscore" do
+      @client.zadd("key", 1, 1)
+      @client.zscore("key", 1).should == "1"
+    end
     #it "should intersect multiple sorted sets and store the resulting sorted set in a new key"
 
-    #it "should return a range of members in a sorted set, by index" do
-      #@client.zadd("key", 1, "one")
-      #@client.zadd("key", 2, "two")
-      #@client.zadd("key", 3, "three")
-
-      #@client.zrange("key", 0, -1).should == ["one", "two", "three"]
-
-    #end
-
-    #it "should return a range of members in a sorted set, by score" do
-      #@client.zadd("key", 1, "one")
-      #@client.zadd("key", 2, "two")
-      #@client.zadd("key", 3, "three")
-
-      #@client.zrangescore("key", 0, -1).should == ["three", "two", "one"]
-    #end
-
-    #it "should determine the index of a member in a sorted set" do
-      #@client.zadd("key", 1, "one")
-      #@client.zadd("key", 2, "two")
-      #@client.zadd("key", 3, "three")
-
-      #@client.zrank("key", "three").should == 2
-    #end
-
-    #it "should remove a member from a sorted set"
+    it "should return a range of members in a sorted set, by index" do
+      @client.zadd("key", 1, "one")
+      @client.zadd("key", 2, "two")
+      @client.zadd("key", 3, "three")
+
+      @client.zrange("key", 0, -1).should == ["one", "two", "three"]
+      @client.zrange("key", 1, 2).should == ["two", "three"]
+      @client.zrange("key", 0, -1, :withscores => true).should == ["one", "1", "two", "2", "three", "3"]
+      @client.zrange("key", 1, 2, :with_scores => true).should == ["two", "2", "three", "3"]
+    end
+
+    it "should return a reversed range of members in a sorted set, by index" do
+      @client.zadd("key", 1, "one")
+      @client.zadd("key", 2, "two")
+      @client.zadd("key", 3, "three")
+
+      @client.zrevrange("key", 0, -1).should == ["three", "two", "one"]
+      @client.zrevrange("key", 1, 2).should == ["two", "one"]
+      @client.zrevrange("key", 0, -1, :withscores => true).should == ["three", "3", "two", "2", "one", "1"]
+      @client.zrevrange("key", 0, -1, :with_scores => true).should == ["three", "3", "two", "2", "one", "1"]
+    end
+
+    it "should return a range of members in a sorted set, by score" do
+      @client.zadd("key", 1, "one")
+      @client.zadd("key", 2, "two")
+      @client.zadd("key", 3, "three")
+
+      @client.zrangebyscore("key", 0, 100).should == ["one", "two", "three"]
+      @client.zrangebyscore("key", 1, 2).should == ["one", "two"]
+      @client.zrangebyscore("key", 0, 100, :withscores => true).should == ["one", "1", "two", "2", "three", "3"]
+      @client.zrangebyscore("key", 1, 2, :with_scores => true).should == ["one", "1", "two", "2"]
+    end
+
+    it "should return a reversed range of members in a sorted set, by score" do
+      @client.zadd("key", 1, "one")
+      @client.zadd("key", 2, "two")
+      @client.zadd("key", 3, "three")
+
+      @client.zrevrangebyscore("key", 100, 0).should == ["three", "two", "one"]
+      @client.zrevrangebyscore("key", 2, 1).should == ["two", "one"]
+      @client.zrevrangebyscore("key", 1, 2).should == []
+      @client.zrevrangebyscore("key", 2, 1, :with_scores => true).should == ["two", "2", "one", "1"]
+    end
+
+    it "should determine the index of a member in a sorted set" do
+      @client.zadd("key", 1, "one")
+      @client.zadd("key", 2, "two")
+      @client.zadd("key", 3, "three")
+
+      @client.zrank("key", "three").should == 2
+      @client.zrank("key", "four").should be_nil
+    end
+
+    it "should determine the reversed index of a member in a sorted set" do
+      @client.zadd("key", 1, "one")
+      @client.zadd("key", 2, "two")
+      @client.zadd("key", 3, "three")
+
+      @client.zrevrank("key", "three").should == 0
+      @client.zrevrank("key", "four").should be_nil
+    end
+
+    it "should create untersections between multiple (sorted) sets and store the resulting sorted set in a new key" do
+      @client.zadd("key1", 1, "one")
+      @client.zadd("key1", 2, "two")
+      @client.zadd("key1", 3, "three")
+      @client.zadd("key2", 5, "two")
+      @client.zadd("key2", 7, "three")
+      @client.sadd("key3", 'one')
+      @client.sadd("key3", 'two')
+
+      @client.zinterstore("out", ["key1", "key2"]).should == 2
+      @client.zrange("out", 0, 100, :with_scores => true).should == ['two', '7', 'three', '10']
+
+      @client.zinterstore("out", ["key1", "key3"]).should == 2
+      @client.zrange("out", 0, 100, :with_scores => true).should == ['one', '1', 'two', '2']
+
+      @client.zinterstore("out", ["key1", "key2", "key3"]).should == 1
+      @client.zrange("out", 0, 100, :with_scores => true).should == ['two', '7']
+
+      @client.zinterstore("out", ["key1", "no_key"]).should == 0
+      @client.zrange("out", 0, 100, :with_scores => true).should == []
+    end
 
     #it "should remove all members in a sorted set within the given indexes"
 
@@ -77,5 +151,5 @@
     #it "should get the score associated with the given member in a sorted set"
 
     #it "should add multiple sorted sets and store the resulting sorted set in a new key"
-  #end
-#end
+  end
+end

data/spec/strings_spec.rb

@@ -64,16 +64,30 @@ module FakeRedis
 
     it "should increment the integer value of a key by one" do
       @client.set("counter", "1")
-      @client.incr("counter")
+      @client.incr("counter").should == 2
 
       @client.get("counter").should == "2"
     end
+    
+    it "should decrement the integer value of a key by one" do
+      @client.set("counter", "1")
+      @client.decr("counter").should == 0
+      
+      @client.get("counter").should == "0"
+    end
 
     it "should increment the integer value of a key by the given number" do
       @client.set("counter", "10")
-      @client.incrby("counter", "5")
+      @client.incrby("counter", "5").should == 15
+      @client.incrby("counter", 2).should == 17
+      @client.get("counter").should == "17"
+    end
 
-      @client.get("counter").should == "15"
+    it "should decrement the integer value of a key by the given number" do
+      @client.set("counter", "10")
+      @client.decrby("counter", "5").should == 5
+      @client.decrby("counter", 2).should == 3
+      @client.get("counter").should == "3"
     end
 
     it "should get the values of all the given keys" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fakeredis
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-23 00:00:00.000000000Z
+date: 2012-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70228508905360 !ruby/object:Gem::Requirement
+  requirement: &70149263528920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 2.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70228508905360
+  version_requirements: *70149263528920
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70228508904840 !ruby/object:Gem::Requirement
+  requirement: &70149263528400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: 2.0.0
   type: :development
   prerelease: false
-  version_requirements: *70228508904840
+  version_requirements: *70149263528400
 description: Fake (In-memory) driver for redis-rb. Useful for testing environment
   and machines without Redis.
 email:
@@ -50,6 +50,7 @@ files:
 - Rakefile
 - fakeredis.gemspec
 - lib/fakeredis.rb
+- lib/fakeredis/rspec.rb
 - lib/fakeredis/version.rb
 - lib/redis/connection/memory.rb
 - spec/compatibility_spec.rb
@@ -83,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: fakeredis
-rubygems_version: 1.8.7
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Fake (In-memory) driver for redis-rb.