nkallen-cash 0.1.1

data/spec/cash/window_spec.rb

@@ -0,0 +1,195 @@
+require File.join(File.dirname(__FILE__), '..', '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,223 @@
+require File.join(File.dirname(__FILE__), '..', '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
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{dir}/../lib"
+
+require 'rubygems'
+require 'spec'
+require 'pp'
+require 'cash'
+require 'memcache'
+require File.join(dir, '../config/environment')
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+  config.before :suite do
+    config = YAML.load(IO.read((File.expand_path(File.dirname(__FILE__) + "/../config/memcache.yml"))))['test']
+    $memcache = MemCache.new(config)
+    $memcache.servers = config['servers']
+    $lock = Cash::Lock.new($memcache)
+  end
+
+  config.before :each do
+    $memcache.flush_all
+    Story.delete_all
+    Character.delete_all
+  end
+
+  config.before :suite do
+    ActiveRecord::Base.class_eval do
+      is_cached :repository => Cash::Transactional.new($memcache, $lock)
+    end
+
+    Character = Class.new(ActiveRecord::Base)
+    Story = Class.new(ActiveRecord::Base)
+    Story.has_many :characters
+
+    Story.class_eval do
+      index :title
+      index [:id, :title]
+    end
+
+    Epic = Class.new(Story)
+    Oral = Class.new(Epic)
+
+    Character.class_eval do
+      index [:name, :story_id]
+      index [:id, :story_id]
+      index [:id, :name, :story_id]
+    end
+
+    Oral.class_eval do
+      index :subtitle
+    end
+  end
+end