artemk-cache-money 0.2.13.2

data/spec/cash/finders_spec.rb

@@ -0,0 +1,408 @@
+require "spec_helper"
+
+module Cash
+  describe Finders do
+    describe 'Cache Usage' do
+      describe 'when the cache is populated' do
+        describe '#find' do
+          describe '#find(1)' do
+            it 'does not use the database' do
+              story = Story.create!
+              mock(Story.connection).execute.never
+              Story.find(story.id).should == story
+            end
+          end
+
+          describe '#find(object)' do
+            it 'uses the objects quoted id' do
+              story = Story.create!
+              mock(Story.connection).execute.never
+              Story.find(story).should == story
+            end
+          end
+
+          describe '#find(:first, ...)' do
+            describe '#find(:first, :conditions => { :id => ? })' do
+              it "does not use the database" do
+                story = Story.create!
+                mock(Story.connection).execute.never
+                Story.find(:first, :conditions => { :id => story.id }).should == story
+              end
+            end
+
+            describe '#find(:first, :conditions => [ "id = :id", { :id => story.id } ])' do
+              it "does not use the database" do
+                story = Story.create!
+                mock(Story.connection).execute.never
+                Story.find(:first, :conditions => [ "id = :id", { :id => story.id } ]).should == story
+              end
+            end
+
+            describe "#find(:first, :conditions => 'id = ?')" do
+              it "does not use the database" do
+                story = Story.create!
+                mock(Story.connection).execute.never
+                Story.find(:first, :conditions => "id = #{story.id}").should == story
+                Story.find(:first, :conditions => "`stories`.id = #{story.id}").should == story
+                Story.find(:first, :conditions => "`stories`.`id` = #{story.id}").should == story
+              end
+            end
+
+            describe '#find(:first, :readonly => false) and any other options other than conditions are nil' do
+              it "does not use the database" do
+                story = Story.create!
+                mock(Story.connection).execute.never
+                Story.find(:first, :conditions => { :id => story.id }, :readonly => false, :limit => nil, :offset => nil, :joins => nil, :include => nil).should == story
+              end
+            end
+
+            describe '#find(:first, :readonly => true)' do
+              it "uses the database, not the cache" do
+                story = Story.create!
+                mock(Story).get.never
+                Story.find(:first, :conditions => { :id => story.id }, :readonly => true).should == story
+              end
+            end
+
+            describe '#find(:first, :join => ...) or find(..., :include => ...)' do
+              it "uses the database, not the cache" do
+                story = Story.create!
+                mock(Story).get.never
+                Story.find(:first, :conditions => { :id => story.id }, :joins => 'AS stories').should == story
+                Story.find(:first, :conditions => { :id => story.id }, :include => :characters).should == story
+              end
+            end
+
+            describe '#find(:first)' do
+              it 'uses the database, not the cache' do
+                mock(Story).get.never
+                Story.find(:first)
+              end
+            end
+
+            describe '#find(:first, :conditions => "...")' do
+              describe 'on unindexed attributes' do
+                it 'uses the database, not the cache' do
+                  story = Story.create!
+                  mock(Story).get.never
+                  Story.find(:first, :conditions => "type IS NULL")
+                end
+              end
+
+              describe 'on indexed attributes' do
+                describe 'when the attributes are integers' do
+                  it 'does not use the database' do
+                    story = Story.create!
+                    mock(Story.connection).execute.never
+                    Story.find(:first, :conditions => "`stories`.id = #{story.id}") \
+                      .should == story
+                  end
+                end
+
+                describe 'when the attributes are non-integers' do
+                  it 'uses the database, not the cache' do
+                    story = Story.create!(:title => "title")
+                    mock(Story.connection).execute.never
+                    Story.find(:first, :conditions => "`stories`.title = '#{story.title }'") \
+                      .should == story
+                  end
+                end
+                
+                describe 'when the attributes must be coerced to sql values' do
+                  it 'does not use the database' do
+                    story1 = Story.create!(:published => true)
+                    story2 = Story.create!(:published => false)
+                    mock(Story.connection).execute.never
+                    Story.find(:first, :conditions => 'published = 0').should == story2
+                  end
+                end
+              end
+
+              describe '#find(:first, :conditions => [...])' do
+                describe 'with one indexed attribute' do
+                  it 'does not use the database' do
+                    story = Story.create!
+                    mock(Story.connection).execute.never
+                    Story.find(:first, :conditions => ['id = ?', story.id]).should == story
+                  end
+                end
+
+                describe 'with two attributes that match a combo-index' do
+                  it 'does not use the database' do
+                    story = Story.create!(:title => 'title')
+                    mock(Story.connection).execute.never
+                    Story.find(:first, :conditions => ['id = ? AND title = ?', story.id, story.title]).should == story
+                  end
+                end
+              end
+            end
+
+            describe '#find(:first, :conditions => {...})' do
+              it "does not use the database" do
+                story = Story.create!(:title => "Sam")
+                mock(Story.connection).execute.never
+                Story.find(:first, :conditions => { :id => story.id, :title => story.title }).should == story
+              end
+
+              describe 'regardless of hash order' do
+                it 'does not use the database' do
+                  story = Story.create!(:title => "Sam")
+                  mock(Story.connection).execute.never
+                  Story.find(:first, :conditions => { :id => story.id, :title => story.title }).should == story
+                  Story.find(:first, :conditions => { :title => story.title, :id => story.id }).should == story
+                end
+              end
+
+              describe 'on unindexed attribtes' do
+                it 'uses the database, not the cache' do
+                  story = Story.create!
+                  mock(Story).get.never
+                  Story.find(:first, :conditions => { :id => story.id, :type => story.type }).should == story
+                end
+              end
+            end
+          end
+
+          describe 'when there is a with_scope' do
+            describe 'when the with_scope has conditions' do
+              describe 'when the scope conditions is a string' do
+                it "uses the database, not the cache" do
+                  story = Story.create!(:title => title = 'title')
+                  mock(Story.connection).execute.never
+                  Story.send :with_scope, :find => { :conditions => "title = '#{title}'"} do
+                    Story.find(:first, :conditions => { :id => story.id }).should == story
+                  end
+                end
+              end
+
+              describe 'when the find conditions is a string' do
+                it "does not use the database" do
+                  story = Story.create!(:title => title = 'title')
+                  mock(Story.connection).execute.never
+                  Story.send :with_scope, :find => { :conditions => { :id => story.id }} do
+                    Story.find(:first, :conditions => "title = '#{title}'").should == story
+                  end
+                end
+              end
+
+              describe '#find(1, :conditions => ...)' do
+                it "does not use the database" do
+                  story = Story.create!
+                  character = Character.create!(:name => name = 'barbara', :story_id => story)
+                  mock(Character.connection).execute.never
+                  Character.send :with_scope, :find => { :conditions => { :story_id => story.id } } do
+                    Character.find(character.id, :conditions => { :name => name }).should == character
+                  end
+                end
+              end
+            end
+
+            describe 'has_many associations' do
+              describe '#find(1)' do
+                it "does not use the database" do
+                  story = Story.create!
+                  character = story.characters.create!
+                  mock(Character.connection).execute.never
+                  story.characters.find(character.id).should == character
+                end
+              end
+
+              describe '#find(1, 2, ...)' do
+                it "does not use the database" do
+                  story = Story.create!
+                  character1 = story.characters.create!
+                  character2 = story.characters.create!
+                  mock(Character.connection).execute.never
+                  story.characters.find(character1.id, character2.id).should == [character1, character2]
+                end
+              end
+
+              describe '#find_by_attr' do
+                it "does not use the database" do
+                  story = Story.create!
+                  character = story.characters.create!
+                  mock(Character.connection).execute.never
+                  story.characters.find_by_id(character.id).should == character
+                end
+              end
+            end
+          end
+
+          describe '#find(:all)' do
+            it "uses the database, not the cache" do
+              character = Character.create!
+              mock(Character).get.never
+              Character.find(:all).should == [character]
+            end
+
+            describe '#find(:all, :conditions => {...})' do
+              describe 'when the index is not empty' do
+                it 'does not use the database' do
+                  story1 = Story.create!(:title => title = "title")
+                  story2 = Story.create!(:title => title)
+                  mock(Story.connection).execute.never
+                  Story.find(:all, :conditions => { :title => story1.title }).should == [story1, story2]
+                end
+              end
+            end
+
+            describe '#find(:all, :limit => ..., :offset => ...)' do
+              it "cached attributes should support limits and offsets" do
+                character1 = Character.create!(:name => "Sam", :story_id => 1)
+                character2 = Character.create!(:name => "Sam", :story_id => 1)
+                character3 = Character.create!(:name => "Sam", :story_id => 1)
+                mock(Character.connection).execute.never
+
+                Character.find(:all, :conditions => { :name => character1.name, :story_id => character1.story_id }, :limit => 1).should == [character1]
+                Character.find(:all, :conditions => { :name => character1.name, :story_id => character1.story_id }, :offset => 1).should == [character2, character3]
+                Character.find(:all, :conditions => { :name => character1.name, :story_id => character1.story_id }, :limit => 1, :offset => 1).should == [character2]
+              end
+            end
+          end
+
+          describe '#find([...])' do
+            describe '#find([1, 2, ...], :conditions => ...)' do
+              it "uses the database, not the cache" do
+                story1, story2 = Story.create!, Story.create!
+                mock(Story).get.never
+                Story.find([story1.id, story2.id], :conditions => "type IS NULL").should == [story1, story2]
+              end
+            end
+
+            describe '#find([1], :conditions => ...)' do
+              it "uses the database, not the cache" do
+                story1, story2 = Story.create!, Story.create!
+                mock(Story).get.never
+                Story.find([story1.id], :conditions => "type IS NULL").should == [story1]
+              end
+            end
+          end
+
+          describe '#find_by_attr' do
+            describe 'on indexed attributes' do
+              describe '#find_by_id(id)' do
+                it "does not use the database" do
+                  story = Story.create!
+                  mock(Story.connection).execute.never
+                  Story.find_by_id(story.id).should == story
+                end
+              end
+
+              describe '#find_by_title(title)' do
+                it "does not use the database" do
+                  story1 = Story.create!(:title => 'title1')
+                  story2 = Story.create!(:title => 'title2')
+                  mock(Story.connection).execute.never
+                  Story.find_by_title('title1').should == story1
+                end
+              end
+            end
+          end
+
+          describe "Single Table Inheritence" do
+            describe '#find(:all, ...)' do
+              it "does not use the database" do
+                story, epic, oral = Story.create!(:title => title = 'foo'), Epic.create!(:title => title), Oral.create!(:title => title)
+                mock(Story.connection).execute.never
+                Story.find(:all, :conditions => { :title => title }).should == [story, epic, oral]
+                Epic.find(:all, :conditions => { :title => title }).should == [epic, oral]
+                Oral.find(:all, :conditions => { :title => title }).should == [oral]
+              end
+            end
+          end
+        end
+
+        describe '#without_cache' do
+          describe 'when finders are called within the provided block' do
+            it 'uses the database not the cache' do
+              story = Story.create!
+              mock(Story).get.never
+              Story.without_cache do
+                Story.find(story.id).should == story
+              end
+            end
+          end
+        end
+      end
+
+      describe 'when the cache is not populated' do
+        before do
+          @story = Story.create!(:title => 'title')
+          $memcache.flush_all
+        end
+
+        describe '#find(:first, ...)' do
+          it 'populates the cache' do
+            Story.find(:first, :conditions => { :title => @story.title })
+            Story.fetch("title/#{@story.title}").should == [@story.id]
+          end
+        end
+
+        describe '#find_by_attr' do
+          before(:each) do
+            Story.find_by_title(@story.title)  # populates cache for title with [@story.id]
+          end
+          
+          it 'populates the cache' do
+            Story.fetch("title/#{@story.title}").should == [@story.id]
+          end
+          
+          it 'populates the cache when finding by non-primary-key attribute' do
+            Story.find_by_title(@story.title)  # populates cache for id with record
+            
+            mock(Story.connection).execute.never  # should hit cache only
+            Story.find_by_title(@story.title).id.should == @story.id
+          end
+        end
+
+        describe '#find(:all, :conditions => ...)' do
+          it 'populates the cache' do
+            Story.find(:all, :conditions => { :title => @story.title })
+            Story.fetch("title/#{@story.title}").should == [@story.id]
+          end
+        end
+
+        describe '#find(:all, :conditions => ..., :order => ...)' do
+          before(:each) do
+            @short1 = Short.create(:title => 'title',
+              :subtitle => 'subtitle')
+            @short2 = Short.create(:title => 'another title',
+              :subtitle => 'subtitle')
+            $memcache.flush_all
+            Short.find(:all, :conditions => { :subtitle => @short1.subtitle },
+              :order => 'title')
+          end
+
+          it 'populates the cache' do
+            Short.fetch("subtitle/subtitle").should_not be_blank
+          end
+
+          it 'returns objects in the correct order' do
+            Short.fetch("subtitle/subtitle").should ==
+              [@short2.id, @short1.id]
+          end
+
+          it 'finds objects in the correct order' do
+            Short.find(:all, :conditions => { :subtitle => @short1.subtitle },
+              :order => 'title').map(&:id).should == [@short2.id, @short1.id]
+          end
+        end
+
+        describe '#find(1)' do
+          it 'populates the cache' do
+            Story.find(@story.id)
+            Story.fetch("id/#{@story.id}").should == [@story]
+          end
+        end
+
+        describe 'when there is a with_scope' do
+          it "uses the database, not the cache" do
+            Story.send :with_scope, :find => { :conditions => { :title => @story.title }} do
+              Story.find(:first, :conditions => { :id => @story.id }).should == @story
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cash/local_buffer_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+module Cash
+  describe LocalBuffer do
+    it "should have method missing as a private method" do
+      LocalBuffer.private_instance_methods.should include("method_missing")
+    end
+  end
+end

