merb-cache 0.9.7 → 0.9.8

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

@@ -0,0 +1,189 @@
+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_nil
+    end
+
+    it "should use the controller instance's body as the data" do
+      @controller.should_receive(:body)
+
+      @store.write(@controller)
+    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_nil
+    end
+
+    it "should use the controller instance's body as the data" do
+      @controller.should_receive(:body)
+
+      @store.write_all(@controller)
+    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, :index
+      eager_cache(:short, :params => :page) {|c| c.params[:page] = (c.params[:page].to_i + 1).to_s}
+
+      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 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,225 @@
+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 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_nil
+    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

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

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/abstract_strategy_store_spec'
+
+describe Merb::Cache::GzipStore do
+  it_should_behave_like 'all strategy stores'
+
+  before(:each) do
+    @klass = Merb::Cache::GzipStore
+    @store = Merb::Cache::GzipStore[DummyStore].new
+  end
+
+  describe "#writable?" do
+    it "should always be true" do
+      @store.writable?(:foo).should be_true
+      @store.writable?('foo').should be_true
+      @store.writable?(123).should be_true
+    end
+  end
+
+  describe "#read" do
+    it "should return nil if hash does not exist as a key in any context store" do
+      @store.stores.each {|s| s.should_receive(:read).with(:foo, :bar => :baz).and_return nil}
+
+      @store.read(:foo, :bar => :baz).should be_nil
+    end
+
+    it "should return the data from the context store when there is a hash key match" do
+      @store.stores.first.should_receive(:read).with(:foo, {}).and_return @store.compress("bar")
+
+      @store.read(:foo).should == "bar"
+    end
+  end
+
+  describe "#write" do
+    it "should pass the hashed key to the context store" do
+      @store.stores.first.should_receive(:write).with(:foo,  @store.compress('body'), {}, {}).and_return true
+
+      @store.write(:foo, 'body').should be_true
+    end
+
+    it "should use the parameters to create the hashed key" do
+      @store.stores.first.should_receive(:write).with(:foo, @store.compress('body'), {:bar => :baz}, {}).and_return true
+
+      @store.write(:foo, 'body', :bar => :baz).should be_true
+    end
+  end
+
+  describe "#fetch" do
+    # not sure how to spec this yet
+  end
+end

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

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/abstract_strategy_store_spec'
+
+describe Merb::Cache::PageStore do
+  it_should_behave_like 'all strategy stores'
+
+  before(:each) do
+    Merb::Cache.stores.clear
+    Thread.current[:'merb-cache'] = nil
+
+    @klass = Merb::Cache::PageStore[:dummy]
+    Merb::Cache.register(:dummy, DummyStore)
+    Merb::Cache.register(:default, @klass)
+
+    @store = Merb::Cache[:default]
+    @dummy = @store.stores.first
+  end
+
+  def dispatch(url, attrs = {})
+    Merb::Dispatcher.handle(request_for(url, attrs))
+  end
+
+  def request_for(url, attrs = {})
+    Merb::Request.new(Rack::MockRequest.env_for(url, attrs))
+  end
+
+  describe "examples" do
+
+    class NhlScores < Merb::Controller
+      provides :xml, :json, :yaml
+
+      cache :index, :show
+      cache :overview
+
+      eager_cache(:index, :overview) {|c| c.request.env['REQUEST_PATH'] = c.url(:overview)}
+      eager_cache :overview, :index
+
+      def index
+        "NHLScores index"
+      end
+
+      def show(team)
+        "NHLScores show(#{team})"
+      end
+
+      def overview
+        "NHLScores overview"
+      end
+    end
+
+    before(:each) do
+      Merb::Router.prepare do |r|
+        r.match("/").to(:controller => "nhl_scores", :action => "index").name(:index)
+        r.match("/show/:team").to(:controller => "nhl_scores", :action => "show").name(:show)
+        r.match("/overview").to(:controller => "nhl_scores", :action => "overview").name(:overview)
+      end
+    end
+
+
+    # NOTE: the "REQUEST_URI" => ... stuff will be removed after has_query_params? is in core.
+    it "should cache the index action on the first request" do
+      dispatch(url(:index), "REQUEST_URI" => url(:index))
+
+      @dummy.data("/index.html").should == "NHLScores index"
+    end
+
+    it "should cache the yaml version of the index action request" do
+      dispatch(url(:index), "HTTP_ACCEPT" => "application/x-yaml", "REQUEST_URI" => url(:index))
+
+      @dummy.data("/index.yaml").should == "NHLScores index"
+    end
+
+    it "should cache the show action when the team parameter is a route parameter" do
+      dispatch(url(:show, :team => 'redwings'), "REQUEST_URI" => url(:show, :team => 'redwings'))
+
+      @dummy.data("/show/redwings.html").should == "NHLScores show(redwings)"
+    end
+
+    it "should cache the xml version of a request" do
+      dispatch(url(:show, :team => 'redwings'), "HTTP_ACCEPT" => "application/xml", "REQUEST_URI" => url(:show, :team => 'redwings'))
+
+      @dummy.data("/show/redwings.xml").should == "NHLScores show(redwings)"
+    end
+
+
+    it "should not cache the show action when the team parameter is not a route parameter" do
+      pending "the has_query_params? is implemented in merb-core"
+      dispatch_to(NhlScores, :show, :team => 'readwings', "REQUEST_URI" => url(:show, :team => 'redwings'))
+
+      @dummy.vault.should be_empty
+    end
+
+    it "should not cache the action when a there is a query string parameter" do
+      dispatch(url(:index, :page => 2))
+
+      @dummy.data(url(:index)).should be_nil
+    end
+
+    it "should not cache a POST request" do
+      dispatch(url(:index), "REQUEST_METHOD" => "POST")
+
+      @dummy.vault.should be_empty
+    end
+
+    it "should not eager cache during an eager cache, causing an infinit loop of eagerness" do
+      dispatch(url(:overview), "REQUEST_URI" => url(:overview))
+
+      @dummy.data("/overview.html").should == "NHLScores overview"
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/abstract_strategy_store_spec'
+
+describe Merb::Cache::SHA1Store do
+  it_should_behave_like 'all strategy stores'
+
+  before(:each) do
+    @klass = Merb::Cache::SHA1Store
+    @store = Merb::Cache::SHA1Store[DummyStore].new
+  end
+
+  describe "#writable?" do
+    it "should be true if the key is a string, symbol, or number" do
+      @store.writable?(:foo).should be_true
+      @store.writable?('foo').should be_true
+      @store.writable?(123).should be_true
+    end
+
+    it "should be false if none of the context caches are writable" do
+      @store.stores.each {|s| s.should_receive(:writable?).and_return false}
+
+      @store.writable?(:foo).should be_false
+    end
+  end
+
+  describe "#read" do
+    it "should return nil if hash does not exist as a key in any context store" do
+      @store.stores.each {|s| s.should_receive(:read).with(@store.digest(:foo, :bar => :baz)).and_return nil}
+
+      @store.read(:foo, :bar => :baz).should be_nil
+    end
+
+    it "should return the data from the context store when there is a hash key match" do
+      @store.stores.first.should_receive(:read).with(@store.digest(:foo)).and_return :bar
+
+      @store.read(:foo).should == :bar
+    end
+  end
+
+  describe "#write" do
+    it "should pass the hashed key to the context store" do
+      @store.stores.first.should_receive(:write).with(@store.digest(:foo), 'body', {}, {}).and_return true
+
+      @store.write(:foo, 'body').should be_true
+    end
+
+    it "should use the parameters to create the hashed key" do
+      @store.stores.first.should_receive(:write).with(@store.digest(:foo, :bar => :baz), 'body', {}, {}).and_return true
+
+      @store.write(:foo, 'body', :bar => :baz).should be_true
+    end
+  end
+
+  describe "#fetch" do
+    it "should return nil if the arguments are not storable" do
+      @store.fetch(mock(:request)) {'body'}.should be_nil
+    end
+
+    
+  end
+
+  describe "#digest" do
+    it "should produce the same digest for the exact same key and parameters" do
+      @store.digest(:foo, :bar => :baz).should == @store.digest(:foo, :bar => :baz)
+    end
+
+    it "should use the string result of the parameter arguments to_param in the hash" do
+      @store.digest(:foo, :bar => :baz).should_not == @store.digest(:foo)
+    end
+
+    it "should use the key argument in the hash" do
+      @store.digest('', :bar => :baz).should_not == @store.digest('')
+    end
+  end
+end