benschwarz-merb-cache 1.0.0

data/spec/merb-cache/stores/strategy/abstract_strategy_store_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/../fundamental/abstract_store_spec'
+
+
+describe Merb::Cache::AbstractStrategyStore do
+  describe 'all strategy stores', :shared => true do
+    it_should_behave_like 'all stores'
+
+    before(:each) do
+      Merb::Cache.stores.clear
+      Thread.current[:'merb-cache'] = nil
+    end
+
+    describe "contextualizing method", :shared => true do
+      it "should return a subclass of itself" do
+        subclass = @klass.[](Class.new(Merb::Cache::AbstractStore))
+        subclass.superclass.should  == @klass
+      end
+
+      it "should set the contextualized_stores attributes" do
+        subclass = @klass.[](context_class = Class.new(Merb::Cache::AbstractStore))
+        subclass.contextualized_stores.first.should == context_class
+      end
+    end
+    
+    describe ".contextualize" do
+      it_should_behave_like "contextualizing method"
+    end
+
+    describe ".[]" do
+      it_should_behave_like "contextualizing method"
+    end
+
+    describe "#initialize" do
+      it "should create an instance of the any context classes" do
+        subclass = @klass.[](context_class = Class.new(Merb::Cache::AbstractStore))
+        instance = subclass.new({})
+        instance.stores.first.class.superclass.should == Merb::Cache::AbstractStore
+      end
+
+      it "should lookup the instance of any context names" do
+        Merb::Cache.register(:foo, Class.new(Merb::Cache::AbstractStore))
+        subclass = @klass.[](:foo)
+        Merb::Cache.should_receive(:[]).with(:foo)
+        subclass.new({})
+      end
+    end
+
+    describe "#clone" do
+      it "should clone each context instance" do
+        subclass = @klass.[](context_class = Class.new(Merb::Cache::AbstractStore))
+        instance = mock(:instance)
+        context_class.should_receive(:new).and_return(instance)
+        instance.should_receive(:clone)
+
+        subclass.new.clone
+      end
+    end
+    
+    describe "#write_all" do
+      it "should not raise a NotImplementedError error" do
+        lambda { @store.write_all('foo', 'bar') }.should_not raise_error(NotImplementedError)
+      end
+
+      it "should accept a string key" do
+        @store.write_all('foo', 'bar')
+      end
+
+      it "should accept a symbol as a key" do
+        @store.write_all(:foo, :bar)
+      end
+
+      it "should accept parameters and conditions" do
+        @store.write_all('foo', 'bar', {:params => :hash}, :conditions => :hash)
+      end
+    end
+  end
+end

data/spec/merb-cache/stores/strategy/action_store_spec.rb

