artemk-cache-money 0.2.13.2

data/spec/cash/window_spec.rb

@@ -0,0 +1,195 @@
+require "spec_helper"
+
+module Cash
+  describe 'Windows' do
+    LIMIT, BUFFER = 5, 2
+
+    before :suite do
+      Fable = Class.new(Story)
+      Fable.index :title, :limit => LIMIT, :buffer => BUFFER
+    end
+
+    describe '#find(...)' do
+      before do
+        @fables = []
+        10.times { @fables << Fable.create!(:title => @title = 'title') }
+      end
+
+      describe 'when the cache is populated' do
+        describe "#find(:all, :conditions => ...)" do
+          it "uses the database, not the cache" do
+            mock(Fable).get.never
+            Fable.find(:all, :conditions => { :title => @title }).should == @fables
+          end
+        end
+
+        describe "#find(:all, :conditions => ..., :limit => ...) and query limit > index limit" do
+          it "uses the database, not the cache" do
+            mock(Fable).get.never
+            Fable.find(:all, :conditions => { :title => @title }, :limit => LIMIT + 1).should == @fables[0, LIMIT + 1]
+          end
+        end
+
+        describe "#find(:all, :conditions => ..., :limit => ..., :offset => ...) and query limit + offset > index limit" do
+          it "uses the database, not the cache" do
+            mock(Fable).get.never
+            Fable.find(:all, :conditions => { :title => @title }, :limit => 1, :offset => LIMIT).should == @fables[LIMIT, 1]
+          end
+        end
+
+        describe "#find(:all, :conditions => ..., :limit => ...) and query limit <= index limit" do
+          it "does not use the database" do
+            mock(Fable.connection).execute.never
+            Fable.find(:all, :conditions => { :title => @title }, :limit => LIMIT - 1).should == @fables[0, LIMIT - 1]
+          end
+        end
+      end
+
+      describe 'when the cache is not populated' do
+        describe "#find(:all, :conditions => ..., :limit => ...) and query limit <= index limit" do
+          describe 'when there are fewer than limit + buffer items' do
+            it "populates the cache with all items" do
+              Fable.find(:all, :limit => deleted = @fables.size - LIMIT - BUFFER + 1).collect(&:destroy)
+              $memcache.flush_all
+              Fable.find(:all, :conditions => { :title => @title }, :limit => LIMIT).should == @fables[deleted, LIMIT]
+              Fable.get("title/#{@title}").should == @fables[deleted, @fables.size - deleted].collect(&:id)
+            end
+          end
+
+          describe 'when there are more than limit + buffer items' do
+            it "populates the cache with limit + buffer items" do
+              $memcache.flush_all
+              Fable.find(:all, :conditions => { :title => @title }, :limit => 5).should == @fables[0, 5]
+              Fable.get("title/#{@title}").should == @fables[0, LIMIT + BUFFER].collect(&:id)
+            end
+          end
+        end
+      end
+    end
+
+    describe '#create!' do
+      describe 'when the cache is populated' do
+        describe 'when the count of records in the database is > limit + buffer items' do
+          it 'truncates' do
+            fables, title = [], 'title'
+            (LIMIT + BUFFER).times { fables << Fable.create!(:title => title) }
+            Fable.get("title/#{title}").should == fables.collect(&:id)
+            Fable.create!(:title => title)
+            Fable.get("title/#{title}").should == fables.collect(&:id)
+          end
+        end
+
+        describe 'when the count of records in the database is < limit + buffer items' do
+          it 'appends to the list' do
+            fables, title = [], 'title'
+            (LIMIT + BUFFER - 1).times { fables << Fable.create!(:title => title) }
+            Fable.get("title/#{title}").should == fables.collect(&:id)
+            fable = Fable.create!(:title => title)
+            Fable.get("title/#{title}").should == (fables << fable).collect(&:id)
+          end
+        end
+      end
+
+      describe 'when the cache is not populated' do
+        describe 'when the count of records in the database is > limit + buffer items' do
+          it 'truncates the index' do
+            fables, title = [], 'title'
+            (LIMIT + BUFFER).times { fables << Fable.create!(:title => title) }
+            $memcache.flush_all
+            Fable.create!(:title => title)
+            Fable.get("title/#{title}").should == fables.collect(&:id)
+          end
+        end
+
+        describe 'when the count of records in the database is < limit + buffer items' do
+          it 'appends to the list' do
+            fables, title = [], 'title'
+            (LIMIT + BUFFER - 1).times { fables << Fable.create!(:title => title) }
+            $memcache.flush_all
+            fable = Fable.create!(:title => title)
+            Fable.get("title/#{title}").should == (fables << fable).collect(&:id)
+          end
+        end
+      end
+    end
+
+    describe '#destroy' do
+      describe 'when the cache is populated' do
+        describe 'when the index size is <= limit of items' do
+          describe 'when the count of records in the database is <= limit of items' do
+            it 'deletes from the list without refreshing from the database' do
+              fables, title = [], 'title'
+              LIMIT.times { fables << Fable.create!(:title => title) }
+              Fable.get("title/#{title}").size.should <= LIMIT
+
+              mock(Fable.connection).select.never
+              fables.shift.destroy
+              Fable.get("title/#{title}").should == fables.collect(&:id)
+            end
+          end
+
+          describe 'when the count of records in the database is >= limit of items' do
+            it 'refreshes the list (from the database)' do
+              fables, title = [], 'title'
+              (LIMIT + BUFFER + 1).times { fables << Fable.create!(:title => title) }
+              BUFFER.times { fables.shift.destroy }
+              Fable.get("title/#{title}").size.should == LIMIT
+
+              fables.shift.destroy
+              Fable.get("title/#{title}").should == fables.collect(&:id)
+
+            end
+          end
+        end
+
+        describe 'when the index size is > limit of items' do
+          it 'deletes from the list' do
+            fables, title = [], 'title'
+            (LIMIT + 1).times { fables << Fable.create!(:title => title) }
+            Fable.get("title/#{title}").size.should > LIMIT
+
+            fables.shift.destroy
+            Fable.get("title/#{title}").should == fables.collect(&:id)
+          end
+        end
+      end
+
+      describe 'when the cache is not populated' do
+        describe 'when count of records in the database is <= limit of items' do
+          it 'deletes from the index' do
+            fables, title = [], 'title'
+            LIMIT.times { fables << Fable.create!(:title => title) }
+            $memcache.flush_all
+
+            fables.shift.destroy
+            Fable.get("title/#{title}").should == fables.collect(&:id)
+          end
+
+          describe 'when the count of records in the database is between limit and limit + buffer items' do
+            it 'populates the index' do
+              fables, title = [], 'title'
+              (LIMIT + BUFFER + 1).times { fables << Fable.create!(:title => title) }
+              BUFFER.times { fables.shift.destroy }
+              $memcache.flush_all
+
+              fables.shift.destroy
+              Fable.get("title/#{title}").should == fables.collect(&:id)
+
+            end
+          end
+
+          describe 'when the count of records in the database is > limit + buffer items' do
+            it 'populates the index with limit + buffer items' do
+              fables, title = [], 'title'
+              (LIMIT + BUFFER + 2).times { fables << Fable.create!(:title => title) }
+              $memcache.flush_all
+
+              fables.shift.destroy
+              Fable.get("title/#{title}").should == fables[0, LIMIT + BUFFER].collect(&:id)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cash/write_through_spec.rb