data/spec/cash/local_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+module Cash
+  describe Local do
+    it "should have method missing as a private method" do
+      Local.private_instance_methods.should include("method_missing")
+    end
+  end
+end

data/spec/cash/lock_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+module Cash
+  describe Lock do
+    describe '#synchronize' do
+      it "yields the block" do
+        block_was_called = false
+        $lock.synchronize('lock_key') do
+          block_was_called = true
+        end
+        block_was_called.should == true
+      end
+
+      it "acquires the specified lock before the block is run" do
+        $memcache.get("lock/lock_key").should == nil
+        $lock.synchronize('lock_key') do
+           $memcache.get("lock/lock_key").should_not == nil
+         end
+      end
+
+      it "releases the lock after the block is run" do
+        $memcache.get("lock/lock_key").should == nil
+        $lock.synchronize('lock_key') {}
+        $memcache.get("lock/lock_key").should == nil
+      end
+
+      it "releases the lock even if the block raises" do
+        $memcache.get("lock/lock_key").should == nil
+        $lock.synchronize('lock_key') { raise } rescue nil
+        $memcache.get("lock/lock_key").should == nil
+      end
+
+      it "does not block on recursive lock acquisition" do
+        $lock.synchronize('lock_key') do
+          lambda { $lock.synchronize('lock_key') {} }.should_not raise_error
+        end
+      end
+    end
+
+    describe '#acquire_lock' do
+      it "creates a lock at a given cache key" do
+        $memcache.get("lock/lock_key").should == nil
+        $lock.acquire_lock("lock_key")
+        $memcache.get("lock/lock_key").should_not == nil
+      end
+
+      describe 'when given a timeout for the lock' do
+        it "correctly sets timeout on memcache entries" do
+          mock($memcache).add('lock/lock_key', "#{Socket.gethostname} #{Process.pid}", timeout = 10) { true }
+          # $lock.acquire_lock('lock_key', timeout)
+          lambda { $lock.acquire_lock('lock_key', timeout, 1) }.should raise_error
+        end
+      end
+
+      describe 'when to processes contend for a lock' do
+        it "prevents two processes from acquiring the same lock at the same time" do
+          $lock.acquire_lock('lock_key')
+          as_another_process do
+            stub($lock).exponential_sleep
+            lambda { $lock.acquire_lock('lock_key') }.should raise_error
+          end
+        end
+        
+        describe 'when given a number of times to retry' do
+          it "retries specified number of times" do
+            $lock.acquire_lock('lock_key')
+            as_another_process do
+              mock($memcache).add("lock/lock_key", "#{Socket.gethostname} #{Process.pid}", timeout = 10) { false }.times(retries = 3)
+              stub($lock).exponential_sleep
+              lambda { $lock.acquire_lock('lock_key', timeout, retries) }.should raise_error
+            end
+          end
+        end
+        
+        describe 'when given an initial wait' do
+          it 'sleeps exponentially starting with the initial wait' do
+            stub($lock).sleep(initial_wait = 0.123)
+            stub($lock).sleep(2 * initial_wait)
+            stub($lock).sleep(4 * initial_wait)
+            stub($lock).sleep(8 * initial_wait)
+            $lock.acquire_lock('lock_key')
+            as_another_process do
+              lambda { $lock.acquire_lock('lock_key', Lock::DEFAULT_EXPIRY, Lock::DEFAULT_RETRY, initial_wait) }.should raise_error
+            end            
+          end
+        end
+
+        def as_another_process
+          current_pid = Process.pid
+          stub(Process).pid { current_pid + 1 }
+          yield
+        end
+        
+      end
+
+    end
+
+    describe '#release_lock' do
+      it "deletes the lock for a given cache key" do
+        $memcache.get("lock/lock_key").should == nil
+        $lock.acquire_lock("lock_key")
+        $memcache.get("lock/lock_key").should_not == nil
+        $lock.release_lock("lock_key")
+        $memcache.get("lock/lock_key").should == nil
+      end
+    end
+  end
+end