artemk-cache-money 0.2.13.2

data/spec/cash/accessor_spec.rb

@@ -0,0 +1,186 @@
+require "spec_helper"
+require 'ruby-debug'
+
+module Cash
+  describe Accessor do
+    describe '#fetch' do
+      describe '#fetch("...")' do
+        describe 'when there is a cache miss' do
+          it 'returns nil' do
+            Story.fetch("yabba").should be_nil
+          end
+        end
+
+        describe 'when there is a cache hit' do
+          it 'returns the value of the cache' do
+            Story.set("yabba", "dabba")
+            Story.fetch("yabba").should == "dabba"
+          end
+        end
+      end
+
+      describe '#fetch([...])', :shared => true do
+        describe '#fetch([])' do
+          it 'returns the empty hash' do
+            Story.fetch([]).should == {}
+          end
+        end
+        
+        describe 'when there is a total cache miss' do
+          it 'yields the keys to the block' do
+            Story.fetch(["yabba", "dabba"]) { |*missing_ids| ["doo", "doo"] }.should == {
+              "Story:1/yabba" => "doo",
+              "Story:1/dabba" => "doo"
+            }
+          end
+        end
+
+        describe 'when there is a partial cache miss' do
+          it 'yields just the missing ids to the block' do
+            Story.set("yabba", "dabba")
+            Story.fetch(["yabba", "dabba"]) { |*missing_ids| "doo" }.should == {
+              "Story:1/yabba" => "dabba",
+              "Story:1/dabba" => "doo"
+            }
+          end
+        end
+      end
+    end
+
+    describe '#get' do
+      describe '#get("...")' do
+        describe 'when there is a cache miss' do
+          it 'returns the value of the block' do
+            Story.get("yabba") { "dabba" }.should == "dabba"
+          end
+
+          it 'adds to the cache' do
+            Story.get("yabba") { "dabba" }
+            Story.get("yabba").should == "dabba"
+          end
+        end
+
+        describe 'when there is a cache hit' do
+          before do
+            Story.set("yabba", "dabba")
+          end
+
+          it 'returns the value of the cache' do
+            Story.get("yabba") { "doo" }.should == "dabba"
+          end
+
+          it 'does nothing to the cache' do
+            Story.get("yabba") { "doo" }
+            Story.get("yabba").should == "dabba"
+          end
+        end
+      end
+
+      describe '#get([...])' do
+        it_should_behave_like "#fetch([...])"
+      end
+    end
+
+    describe '#add' do
+      describe 'when the value already exists' do
+        describe 'when a block is given' do
+          it 'yields to the block' do
+            Story.set("count", 1)
+            Story.add("count", 1) { "yield me" }.should == "yield me"
+          end
+        end
+        
+        describe 'when no block is given' do
+          it 'does not error' do
+            Story.set("count", 1)
+            lambda { Story.add("count", 1) }.should_not raise_error
+          end
+        end
+      end
+
+      describe 'when the value does not already exist' do
+        it 'adds the key to the cache' do
+          Story.add("count", 1)
+          Story.get("count").should == 1
+        end
+      end
+    end
+
+    describe '#set' do
+    end
+    
+    describe '#incr' do
+      describe 'when there is a cache hit' do
+        before do
+          Story.set("count", 0, :raw => true)
+        end
+
+        it 'increments the value of the cache' do
+          Story.incr("count", 2)
+          Story.get("count", :raw => true).should =~ /2/
+        end
+
+        it 'returns the new cache value' do
+          Story.incr("count", 2).should == 2
+        end
+      end
+
+      describe 'when there is a cache miss' do
+        it 'initializes the value of the cache to the value of the block' do
+          Story.incr("count", 1) { 5 }
+          Story.get("count", :raw => true).should =~ /5/
+        end
+
+        it 'returns the new cache value' do
+          Story.incr("count", 1) { 2 }.should == 2
+        end
+      end
+    end
+
+    describe '#decr' do
+      describe 'when there is a cache hit' do
+        before do
+          Story.incr("count", 1) { 10 }
+        end
+
+        it 'decrements the value of the cache' do
+          Story.decr("count", 2)
+          Story.get("count", :raw => true).should =~ /8/
+        end
+
+        it 'returns the new cache value' do
+          Story.decr("count", 2).should == 8
+        end
+      end
+
+      describe 'when there is a cache miss' do
+        it 'initializes the value of the cache to the value of the block' do
+          Story.decr("count", 1) { 5 }
+          Story.get("count", :raw => true).should =~ /5/
+        end
+
+        it 'returns the new cache value' do
+          Story.decr("count", 1) { 2 }.should == 2
+        end
+      end
+    end
+
+    describe '#expire' do
+      it 'deletes the key' do
+        Story.set("bobo", 1)
+        Story.expire("bobo")
+        Story.get("bobo").should == nil
+      end
+    end
+    
+    describe '#cache_key' do
+      it 'uses the version number' do
+        Story.version 1
+        Story.cache_key("foo").should == "Story:1/foo"
+
+        Story.version 2
+        Story.cache_key("foo").should == "Story:2/foo"
+      end
+    end
+  end
+end