@@ -0,0 +1,245 @@
+require "spec_helper"
+
+module Cash
+  describe WriteThrough do
+    describe 'ClassMethods' do
+      describe 'after create' do
+        it "inserts all indexed attributes into the cache" do
+          story = Story.create!(:title => "I am delicious")
+          Story.get("title/#{story.title}").should == [story.id]
+          Story.get("id/#{story.id}").should == [story]
+        end
+
+        describe 'multiple objects' do
+          it "inserts multiple objects into the same cache key" do
+            story1 = Story.create!(:title => "I am delicious")
+            story2 = Story.create!(:title => "I am delicious")
+            Story.get("title/#{story1.title}").should == [story1.id, story2.id]
+          end
+
+          describe 'when the cache has been cleared after some objects were created' do
+            before do
+              @story1 = Story.create!(:title => "I am delicious")
+              $memcache.flush_all
+              @story2 = Story.create!(:title => "I am delicious")
+            end
+
+            it 'inserts legacy objects into the cache' do
+              Story.get("title/#{@story1.title}").should == [@story1.id, @story2.id]
+            end
+
+            it 'initializes the count to account for the legacy objects' do
+              Story.get("title/#{@story1.title}/count", :raw => true).should =~ /2/
+            end
+          end
+        end
+
+        it "does not write through the cache on non-indexed attributes" do
+          story = Story.create!(:title => "Story 1", :subtitle => "Subtitle")
+          Story.get("subtitle/#{story.subtitle}").should == nil
+        end
+
+        it "indexes on combinations of attributes" do
+          story = Story.create!(:title => "Sam")
+          Story.get("id/#{story.id}/title/#{story.title}").should == [story.id]
+        end
+
+        it "does not cache associations" do
+          story = Story.new(:title => 'I am lugubrious')
+          story.characters.build(:name => 'How am I holy?')
+          story.save!
+          Story.get("id/#{story.id}").first.characters.loaded?.should_not be
+        end
+
+        it 'increments the count' do
+          story = Story.create!(:title => "Sam")
+          Story.get("title/#{story.title}/count", :raw => true).should =~ /1/
+          story = Story.create!(:title => "Sam")
+          Story.get("title/#{story.title}/count", :raw => true).should =~ /2/
+        end
+
+        describe 'when the value is nil' do
+          it "does not write through the cache on indexed attributes" do
+            story = Story.create!(:title => nil)
+            Story.get("title/").should == nil
+          end
+        end
+      end
+
+      describe 'after update' do
+        it "overwrites the primary cache" do
+          story = Story.create!(:title => "I am delicious")
+          Story.get(cache_key = "id/#{story.id}").first.title.should == "I am delicious"
+          story.update_attributes(:title => "I am fabulous")
+          Story.get(cache_key).first.title.should == "I am fabulous"
+        end
+
+        it "populates empty caches" do
+          story = Story.create!(:title => "I am delicious")
+          $memcache.flush_all
+          story.update_attributes(:title => "I am fabulous")
+          Story.get("title/#{story.title}").should == [story.id]
+        end
+
+        it "removes from the affected index caches on update" do
+          story = Story.create!(:title => "I am delicious")
+          Story.get(cache_key = "title/#{story.title}").should == [story.id]
+          story.update_attributes(:title => "I am fabulous")
+          Story.get(cache_key).should == []
+        end
+
+        it 'increments/decrements the counts of affected indices' do
+          story = Story.create!(:title => original_title = "I am delicious")
+          story.update_attributes(:title => new_title = "I am fabulous")
+          Story.get("title/#{original_title}/count", :raw => true).should =~ /0/
+          Story.get("title/#{new_title}/count", :raw => true).should =~ /1/
+        end
+      end
+
+      describe 'after destroy' do
+        it "removes from the primary cache" do
+          story = Story.create!(:title => "I am delicious")
+          Story.get(cache_key = "id/#{story.id}").should == [story]
+          story.destroy
+          Story.get(cache_key).should == []
+        end
+
+        it "removes from the the cache on keys matching the original values of attributes" do
+          story = Story.create!(:title => "I am delicious")
+          Story.get(cache_key = "title/#{story.title}").should == [story.id]
+          story.title = "I am not delicious"
+          story.destroy
+          Story.get(cache_key).should == []
+        end
+
+        it 'decrements the count' do
+          story = Story.create!(:title => "I am delicious")
+          story.destroy
+          Story.get("title/#{story.title}/count", :raw => true).should =~ /0/
+        end
+
+        describe 'when there are multiple items in the index' do
+          it "only removes one item from the affected indices, not all of them" do
+            story1 = Story.create!(:title => "I am delicious")
+            story2 = Story.create!(:title => "I am delicious")
+            Story.get(cache_key = "title/#{story1.title}").should == [story1.id, story2.id]
+            story1.destroy
+            Story.get(cache_key).should == [story2.id]
+          end
+        end
+
+        describe 'when the object is a new record' do
+          it 'does nothing' do
+            story1 = Story.new
+            mock(Story).set.never
+            story1.destroy
+          end
+        end
+
+        describe 'when the cache is not yet populated' do
+          it "populates the cache with data" do
+            story1 = Story.create!(:title => "I am delicious")
+            story2 = Story.create!(:title => "I am delicious")
+            $memcache.flush_all
+            Story.get(cache_key = "title/#{story1.title}").should == nil
+            story1.destroy
+            Story.get(cache_key).should == [story2.id]
+          end
+        end
+
+        describe 'when the value is nil' do
+          it "does not delete through the cache on indexed attributes when the value is nil" do
+            story = Story.create!(:title => nil)
+            story.destroy
+            Story.get("title/").should == nil
+          end
+        end
+      end
+
+      describe 'InstanceMethods' do
+        describe '#expire_caches' do
+          it 'deletes the index' do
+            story = Story.create!(:title => "I am delicious")
+            Story.get(cache_key = "id/#{story.id}").should == [story]
+            story.expire_caches
+            Story.get(cache_key).should be_nil
+          end
+        end
+      end
+    end
+
+    describe "Locking" do
+      it "acquires and releases locks, in order, for all indices to be written" do
+        pending
+
+        story = Story.create!(:title => original_title = "original title")
+        story.title = tentative_title = "tentative title"
+        keys = ["id/#{story.id}", "title/#{original_title}", "title/#{story.title}", "id/#{story.id}/title/#{original_title}", "id/#{story.id}/title/#{tentative_title}"]
+
+        locks_should_be_acquired_and_released_in_order($lock, keys)
+        story.save!
+      end
+
+      it "acquires and releases locks on destroy" do
+        pending
+
+        story = Story.create!(:title => "title")
+        keys = ["id/#{story.id}", "title/#{story.title}", "id/#{story.id}/title/#{story.title}"]
+
+        locks_should_be_acquired_and_released_in_order($lock, keys)
+        story.destroy
+      end
+
+      def locks_should_be_acquired_and_released_in_order(lock, keys)
+        mock = keys.sort!.inject(mock = mock($lock)) do |mock, key|
+          mock.acquire_lock.with(Story.cache_key(key)).then
+        end
+        keys.inject(mock) do |mock, key|
+          mock.release_lock.with(Story.cache_key(key)).then
+        end
+      end
+    end
+
+    describe "Single Table Inheritence" do
+      describe 'A subclass' do
+        it "writes to indices of all superclasses" do
+          oral = Oral.create!(:title => 'title')
+          Story.get("title/#{oral.title}").should == [oral.id]
+          Epic.get("title/#{oral.title}").should == [oral.id]
+          Oral.get("title/#{oral.title}").should == [oral.id]
+        end
+
+        describe 'when one ancestor has its own indices' do
+          it "it only populates those indices for that ancestor" do
+            oral = Oral.create!(:subtitle => 'subtitle')
+            Story.get("subtitle/#{oral.subtitle}").should be_nil
+            Epic.get("subtitle/#{oral.subtitle}").should be_nil
+            Oral.get("subtitle/#{oral.subtitle}").should == [oral.id]
+          end
+        end
+      end
+    end
+    
+    describe 'Transactions' do
+      def create_story_and_update
+        @story = Story.create!(:title => original_title = "original title")
+        
+        Story.transaction do
+          @story.title = "new title"
+          @story.save
+          yield if block_given?
+        end
+      end
+      
+      it 'should commit on success' do
+        create_story_and_update
+        @story.reload.title.should == "new title"
+      end
+      
+      it 'should roll back transactions when ActiveRecord::Rollback is raised' do
+        create_story_and_update { raise ActiveRecord::Rollback }
+        @story.reload.title.should == "original title"
+      end
+    end
+  end
+end

