benschwarz-merb-cache 1.0.0

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

@@ -0,0 +1,68 @@
+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 return true" 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(: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 "#exists?" do
+    it "should return a boolean" do
+      @store.write('foo', 'bar')
+      @store.exists?('foo').should be_true
+    end
+  end
+
+  describe "#write" do
+    it "should write" do
+      @store.write(:foo, "bar").should be_true
+    end
+    
+    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/mintcache_store_spec.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/abstract_strategy_store_spec'
+
+describe Merb::Cache::MintCacheStore do
+  it_should_behave_like 'all strategy stores'
+
+  before(:each) do
+    @klass = Merb::Cache::MintCacheStore
+    @store = Merb::Cache::MintCacheStore[DummyStore].new
+  end
+  
+  describe "reading caches" do
+    it "should return data after the first level cache has expired"
+  end
+  
+  describe "knowing if a cache exists" do
+    it "should return a boolean" do
+      @store.write('foo', 'bar')
+      @store.exists?('foo').should be_true
+    end
+  end
+  
+  describe "when writing a cache" do
+    it "should write" do
+      @store.write('foo', 'bar').should be_true
+    end
+    
+    it "should write three keys" do
+      @store.write('foo', 'body')
+      %w(foo foo_validity foo_data).each do |key|
+        @store.read(key).should_not be_nil
+      end
+    end
+    
+    it "should write a validity key that is a time object" do
+      @store.write('foo', 'body')
+      @store.read('foo_validity').first.should be_a_kind_of Time
+    end
+    
+    it "should write a data key that is the same as a regular key" do
+      @store.write('foo', 'body')
+      @store.read('foo_data').first.should == @store.read('foo').first
+    end
+    
+    it "should write the additional keys with double expiry time" do
+      @store.write('foo', 'body', {}, :expire_in => 10)
+      @store.read('foo_data')[2][:expire_in].should eql 20
+    end
+    
+    it "should receive write_all three times (key, key_validity and key_data for write_all" do
+      @store.write_all('foo', 'body')
+      %w(foo foo_validity foo_data).each do |key|
+        @store.read(key).should_not be_nil
+      end
+    end
+  end
+  
+  
+end

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

@@ -0,0 +1,146 @@
+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, :uri => '/overview'
+      eager_cache :overview, :index
+      eager_cache(:overview, :show) {{ :uri => build_url(:show, :team => 1), :params => {:team => 1} }}
+
+      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.data('/index.html').should be_nil
+    end
+    
+    it "should eager cache overview after a POST request to index" do
+      dispatch(url(:index), "REQUEST_METHOD" => "POST")
+      
+      @dummy.data('/overview.html').should == "NHLScores overview"
+    end
+
+    it "should eager cache show after a request to overview" do
+      dispatch(url(:overview))
+      
+      @dummy.data('/show/1.html').should == "NHLScores show(1)"
+    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
+    
+    describe "controller.caches?" do      
+      it "should return true for a request to overview with the :get method" do
+        NhlScores.caches?(:overview, :uri => url(:overview)).should be_true
+      end
+      
+      it "should return false for a request to overview with the :post method" do
+        NhlScores.caches?(:overview, :uri => url(:overview), :method => :post).should be_false
+      end
+      
+      it "should return false for a request to overview with query string parameters" do
+        NhlScores.caches?(:overview, :uri => url(:overview, :foo => 'baz')).should be_false
+      end  
+      
+      it "should return true for a request to overview with the :get method when looking in the page store" do
+        NhlScores.caches?(:overview, :uri => url(:overview), :store => :default).should be_true
+      end
+      
+      it "should return false for a request to overview with the :get method when looking in the action store" do
+        pending "need to move all the specs for caches? over to a controller integration test that uses both controller stores"
+      end      
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+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 return true" do
+      @store.writable?('foo').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 "#exists?" do
+    it "should return a boolean" do
+      @store.write('foo', 'bar')
+      @store.exists?('foo').should be_true
+    end
+  end
+
+  describe "#write" do
+    it "should write" do
+      @store.write('foo', 'bar').should be_true
+    end
+    
+    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

data/spec/spec_helper.rb

@@ -0,0 +1,95 @@
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+# Deps
+require 'rubygems'
+require 'merb-core'
+require 'merb-action-args'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'merb-cache')
+
+Merb.disable(:initfile)
+
+Merb.start :environment => "test",
+           :adapter     => "runner",
+           :log_file    => File.join(File.dirname(__FILE__), '..', 'log', 'merb_test.log')
+
+require "merb-core/test"
+Spec::Runner.configure do |config|
+  config.include Merb::Test::Helpers
+  #config.include Merb::Test::ControllerHelper
+  config.include Merb::Test::RouteHelper
+end
+
+# Usage
+# http://github.com/hassox/merb/tree/authz/merb-core/spec/public/authorization/base_spec.rb
+class Viking
+  def self.captures
+    @captures ||= []
+  end
+  
+  def self.capture(obj)
+    captures << obj
+  end
+end
+
+class DummyStore < Merb::Cache::AbstractStore
+  cattr_accessor :vault
+  attr_accessor  :options
+  
+  def initialize(config = {})
+    super(config)
+    @options = config
+    @@vault = {}
+  end
+
+  def writable?(*args)
+    true
+  end
+
+  def read(key, parameters = {})
+        
+    if @@vault.keys.include?(key)
+      @@vault[key].find {|data, timestamp, conditions, params| params == parameters}
+    end
+  end
+
+  def data(key, parameters = {})
+    read(key, parameters)[0] if read(key, parameters)
+  end
+
+  def time(key, parameters = {})
+    read(key, parameters)[1] if read(key, parameters)
+  end
+
+  def conditions(key, parameters = {})
+    read(key, parameters)[2] if read(key, parameters)
+  end
+
+  def write(key, data = nil, parameters = {}, conditions = {})
+    (@@vault[key] ||= []) << [data, Time.now, conditions, parameters]
+    true
+  end
+
+  def fetch(key, parameters = {}, conditions = {}, &blk)
+    @@vault[[key, parameters]] ||= blk.call
+  end
+  
+  def exists?(key, parameters = {})
+    return true if @@vault.has_key?(key) and @@vault[key].find {|data, timestamp, conditions, params| params == parameters}
+    return false
+  end
+
+  def delete(key, parameters = {})
+    @@vault.delete([key, parameters]) unless @@vault[[key, parameters]].nil?
+  end
+
+  def delete_all
+    @@vault = {}
+  end
+end
+
+#TODO change this to a work queue per class called in an after aspect
+class Merb::Controller
+  def run_later
+    yield
+  end
+end