data/spec/cash/active_record_spec.rb

@@ -0,0 +1,224 @@
+require "spec_helper"
+
+module Cash
+  describe Finders do
+    describe 'when the cache is populated' do
+      describe "#find" do
+        describe '#find(id...)' do
+          describe '#find(id)' do
+            it "returns an active record" do
+              story = Story.create!(:title => 'a story')
+              Story.find(story.id).should == story
+            end
+          end
+
+          describe 'when the object is destroyed' do
+            describe '#find(id)' do
+              it "raises an error" do
+                story = Story.create!(:title => "I am delicious")
+                story.destroy
+                lambda { Story.find(story.id) }.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+          end
+
+          describe '#find(id1, id2, ...)' do
+            it "returns an array" do
+              story1, story2 = Story.create!, Story.create!
+              Story.find(story1.id, story2.id).should == [story1, story2]
+            end
+
+            describe "#find(id, nil)" do
+              it "ignores the nils" do
+                story = Story.create!
+                Story.find(story.id, nil).should == story
+              end
+            end
+          end
+
+          describe 'when given nonexistent ids' do
+            describe 'when given one nonexistent id' do
+              it 'raises an error' do
+                lambda { Story.find(1) }.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+
+            describe 'when given multiple nonexistent ids' do
+               it "raises an error" do
+                lambda { Story.find(1, 2, 3) }.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+
+
+            describe '#find(nil)' do
+              it 'raises an error' do
+                lambda { Story.find(nil) }.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+          end
+        end
+
+        describe '#find(object)' do
+          it "coerces arguments to integers" do
+            story = Story.create!
+            Story.find(story.id.to_s).should == story
+          end
+        end
+
+        describe '#find([...])' do
+          describe 'when given an array with valid ids' do
+            it "#finds the object with that id" do
+              story = Story.create!
+              Story.find([story.id]).should == [story]
+            end
+          end
+
+          describe '#find([])' do
+            it 'returns the empty array' do
+              Story.find([]).should == []
+            end
+          end
+
+          describe 'when given nonexistent ids' do
+            it 'raises an error' do
+              lambda { Story.find([1, 2, 3]) }.should raise_error(ActiveRecord::RecordNotFound)
+            end
+          end
+
+          describe 'when given limits and offsets' do
+            describe '#find([1, 2, ...], :limit => ..., :offset => ...)' do
+              it "returns the correct slice of objects" 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)
+                Character.find(
+                  [character1.id, character2.id, character3.id],
+                  :conditions => { :name => "Sam", :story_id => 1 }, :limit => 2
+                ).should == [character1, character2]
+              end
+            end
+
+            describe '#find([1], :limit => 0)' do
+              it "raises an error" do
+                character = Character.create!(:name => "Sam", :story_id => 1)
+                lambda do
+                  Character.find([character.id], :conditions => { :name => "Sam", :story_id => 1 }, :limit => 0)
+                end.should raise_error(ActiveRecord::RecordNotFound)
+              end
+            end
+          end
+        end
+
+        describe '#find(:first, ...)' do
+          describe '#find(:first, ..., :offset => ...)' do
+            it "#finds the object in the correct order" do
+              story1 = Story.create!(:title => 'title1')
+              story2 = Story.create!(:title => story1.title)
+              Story.find(:first, :conditions => { :title => story1.title }, :offset => 1).should == story2
+            end
+          end
+
+          describe '#find(:first, :conditions => [])' do
+            it 'finds the object in the correct order' do
+              story = Story.create!
+              Story.find(:first, :conditions => []).should == story
+            end
+          end
+        
+          describe "#find(:first, :conditions => '...')" do
+            it "coerces ruby values to the appropriate database values" do
+              story1 = Story.create! :title => 'a story', :published => true
+              story2 = Story.create! :title => 'another story', :published => false
+              Story.find(:first, :conditions => 'published = 0').should == story2
+            end
+          end
+        end
+      end
+
+      describe '#find_by_attr' do
+        describe '#find_by_attr(nil)' do
+          it 'returns nil' do
+            Story.find_by_id(nil).should == nil
+          end
+        end
+
+        describe 'when given non-existent ids' do
+          it 'returns nil' do
+            Story.find_by_id(-1).should == nil
+          end
+        end
+      end
+
+      describe '#find_all_by_attr' do
+        describe 'when given non-existent ids' do
+          it "does not raise an error" do
+            lambda { Story.find_all_by_id([-1, -2, -3]) }.should_not raise_error
+          end
+        end
+      end
+    end
+
+    describe 'when the cache is partially populated' do
+      describe '#find(:all, :conditions => ...)' do
+        it "returns the correct records" do
+          story1 = Story.create!(:title => title = 'once upon a time...')
+          $memcache.flush_all
+          story2 = Story.create!(:title => title)
+          Story.find(:all, :conditions => { :title => story1.title }).should == [story1, story2]
+        end
+      end
+
+      describe '#find(id1, id2, ...)' do
+        it "returns the correct records" do
+          story1 = Story.create!(:title => 'story 1')
+          $memcache.flush_all
+          story2 = Story.create!(:title => 'story 2')
+          Story.find(story1.id, story2.id).should == [story1, story2]
+        end
+      end
+    end
+
+    describe 'when the cache is not populated' do
+      describe '#find(id)' do
+        it "returns the correct records" do
+          story = Story.create!(:title => 'a story')
+          $memcache.flush_all
+          Story.find(story.id).should == story
+        end
+
+        it "handles after_find on model" do
+          class AfterFindStory < Story
+            def after_find
+              self.title
+            end
+          end
+          lambda do
+            AfterFindStory.create!(:title => 'a story') 
+          end.should_not raise_error(ActiveRecord::MissingAttributeError)
+        end
+      end
+
+      describe '#find(id1, id2, ...)' do
+        it "handles finds with multiple ids correctly" do
+          story1 = Story.create!
+          story2 = Story.create!
+          $memcache.flush_all
+          Story.find(story1.id, story2.id).should == [story1, story2]
+        end
+      end
+    end
+    
+    describe 'loading' do
+      it "should be able to create a record for an ar subclass that was loaded before cache money" do
+        $debug = true
+        session = ActiveRecord::SessionStore::Session.new
+        session.session_id = "12345"
+        session.data = "foobarbaz"
+
+        lambda {
+          session.save!
+        }.should_not raise_error
+      end
+    end
+  end
+end