data/spec/memcached_wrapper_test.rb

@@ -0,0 +1,209 @@
+require 'test_helper'
+require 'memcache'
+
+class MemcachedWrapperTest < ActiveSupport::TestCase
+
+  context "with single memcached server" do
+
+    setup do
+      @wrapper = MemcachedWrapper.new("127.0.0.1:11211", {:namespace => "wrapper", :show_backtraces => true, :support_cas => true})
+      @memcache = MemCache.new("127.0.0.1:11211", {:namespace => "memcache"})
+      @wrapper.flush_all
+      @memcache.flush_all
+    end
+    
+    teardown do
+      @wrapper.close
+      @memcache.reset
+    end
+
+    should "add" do
+      assert_equal(@wrapper.add("blah/toe", "blah"),  @memcache.add("blah/toe", "blah"))
+      assert_equal(@wrapper.get("blah/toe"),          @memcache.get("blah/toe"))
+      assert_equal(@wrapper.add("blah/toe", "blah2"), @memcache.add("blah/toe", "blah2"))
+      assert_equal(@wrapper.get("blah/toe"),          @memcache.get("blah/toe"))
+    end
+    
+    should "replace" do
+      assert_equal(@wrapper.replace("blah/toe", "blah"),  @memcache.replace("blah/toe", "blah"))
+      assert_equal(@wrapper.add("blah/toe", "blah"),      @memcache.add("blah/toe", "blah"))
+      assert_equal(@wrapper.replace("blah/toe", "blah2"), @memcache.replace("blah/toe", "blah2"))
+      assert_equal(@wrapper.get("blah/toe"),              @memcache.get("blah/toe"))
+    end
+    
+    should "get" do
+      assert_equal(@wrapper.add("blah/toe", "blah"), @memcache.add("blah/toe", "blah"))
+      assert_equal(@wrapper.get("blah/toe"),         @memcache.get("blah/toe"))
+    end
+    
+    should "fetch" do
+      assert_equal(@wrapper.fetch("blah/toe") { "blah" },  @memcache.fetch("blah/toe") { "blah" })
+      assert_equal(@wrapper.fetch("blah/toe") { "blah2" }, @memcache.fetch("blah/toe") { "blah2" })
+    end
+    
+    should "compare and swap" do
+      assert_equal(@wrapper.cas("blah/toe") { "blah" },  @memcache.cas("blah/toe") { "blah" })
+      assert_equal(@wrapper.add("blah/toe", "blah"),     @memcache.add("blah/toe", "blah"))
+      assert_equal(@wrapper.cas("blah/toe") { "blah2" }, @memcache.cas("blah/toe") { "blah2" })
+      assert_equal(@wrapper.get("blah/toe"),             @memcache.get("blah/toe"))
+    end
+    
+    should "get multiple" do
+      assert_equal(@wrapper.add("blah/toe", "blah"),     @memcache.add("blah/toe", "blah"))
+      assert_equal(@wrapper.add("blah/finger", "blah2"), @memcache.add("blah/finger", "blah2"))
+      assert_equal(@wrapper.get_multi(["blah/toe", "blah/finger"]), @memcache.get_multi(["blah/toe", "blah/finger"]))
+    end
+    
+    should "set" do
+      assert_equal(@wrapper.set("blah/toe", "blah"), @memcache.set("blah/toe", "blah"))
+      assert_equal(@wrapper.get("blah/toe"),         @memcache.get("blah/toe"))
+    end
+    
+    should "append" do
+      assert_equal(@wrapper.append("blah/toe", "blah"), @memcache.append("blah/toe", "blah"))
+      assert_equal(@wrapper.get("blah/toe"),            @memcache.get("blah/toe"))
+
+      assert_equal(@wrapper.set("blah/toe", "blah", 0, true), @memcache.set("blah/toe", "blah", 0, true))
+      assert_equal(@wrapper.get("blah/toe", true),            @memcache.get("blah/toe", true))
+      assert_equal(@wrapper.append("blah/toe", "blah2"),      @memcache.append("blah/toe", "blah2"))
+      assert_equal(@wrapper.get("blah/toe", true),            @memcache.get("blah/toe", true))
+    end
+    
+    should "prepend" do
+      assert_equal(@wrapper.prepend("blah/toe", "blah"), @memcache.prepend("blah/toe", "blah"))
+      assert_equal(@wrapper.get("blah/toe"),             @memcache.get("blah/toe"))
+    
+      assert_equal(@wrapper.set("blah/toe", "blah", 0, true), @memcache.set("blah/toe", "blah", 0, true))
+      assert_equal(@wrapper.prepend("blah/toe", "blah2"),     @memcache.prepend("blah/toe", "blah2"))
+      assert_equal(@wrapper.get("blah/toe", true),            @memcache.get("blah/toe", true))
+    end
+    
+    should "delete" do
+      assert_equal(@wrapper.delete("blah/toe"),      @memcache.delete("blah/toe"))
+      assert_equal(@wrapper.set("blah/toe", "blah"), @memcache.set("blah/toe", "blah"))
+      assert_equal(@wrapper.delete("blah/toe"),      @memcache.delete("blah/toe"))
+    end
+    
+    should "increment" do
+      assert_equal(@wrapper.incr("blah/count"),            @memcache.incr("blah/count"))
+      assert_equal(@wrapper.set("blah/count", 0, 0, true), @memcache.set("blah/count", 0, 0, true))
+      assert_equal(@wrapper.incr("blah/count"),            @memcache.incr("blah/count"))
+    end
+    
+    should "decrement" do
+      assert_equal(@wrapper.decr("blah/count"),            @memcache.decr("blah/count")) 
+      assert_equal(@wrapper.set("blah/count", 2, 0, true), @memcache.set("blah/count", 2, 0, true))
+      assert_equal(@wrapper.decr("blah/count"),            @memcache.decr("blah/count"))
+    end
+
+    # should "stats" do
+    #   assert_equal(@wrapper.stats(), @memcache.stats())
+    # end
+
+  end
+
+  # context "with two memcached servers" do
+  # 
+  #   setup do
+  #     @wrapper = MemcachedWrapper.new(["127.0.0.1:11211", "127.0.0.1:1111"], {:show_backtraces => true, :support_cas => true})
+  #     # @wrapper = MemCache.new(["127.0.0.1:11211", "127.0.0.1:1111"], {:show_backtraces => true, :support_cas => true})
+  #     @wrapper.flush_all
+  #   end
+  #   
+  #   teardown do
+  #     # @wrapper.close
+  #   end
+  # 
+  #   should "add value" do
+  #     assert_stored(@wrapper.add("blah/toe", "blah"))
+  #     assert_equal( "blah", @wrapper.get("blah/toe"))
+  #     assert_not_stored(@wrapper.add("blah/toe", "blah2"))
+  #     assert_equal( "blah", @wrapper.get("blah/toe"))
+  #   end
+  #   
+  #   should "get value" do
+  #     assert_stored(@wrapper.add("blah/toe", "blah"))
+  #     assert_equal( "blah", @wrapper.get("blah/toe"))
+  #   end
+  #   
+  #   should "fetch value" do
+  #     assert_equal( "blah", @wrapper.fetch("blah/toe") { "blah" })
+  #     assert_equal( "blah", @wrapper.fetch("blah/toe") { "blah2" })
+  #   end
+  #   
+  #   should "check and set value" do
+  #     assert_nil(   @wrapper.cas("blah/toe") { "blah" })
+  #     assert_stored(@wrapper.add("blah/toe", "blah"))
+  #     assert_stored(@wrapper.cas("blah/toe") { "blah2" })
+  #     assert_equal( "blah2", @wrapper.get("blah/toe"))
+  #   end
+  #   
+  #   should "get multiple values" do
+  #     assert_stored(@wrapper.add("blah/toe", "blah"))
+  #     assert_stored(@wrapper.add("blah/finger", "blah2"))
+  #     assert_equal( {'blah/toe'=>'blah','blah/finger'=>'blah2'}, @wrapper.get_multi(["blah/toe", "blah/finger"]))
+  #   end
+  #   
+  #   should "set value" do
+  #     assert_stored(@wrapper.set("blah/toe", "blah"))
+  #     assert_equal( "blah", @wrapper.get("blah/toe"))
+  #   end
+  #   
+  #   should "append value" do
+  #     assert_not_stored( @wrapper.append("blah/toe", "blah"))
+  #     assert_nil( @wrapper.get("blah/toe"))
+  # 
+  #     assert_stored( @wrapper.set("blah/toe", "blah", 0, true))
+  #     assert_equal(  "blah", @wrapper.get("blah/toe", true))
+  #     assert_stored( @wrapper.append("blah/toe", "blah2"))
+  #     assert_equal(  "blahblah2", @wrapper.get("blah/toe", true))
+  #   end
+  #   
+  #   should "prepend value" do
+  #     assert_not_stored(@wrapper.prepend("blah/toe", "blah"))
+  #     assert_nil( @wrapper.get("blah/toe"))
+  #   
+  #     assert_stored( @wrapper.set("blah/toe", "blah", 0, true))
+  #     assert_stored( @wrapper.prepend("blah/toe", "blah2"))
+  #     assert_equal(  "blah2blah", @wrapper.get("blah/toe", true))
+  #   end
+  #   
+  #   should "delete value" do
+  #     assert_not_found( @wrapper.delete("blah/toe"))
+  #     assert_stored(    @wrapper.set("blah/toe", "blah"))
+  #     assert_deleted(   @wrapper.delete("blah/toe"))
+  #   end
+  #   
+  #   should "increment value" do
+  #     assert_nil(   @wrapper.incr("blah/count"))
+  #     assert_stored(@wrapper.set("blah/count", 0, 0, true))
+  #     assert_equal( 1, @wrapper.incr("blah/count"))
+  #   end
+  #   
+  #   should "decrement value" do
+  #     assert_nil(   @wrapper.decr("blah/count")) 
+  #     assert_stored(@wrapper.set("blah/count", 2, 0, true))
+  #     assert_equal( 1, @wrapper.decr("blah/count"))
+  #   end
+  # 
+  # end
+
+private
+
+  def assert_stored(val)
+    assert_equal("STORED\r\n", val)
+  end
+
+  def assert_deleted(val)
+    assert_equal("DELETED\r\n", val)
+  end
+
+  def assert_not_stored(val)
+    assert_equal("NOT_STORED\r\n", val)
+  end
+
+  def assert_not_found(val)
+    assert_equal("NOT_FOUND\r\n", val)
+  end
+
+end