sreeix-cache-money 0.2.24.1

data/spec/cash/marshal_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Marshal do
+  describe '#load' do
+    before do
+      class Constant; end
+      @reference_to_constant = Constant
+      @object = @reference_to_constant.new
+      @marshaled_object = Marshal.dump(@object)
+    end
+
+    describe 'when the constant is not yet loaded' do
+      it 'loads the constant' do
+        Object.send(:remove_const, :Constant)
+        stub(Marshal).constantize(@reference_to_constant.name) { Object.send(:const_set, :Constant, @reference_to_constant) }
+        Marshal.load(@marshaled_object).class.should == @object.class
+      end
+
+      it 'loads the constant with the scope operator' do
+        module Foo; class Bar; end; end
+        
+        reference_to_module = Foo
+        reference_to_constant = Foo::Bar
+        object = reference_to_constant.new
+        marshaled_object = Marshal.dump(object)
+
+        Foo.send(:remove_const, :Bar)
+        Object.send(:remove_const, :Foo)
+        stub(Marshal).constantize(reference_to_module.name) { Object.send(:const_set, :Foo, reference_to_module) }
+        stub(Marshal).constantize(reference_to_constant.name) { Foo.send(:const_set, :Bar, reference_to_constant) }
+        
+        Marshal.load(marshaled_object).class.should == object.class
+      end
+    end
+
+    describe 'when the constant does not exist' do
+      it 'raises a LoadError' do
+        Object.send(:remove_const, :Constant)
+        stub(Marshal).constantize { raise NameError }
+        lambda { Marshal.load(@marshaled_object) }.should raise_error(NameError)
+      end
+    end
+
+    describe 'when there are recursive constants to load' do
+      it 'loads all constants recursively' do
+        class Constant1; end
+        class Constant2; end
+        reference_to_constant1 = Constant1
+        reference_to_constant2 = Constant2
+        object = [reference_to_constant1.new, reference_to_constant2.new]
+        marshaled_object = Marshal.dump(object)
+        Object.send(:remove_const, :Constant1)
+        Object.send(:remove_const, :Constant2)
+        stub(Marshal).constantize(reference_to_constant1.name) { Object.send(:const_set, :Constant1, reference_to_constant1) }
+        stub(Marshal).constantize(reference_to_constant2.name) { Object.send(:const_set, :Constant2, reference_to_constant2) }
+        Marshal.load(marshaled_object).collect(&:class).should == object.collect(&:class)
+      end
+    end
+  end
+end

data/spec/cash/order_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+
+module Cash
+  describe 'Ordering' do
+    before :all do
+      FairyTale = Class.new(Story)
+    end
+
+    describe '#create!' do
+      describe 'when the order is ascending' do
+        it_should_behave_like 'the records are written-through in sorted order'
+
+        before :all do
+          FairyTale.index :title, :order => :asc
+        end
+
+        def sorted_and_serialized_records(*records)
+          records.collect(&:id).sort
+        end
+      end
+
+      describe 'when the order is descending' do
+        it_should_behave_like 'the records are written-through in sorted order'
+
+        before :all do
+          FairyTale.index :title, :order => :desc
+        end
+
+        def sorted_and_serialized_records(*records)
+          records.collect(&:id).sort.reverse
+        end
+      end
+    end
+
+    describe "#find(..., :order => ...)" do
+      before :each do
+        @fairy_tales = [FairyTale.create!(:title => @title = 'title'), FairyTale.create!(:title => @title)]
+      end
+
+      describe 'when the order is ascending' do
+        before :all do
+          FairyTale.index :title, :order => :asc
+        end
+
+        describe "#find(..., :order => 'id ASC')" do
+          describe 'when the cache is populated' do
+            it 'does not use the database' do
+              mock(FairyTale.connection).execute.never
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`id`').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'stories.id').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.id').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.`id`').should == @fairy_tales
+            end
+
+            describe 'when the order is passed as a symbol' do
+              it 'works' do
+                FairyTale.find(:all, :conditions => { :title => @title }, :order => :id)
+              end
+            end
+          end
+
+          describe 'when the cache is not populated' do
+            it 'populates the cache' do
+              $memcache.flush_all
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
+              FairyTale.get("title/#{@title}").should == @fairy_tales.collect(&:id)
+            end
+          end
+        end
+
+        describe "#find(..., :order => 'id DESC')" do
+          describe 'when the cache is populated' do
+            it 'uses the database, not the cache' do
+              mock(FairyTale).get.never
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
+            end
+          end
+
+          describe 'when the cache is not populated' do
+            it 'does not populate the cache' do
+              $memcache.flush_all
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
+              FairyTale.get("title/#{@title}").should be_nil
+            end
+          end
+        end
+      end
+
+      describe 'when the order is descending' do
+        before :all do
+          FairyTale.index :title, :order => :desc
+        end
+
+        describe "#find(..., :order => 'id DESC')" do
+          describe 'when the cache is populated' do
+            it 'does not use the database' do
+              mock(FairyTale.connection).execute.never
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`id` DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'stories.id DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.id DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.`id` DESC').should == @fairy_tales.reverse
+            end
+          end
+
+          describe 'when the cache is not populated' do
+            it 'populates the cache' do
+              $memcache.flush_all
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC')
+              FairyTale.get("title/#{@title}").should == @fairy_tales.collect(&:id).reverse
+            end
+          end
+        end
+
+        describe "#find(..., :order => 'id ASC')" do
+          describe 'when the cache is populated' do
+            it 'uses the database, not the cache' do
+              mock(FairyTale).get.never
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id').should == @fairy_tales
+            end
+          end
+
+          describe 'when the cache is not populated' do
+            it 'does not populate the cache' do
+              $memcache.flush_all
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
+              FairyTale.get("title/#{@title}").should be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cash/shared.rb

@@ -0,0 +1,62 @@
+module Cash
+  shared_examples_for "#fetch([...])" 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
+  shared_examples_for 'the records are written-through in sorted order' do
+    describe 'when there are not already records matching the index' do
+      it 'initializes the index' do
+        fairy_tale = FairyTale.create!(:title => 'title')
+        FairyTale.get("title/#{fairy_tale.title}").should == [fairy_tale.id]
+      end
+    end
+
+    describe 'when there are already records matching the index' do
+      before do
+        @fairy_tale1 = FairyTale.create!(:title => 'title')
+        FairyTale.get("title/#{@fairy_tale1.title}").should == sorted_and_serialized_records(@fairy_tale1)
+      end
+
+      describe 'when the index is populated' do
+        it 'appends to the index' do
+          fairy_tale2 = FairyTale.create!(:title => @fairy_tale1.title)
+          FairyTale.get("title/#{@fairy_tale1.title}").should == sorted_and_serialized_records(@fairy_tale1, fairy_tale2)
+        end
+      end
+
+      describe 'when the index is not populated' do
+        before do
+          $memcache.flush_all
+        end
+
+        it 'initializes the index' do
+          fairy_tale2 = FairyTale.create!(:title => @fairy_tale1.title)
+          FairyTale.get("title/#{@fairy_tale1.title}").should == sorted_and_serialized_records(@fairy_tale1, fairy_tale2)
+        end
+      end
+    end
+  end
+end
+