@@ -0,0 +1,208 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/abstract_strategy_store_spec'
+
+describe Merb::Cache::ActionStore do
+  it_should_behave_like 'all strategy stores'
+
+  # this could be cleaned up a bit
+  before(:each) do
+    Merb::Cache.stores.clear
+    Thread.current[:'merb-cache'] = nil
+
+    @klass = Merb::Cache::ActionStore[:dummy]
+    Merb::Cache.register(:dummy, DummyStore)
+    Merb::Cache.register(:default, @klass)
+
+    @store = Merb::Cache[:default]
+    @dummy = @store.stores.first
+
+    class TestController < Merb::Controller; def action; end; end
+    @controller = TestController.new(fake_request)
+    @controller.stub!(:action_name).and_return :action
+    @controller.stub!(:body).and_return 'body'
+  end
+  
+  describe "#writable?" do
+    it "should be false if the key argument is not an instance of a controller" do
+      @store.writable?(:foo).should be_false
+    end
+
+    it "should be false if the fundamental store cannot write the normalized key" do
+      @store.stores.first.should_receive(:writable?).and_return false
+
+      @store.writable?(@controller).should be_false
+    end
+
+    it "should be true if the key is a controller instance and the fundamental store is writable" do
+      @store.writable?(@controller).should be_true
+    end
+  end
+
+  describe "#read" do
+    it "should pass the normalized dispatch as the key to the context cache" do
+      @dummy.should_receive(:read).with("TestController#action", {})
+
+      @store.read(@controller)
+    end
+  end
+
+  describe "#write" do
+    it "should pass the normalized dispatch as the key to the fundamental store" do
+      @dummy.should_receive(:write).with("TestController#action", @controller.body, {}, {})
+
+      @store.write(@controller)
+    end
+
+    it "should not store to the context cache if the dispatch is not storable" do
+      @dummy.should_not_receive(:write)
+
+      @store.write(:foo).should be_false
+    end
+
+    it "should use the controller instance's body as the data" do
+      @controller.should_receive(:body)
+
+      @store.write(@controller)
+    end
+    
+    it "should write" do
+      @store.write(@controller).should be_true
+    end
+  end
+
+  describe "#write_all" do
+    it "should pass the normalized dispatch as the key to the fundamental store" do
+      @dummy.should_receive(:write_all).with("TestController#action", @controller.body, {}, {})
+
+      @store.write_all(@controller)
+    end
+
+    it "should not store to the context cache if the dispatch is not storable" do
+      @dummy.should_not_receive(:write_all)
+
+      @store.write_all(:foo).should be_false
+    end
+
+    it "should use the controller instance's body as the data" do
+      @controller.should_receive(:body)
+
+      @store.write_all(@controller)
+    end
+  end
+  
+  describe "#exists?" do
+    it "should return a boolean" do
+      @store.write(@controller)
+      @store.exists?(@controller).should be_true
+    end
+  end
+  
+  describe "examples" do
+    class MLBSchedule < Merb::Controller
+      cache :index
+
+      def index
+        "MLBSchedule index"
+      end
+    end
+
+    class MLBScores < Merb::Controller
+      cache :index, :show
+      cache :overview
+      cache :short, :params => :page
+      cache :stats, :params => [:start_date, :end_date]
+      cache :ticker, :expire_in => 10
+
+      eager_cache :index, [MLBSchedule, :index]
+      eager_cache [:overview, :show], :index
+      eager_cache(:short, :params => :page) do |params, env|
+        {:params => params.merge(:page => (params[:page].to_i + 1).to_s)}
+      end
+
+      def index
+        "MLBScores index"
+      end
+
+      def show(team)
+        "MLBScores show(#{team})"
+      end
+
+      def overview(team = :all)
+        "MLBScores overview(#{team})"
+      end
+
+      def short(team = :all)
+        "MLBScores short(#{team})[#{params[:page]}]"
+      end
+
+      def stats(start_date, end_date, team = :all)
+        "MLBScores stats(#{team}, #{start_date}, #{end_date})"
+      end
+
+      def ticker
+        "MLBScores ticker"
+      end
+    end
+
+    it "should cache the index action on the first request" do
+      dispatch_to(MLBScores, :index)
+
+      @dummy.data("MLBScores#index").should == "MLBScores index"
+    end
+
+    it "should cache the show action by the team parameter using the action arguments" do
+      dispatch_to(MLBScores, :show, :team => :redsox)
+
+      @dummy.data("MLBScores#show", :team => 'redsox').should == "MLBScores show(redsox)"
+    end
+
+    it "should cache the overview action by the default parameter if none is given" do
+      dispatch_to(MLBScores, :overview)
+
+      @dummy.data("MLBScores#overview", :team => :all).should == "MLBScores overview(all)"
+    end
+
+    it "should cache the short action by the team & page parameters" do
+      dispatch_to(MLBScores, :short, :team => :bosux, :page => 4)
+
+      @dummy.data("MLBScores#short", :team => 'bosux', :page => '4').should == "MLBScores short(bosux)[4]"
+    end
+
+    it "should cache the stats action by team, start_date & end_date parameters" do
+      start_date, end_date = Time.today.to_s, Time.now.to_s
+      dispatch_to(MLBScores, :stats, :start_date => start_date, :end_date => end_date)
+
+      @dummy.data("MLBScores#stats", :team => :all, :start_date => start_date, :end_date => end_date).should == "MLBScores stats(all, #{start_date}, #{end_date})"
+    end
+
+    it "should cache the ticker action with an expire_in condition" do
+      dispatch_to(MLBScores, :ticker)
+
+      @dummy.conditions("MLBScores#ticker")[:expire_in].should == 10
+    end
+
+    it "should eager cache MLBSchedule#index after a request to MLBScores#index" do
+      dispatch_to(MLBScores, :index)
+
+      @dummy.data("MLBSchedule#index").should == "MLBSchedule index"
+    end
+
+    it "should eager cache :index after a request to :overview" do
+      dispatch_to(MLBScores, :overview)
+
+      @dummy.data("MLBScores#index").should == "MLBScores index"
+    end
+    
+    it "should eager cache :index after a request to :show" do
+      dispatch_to(MLBScores, :show, :team => :redsox)
+
+      @dummy.data("MLBScores#index").should == "MLBScores index"
+    end
+
+    it "should eager cache the next :short page" do
+      dispatch_to(MLBScores, :short, :team => :bosux, :page => 4)
+
+      @dummy.data("MLBScores#short", :team => 'bosux', :page => '5').should == "MLBScores short(bosux)[5]"
+    end
+  end
+end