data/spec/cash/buffered_spec.rb

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

data/spec/cash/calculations_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+module Cash
+  describe Finders do
+    describe 'Calculations' do
+      describe 'when the cache is populated' do
+        before do
+          @stories = [Story.create!(:title => @title = 'asdf'), Story.create!(:title => @title)]
+        end
+
+        describe '#count(:all, :conditions => ...)' do
+          it "does not use the database" do
+            Story.count(:all, :conditions => { :title => @title }).should == @stories.size
+          end
+        end
+
+        describe '#count(:column, :conditions => ...)' do
+          it "uses the database, not the cache" do
+            mock(Story).get.never
+            Story.count(:title, :conditions => { :title => @title }).should == @stories.size
+          end
+        end
+
+        describe '#count(:all, :distinct => ..., :select => ...)' do
+          it 'uses the database, not the cache' do
+            mock(Story).get.never
+            Story.count(:all, :distinct => true, :select => :title, :conditions => { :title => @title }).should == @stories.collect(&:title).uniq.size
+          end
+        end
+
+        describe 'association proxies' do
+          describe '#count(:all, :conditions => ...)' do
+            it 'does not use the database' do
+              story = Story.create!
+              characters = [story.characters.create!(:name => name = 'name'), story.characters.create!(:name => name)]
+              mock(Story.connection).execute.never
+              story.characters.count(:all, :conditions => { :name => name }).should == characters.size
+            end
+          end
+        end
+      end
+
+      describe 'when the cache is not populated' do
+        describe '#count(:all, ...)' do
+          describe '#count(:all)' do
+            it 'uses the database, not the cache' do
+              mock(Story).get.never
+              Story.count
+            end
+          end
+
+          describe '#count(:all, :conditions => ...)' do
+            before do
+              Story.create!(:title => @title = 'title')
+              $memcache.flush_all
+            end
+
+            it "populates the count correctly" do
+              Story.count(:all, :conditions => { :title => @title }).should == 1
+              Story.fetch("title/#{@title}/count", :raw => true).should =~ /\s*1\s*/
+            end
+          end
+        end
+      end
+    end
+  end
+end