data/spec/merb-cache/stores/strategy/adhoc_store_spec.rb

@@ -0,0 +1,227 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/abstract_strategy_store_spec'
+
+describe Merb::Cache::AdhocStore do
+  it_should_behave_like 'all stores'
+
+  before(:each) do
+    Merb::Cache.stores.clear
+    Thread.current[:'merb-cache'] = nil
+    Merb::Cache.register(:dummy, DummyStore)
+    @store = Merb::Cache::AdhocStore[:dummy]
+  end
+
+  describe "#initialize" do
+    it "should lookup all store names" do
+      names = [:first, :second, :third]
+      names.each {|n| Merb::Cache.should_receive(:[]).with(n)}
+
+      Merb::Cache::AdhocStore[*names]
+    end
+  end
+
+  describe "#writable?" do
+    it "should return the first non-nil result of a writeable store" do
+      unwritable, writable = mock(:unwritable_store), mock(:writable_store)
+      unwritable.should_receive(:writable?).and_return nil
+      writable.should_receive(:writable?).and_return true
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unwritable, writable]
+      adhoc.writable?(:foo).should be_true
+    end
+
+    it "should stop calling writable after the first non-nil result" do
+      unwritable, writable, unused = mock(:unwritable_store), mock(:writable_store), mock(:unused_store)
+      unwritable.stub!(:writable?).and_return nil
+      writable.should_receive(:writable?).and_return true
+      unused.should_not_receive(:writable?)
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unwritable, writable, unused]
+      adhoc.writable?(:foo).should be_true
+    end
+
+    it "should return nil if none of the stores are writable" do
+      unwritable = mock(:unwritable_store)
+      unwritable.should_receive(:writable?).exactly(3).times.and_return(nil)
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unwritable, unwritable, unwritable]
+      adhoc.writable?(:foo).should be_nil
+    end
+  end
+
+  describe "#write" do
+    it "should write" 
+    
+    it "should return the first non-nil result of a writeable store" do
+      unwritable, writable = mock(:unwritable_store), mock(:writable_store)
+      unwritable.should_receive(:write).and_return nil
+      writable.should_receive(:write).and_return true
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unwritable, writable]
+      adhoc.write(:foo).should be_true
+    end
+
+    it "should stop calling writable after the first non-nil result" do
+      unwritable, writable, unused = mock(:unwritable_store), mock(:writable_store), mock(:unused_store)
+      unwritable.stub!(:write).and_return nil
+      writable.should_receive(:write).and_return true
+      unused.should_not_receive(:write)
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unwritable, writable, unused]
+      adhoc.write(:foo).should be_true
+    end
+
+    it "should return nil if none of the stores are writable" do
+      unwritable = mock(:unwritable_store)
+      unwritable.should_receive(:write).exactly(3).times.and_return(nil)
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unwritable, unwritable, unwritable]
+      adhoc.write(:foo).should be_nil
+    end
+  end
+
+  describe "#write_all" do
+    it "should return false if a store returns nil for write_all" do
+      unwritable, writable = mock(:unwritable_store), mock(:writable_store)
+      unwritable.should_receive(:write_all).and_return nil
+      writable.should_receive(:write_all).and_return "bar"
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unwritable, writable]
+      adhoc.write_all(:foo).should be_false
+    end
+
+    it "should always call write_all on every store" do
+      unwritable, writable, used = mock(:unwritable_store), mock(:writable_store), mock(:used_store)
+      unwritable.stub!(:write_all).and_return nil
+      writable.should_receive(:write_all).and_return true
+      used.should_receive(:write_all).and_return true
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unwritable, writable, used]
+      adhoc.write_all(:foo).should be_false
+    end
+  end
+
+  describe "#fetch" do
+    it "should return a call to read if it is non-nil" do
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.should_receive(:read).and_return "bar"
+      adhoc.fetch(:foo).should == "bar"
+    end
+
+    it "should return the first non-nil result of a fetchable store" do
+      unfetchable, fetchable = mock(:unfetchable_store), mock(:fetchable_store)
+      unfetchable.should_receive(:fetch).and_return nil
+      fetchable.should_receive(:fetch).and_return true
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unfetchable, fetchable]
+      adhoc.should_receive(:read).and_return nil
+      adhoc.fetch(:foo).should be_true
+    end
+
+    it "should return the value of the block if none of the stores are fetchable" do
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.fetch(:foo) {
+        'foo'
+
+      }.should == 'foo'
+    end
+
+    it "should stop calling fetch after the first non-nil result" do
+      unfetchable, fetchable, unused = mock(:unwritable_store), mock(:writable_store), mock(:unused_store)
+      unfetchable.stub!(:fetch).and_return nil
+      fetchable.should_receive(:fetch).and_return true
+      unused.should_not_receive(:fetch)
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unfetchable, fetchable, unused]
+      adhoc.should_receive(:read).and_return nil
+      adhoc.fetch(:foo).should be_true
+    end
+  end
+
+  describe "#exists?" do
+    it "should return the first non-nil result of a readable store" do
+      unreadable, readable = mock(:unreadable_store), mock(:readable_store)
+      unreadable.should_receive(:exists?).and_return nil
+      readable.should_receive(:exists?).and_return true
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unreadable, readable]
+      adhoc.exists?(:foo).should be_true
+    end
+
+    it "should stop calling readable after the first non-nil result" do
+      unreadable, readable, unused = mock(:unreadable_store), mock(:readable_store), mock(:unused_store)
+      unreadable.stub!(:exists?).and_return nil
+      readable.should_receive(:exists?).and_return true
+      unused.should_not_receive(:exists?)
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unreadable, readable, unused]
+      adhoc.exists?(:foo).should be_true
+    end
+
+    it "should return nil if none of the stores are readable" do
+      unreadable = mock(:unreadable_store)
+      unreadable.should_receive(:exists?).exactly(3).times.and_return(nil)
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [unreadable, unreadable, unreadable]
+      adhoc.exists?(:foo).should be_false
+    end
+  end
+
+  describe "#delete" do
+    it "should return false if all stores returns nil for delete" do
+      undeletable = mock(:undeletable_store)
+      undeletable.should_receive(:delete).and_return nil
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [undeletable]
+      adhoc.delete(:foo).should be_false
+    end
+
+    it "should always call delete on every store" do
+      undeletable, deletable, used = mock(:undeletable_store), mock(:deletable_store), mock(:used_store)
+      undeletable.stub!(:delete).and_return nil
+      deletable.should_receive(:delete).and_return true
+      used.should_receive(:delete).and_return true
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [undeletable, deletable, used]
+      adhoc.delete(:foo).should be_true
+    end
+  end
+
+  describe "#delete_all!" do
+    it "should return false if a store returns nil for write_all" do
+      undeletable, deletable = mock(:undeletable_store), mock(:deletable_store)
+      undeletable.should_receive(:delete_all!).and_return nil
+      deletable.should_receive(:delete_all!).and_return true
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [undeletable, deletable]
+      adhoc.delete_all!.should be_false
+    end
+
+    it "should always call write_all on every store" do
+      undeletable, deletable, used = mock(:undeletable_store), mock(:deletable_store), mock(:used_store)
+      undeletable.stub!(:delete_all!).and_return nil
+      deletable.should_receive(:delete_all!).and_return true
+      used.should_receive(:delete_all!).and_return true
+
+      adhoc = Merb::Cache::AdhocStore.new
+      adhoc.stores = [undeletable, deletable, used]
+      adhoc.delete_all!.should be_false
+    end
+  end
+end