cache_fu 0.1.2

data/test/fragment_cache_test.rb

@@ -0,0 +1,250 @@
+require File.join(File.dirname(__FILE__), 'helper')
+require 'test/unit'
+require 'action_controller/test_process'
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+end
+
+class FooController < ActionController::Base
+  def url_for(*args)
+    "http://#{Time.now.to_i}.foo.com"
+  end
+end
+
+class BarController < ActionController::Base
+  def page
+    render :text => "give me my bongos"
+  end
+  
+  def index
+    render :text => "doop!"
+  end
+  
+  def edit
+    render :text => "rawk"
+  end
+
+  def trees_are_swell?
+    true
+  end
+
+  def rescue_action(e)
+    raise e
+  end
+end
+
+class FooTemplate
+  include ::ActionView::Helpers::CacheHelper
+  
+  attr_reader :controller
+
+  def initialize
+    @controller = FooController.new
+  end
+end
+
+context "Fragment caching (when used with memcached)" do
+  include FragmentCacheSpecSetup
+  
+  setup do
+    @view = FooTemplate.new
+  end
+  
+  specify "should be able to cache with a normal, non-keyed Rails cache calls" do
+    _erbout = ""
+    content = "Caching is fun!"
+
+    ActsAsCached.config[:store].expects(:set).with(@view.controller.url_for.gsub('http://',''), content, ActsAsCached.config[:ttl])
+
+    @view.cache { _erbout << content }
+  end
+  
+  specify "should be able to cache with a normal cache call when we don't have a default ttl" do
+    begin
+      _erbout = ""
+      content = "Caching is fun!"
+    
+      original_ttl = ActsAsCached.config.delete(:ttl)
+      ActsAsCached.config[:store].expects(:set).with(@view.controller.url_for.gsub('http://',''), content, 25.minutes)
+
+      @view.cache { _erbout << content }
+    ensure
+      ActsAsCached.config[:ttl] = original_ttl
+    end
+  end
+
+  specify "should be able to cache with a normal, keyed Rails cache calls" do
+    _erbout = ""
+    content = "Wow, even a key?!"
+    key = "#{Time.now.to_i}_wow_key"
+
+    ActsAsCached.config[:store].expects(:set).with(key, content, ActsAsCached.config[:ttl])
+
+    @view.cache(key) { _erbout << content } 
+  end
+  
+  specify "should be able to cache with new time-to-live option" do 
+    _erbout = ""
+    content = "Time to live?  TIME TO DIE!!"
+    key = "#{Time.now.to_i}_death_key"
+
+    ActsAsCached.config[:store].expects(:set).with(key, content, 60)
+    @view.cache(key, { :ttl => 60 }) { _erbout << content }
+  end
+
+  specify "should ignore everything but time-to-live when options are present" do 
+    _erbout = ""
+    content = "Don't mess around, here, sir."
+    key = "#{Time.now.to_i}_mess_key"
+
+    ActsAsCached.config[:store].expects(:set).with(key, content, 60)
+    @view.cache(key, { :other_options => "for the kids", :ttl => 60 }) { _erbout << content } 
+  end
+  
+  specify "should be able to skip cache gets" do
+    ActsAsCached.skip_cache_gets = true
+    ActsAsCached.config[:store].expects(:get).never
+    _erbout = ""
+    @view.cache { _erbout << "Caching is fun!" }
+    ActsAsCached.skip_cache_gets = false
+  end
+end
+
+context "Action caching (when used with memcached)" do
+  include FragmentCacheSpecSetup
+  page_content = "give me my bongos"
+  index_content = "doop!"
+  edit_content = "rawk"
+  
+  setup do
+    @controller = BarController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+  
+  teardown do # clear the filter chain between specs to avoid chaos
+    BarController.write_inheritable_attribute('filter_chain', [])
+  end
+  
+  # little helper for prettier expections on the cache
+  def cache_expects(method, expected_times = 1)
+    ActsAsCached.config[:store].expects(method).times(expected_times)
+  end
+
+  specify "should cache using default ttl for a normal action cache without ttl" do
+    BarController.caches_action :page
+
+    key = 'test.host/bar/page'
+    cache_expects(:set).with(key, page_content, ActsAsCached.config[:ttl])
+    get :page
+    @response.body.should == page_content
+    
+    cache_expects(:read).with(key, nil).returns(page_content)
+    get :page
+    @response.body.should == page_content
+  end
+  
+  specify "should cache using defaul ttl for normal, multiple action caches" do
+    BarController.caches_action :page, :index
+    
+    cache_expects(:set).with('test.host/bar/page', page_content, ActsAsCached.config[:ttl])
+    get :page
+    cache_expects(:set).with('test.host/bar', index_content, ActsAsCached.config[:ttl])
+    get :index
+  end
+  
+  specify "should be able to action cache with ttl" do
+    BarController.caches_action :page => { :ttl => 2.minutes }
+
+    cache_expects(:set).with('test.host/bar/page', page_content, 2.minutes)
+    get :page
+    @response.body.should == page_content
+  end
+  
+  specify "should be able to action cache multiple actions with ttls" do
+    BarController.caches_action :index, :page => { :ttl => 5.minutes }
+    
+    cache_expects(:set).with('test.host/bar/page', page_content, 5.minutes)
+    cache_expects(:set).with('test.host/bar', index_content, ActsAsCached.config[:ttl])
+    
+    get :page
+    @response.body.should == page_content
+
+    get :index
+    @response.body.should == index_content
+    cache_expects(:read).with('test.host/bar', nil).returns(index_content)
+
+    get :index
+  end
+
+  specify "should be able to action cache conditionally when passed something that returns true" do
+    BarController.caches_action :page => { :if => :trees_are_swell? }
+    
+    cache_expects(:set).with('test.host/bar/page', page_content, ActsAsCached.config[:ttl])
+    
+    get :page
+    @response.body.should == page_content
+
+    cache_expects(:read).with('test.host/bar/page', nil).returns(page_content)
+
+    get :page
+  end
+
+  #check for edginess
+  if [].respond_to?(:extract_options!)
+    specify "should not break cache_path overrides" do
+      BarController.caches_action :page, :cache_path => 'http://test.host/some/custom/path'
+      cache_expects(:set).with('test.host/some/custom/path', page_content, ActsAsCached.config[:ttl])
+      get :page
+    end
+  
+    specify "should not break cache_path block overrides" do
+      BarController.caches_action :edit, :cache_path => Proc.new { |c| c.params[:id] ? "http://test.host/#{c.params[:id]}/edit" : "http://test.host/edit" }
+      cache_expects(:set).with('test.host/edit', edit_content, ActsAsCached.config[:ttl])
+      get :edit
+
+      get :index
+      cache_expects(:set).with('test.host/5/edit', edit_content, ActsAsCached.config[:ttl])
+      get :edit, :id => 5
+    end
+  
+    specify "should play nice with custom ttls and cache_path overrides" do 
+      BarController.caches_action :page => { :ttl => 5.days }, :cache_path => 'http://test.host/my/custom/path'
+      cache_expects(:set).with('test.host/my/custom/path', page_content, 5.days)
+      get :page
+    end
+  
+    specify "should play nice with custom ttls and cache_path block overrides" do 
+      BarController.caches_action :edit, :cache_path => Proc.new { |c| c.params[:id] ? "http://test.host/#{c.params[:id]}/edit" : "http://test.host/edit" }
+      cache_expects(:set).with('test.host/5/edit', edit_content, ActsAsCached.config[:ttl])
+      get :edit, :id => 5
+    end
+    
+    specify "should play nice with the most complicated thing i can throw at it" do 
+      BarController.caches_action :index => { :ttl => 24.hours }, :page => { :ttl => 5.seconds }, :edit => { :ttl => 5.days }, :cache_path => Proc.new { |c| c.params[:id] ? "http://test.host/#{c.params[:id]}/#{c.params[:action]}" : "http://test.host/#{c.params[:action]}" }
+      cache_expects(:set).with('test.host/index', index_content, 24.hours)
+      get :index
+      cache_expects(:set).with('test.host/5/edit', edit_content, 5.days)
+      get :edit, :id => 5
+      cache_expects(:set).with('test.host/5/page', page_content, 5.seconds)
+      get :page, :id => 5
+      
+      cache_expects(:read).with('test.host/5/page', nil).returns(page_content)
+      get :page, :id => 5
+      cache_expects(:read).with('test.host/5/edit', nil).returns(edit_content)
+      get :edit, :id => 5
+      cache_expects(:read).with('test.host/index', nil).returns(index_content)
+      get :index
+    end
+  end
+
+  specify "should be able to skip action caching when passed something that returns false" do
+    BarController.caches_action :page => { :if => Proc.new {|c| !c.trees_are_swell?} }
+    
+    cache_expects(:set, 0).with('test.host/bar/page', page_content, ActsAsCached.config[:ttl])
+    
+    get :page
+    @response.body.should == page_content
+  end
+end

data/test/helper.rb

@@ -0,0 +1,215 @@
+##
+# This file exists to fake out all the Railsisms we use so we can run the 
+# tests in isolation.
+$LOAD_PATH.unshift 'lib/'
+# 
+
+begin
+  require 'rubygems'
+  gem 'mocha', '>= 0.4.0'
+  require 'mocha'
+  gem 'test-spec', '= 0.3.0'
+  require 'test/spec'
+  require 'multi_rails_init'
+rescue LoadError
+  puts '=> acts_as_cached tests depend on the following gems: mocha (0.4.0+), test-spec (0.3.0), multi_rails (0.0.2), and rails.'
+end
+
+begin
+  require 'redgreen'
+rescue LoadError
+  nil
+end
+
+Test::Spec::Should.send    :alias_method, :have, :be
+Test::Spec::ShouldNot.send :alias_method, :have, :be
+
+##
+# real men test without mocks
+if $with_memcache = ARGV.include?('with-memcache')
+  require 'memcache'
+end
+
+##
+# init.rb hacks
+RAILS_ROOT = '.'    unless defined? RAILS_ROOT
+RAILS_ENV  = 'test' unless defined? RAILS_ENV
+
+##
+# get the default config using absolute path, so tests all play nice when run in isolation
+DEFAULT_CONFIG_FILE = File.expand_path(File.dirname(__FILE__) + '/../defaults/memcached.yml.default')
+
+##
+# aac
+require 'acts_as_cached'
+Object.send :include, ActsAsCached::Mixin
+
+##
+# i need you.
+module Enumerable
+  def index_by
+    inject({}) do |accum, elem|
+      accum[yield(elem)] = elem
+      accum
+    end
+  end
+end
+
+##
+# mocky.
+class HashStore < Hash
+  alias :get :[]
+
+  def get_multi(*values)
+    reject { |k,v| !values.include? k }
+  end
+
+  def set(key, value, *others)
+    self[key] = value
+  end
+  
+  def namespace
+    nil
+  end
+end
+
+$cache = HashStore.new
+
+class Story
+  acts_as_cached($with_memcache ? {} : { :store => $cache })
+
+  attr_accessor :id, :title
+
+  def initialize(attributes = {})
+    attributes.each { |key, value| instance_variable_set("@#{key}", value) }
+  end
+
+  def attributes
+    { :id => id, :title => title }
+  end
+
+  def ==(other)
+    return false unless other.respond_to? :attributes
+    attributes == other.attributes
+  end
+
+  def self.find(*args) 
+    options = args.last.is_a?(Hash) ? args.pop : {}
+
+    if (ids = args.flatten).size > 1
+      ids.map { |id| $stories[id.to_i] }
+    elsif (id = args.flatten.first).to_i.to_s == id.to_s
+      $stories[id.to_i]
+    end
+  end
+  
+  def self.find_by_title(*args)
+    title = args.shift
+    find(args).select { |s| s.title == title }
+  end
+
+  def self.base_class
+    Story
+  end
+
+  def self.something_cool; :redbull end
+  def something_flashy;    :molassy end
+
+  def self.block_on(target = nil)
+    target || :something
+  end
+
+  def self.pass_through(target)
+    target
+  end
+
+  def self.two_params(first, second)
+    "first: #{first} | second: #{second}"
+  end
+
+  def self.find_live(*args) false end
+end
+
+class Feature   < Story; end
+class Interview < Story; end
+
+module ActionController
+  class Base
+    def rendering_runtime(*args) '' end
+    def self.silence; yield end
+  end
+end
+
+class MemCache
+  attr_accessor :servers
+  def initialize(*args) end
+  class MemCacheError < StandardError; end unless defined? MemCacheError
+end unless $with_memcache
+
+module StoryCacheSpecSetup
+  def self.included(base)
+    base.setup do 
+      setup_cache_spec 
+      Story.instance_eval { @max_key_length = nil }
+    end
+  end
+
+  def setup_cache_spec
+    @story  = Story.new(:id => 1, :title => "acts_as_cached 2 released!")
+    @story2 = Story.new(:id => 2, :title => "BDD is something you can use")
+    @story3 = Story.new(:id => 3, :title => "RailsConf is overrated.")
+    $stories = { 1 => @story, 2 => @story2, 3 => @story3 }
+
+    $with_memcache ? with_memcache : with_mock
+  end
+
+  def with_memcache
+    unless $mc_setup_for_story_cache_spec
+      ActsAsCached.config.clear
+      config = YAML.load_file(DEFAULT_CONFIG_FILE)
+      config['test'] = config['development'].merge('benchmarking' => false, 'disabled' => false)
+      ActsAsCached.config = config
+      $mc_setup_for_story_cache_spec = true
+    end
+
+    Story.send :acts_as_cached
+    Story.expire_cache(1)
+    Story.expire_cache(2)
+    Story.expire_cache(3)
+    Story.expire_cache(:block)
+    Story.set_cache(2, @story2)
+  end
+
+  def with_mock
+    $cache.clear
+
+    Story.send :acts_as_cached, :store => $cache
+    $cache['Story:2'] = @story2
+  end
+end
+
+module FragmentCacheSpecSetup
+  def self.included(base)
+    base.setup { setup_fragment_spec }
+  end
+  
+  def setup_fragment_spec
+    unless $mc_setup_for_fragment_cache_spec
+      ActsAsCached.config.clear
+      config = YAML.load_file(DEFAULT_CONFIG_FILE)
+
+      if $with_memcache
+        other_options = { 'fragments' => true }
+      else
+        Object.const_set(:CACHE, $cache) unless defined? CACHE
+        other_options = { 'fragments' => true, 'store' => $cache }
+      end
+
+      config['test'] = config['development'].merge other_options
+
+      ActsAsCached.config = config
+      ActsAsCached::FragmentCache.setup!
+      $mc_setup_for_fragment_cache_spec = true
+    end
+  end
+end

data/test/local_cache_test.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+context "When local_cache_for_request is called" do
+  include StoryCacheSpecSetup
+
+  setup do
+    ActionController::Base.new.local_cache_for_request
+    $cache = CACHE if $with_memcache
+  end
+
+  specify "get_cache should pull from the local cache on a second hit" do
+    $cache.expects(:get).with('Story:2').returns(@story2)
+    @story2.get_cache
+    $cache.expects(:get).never
+    @story2.get_cache
+  end
+
+  specify "set_cache should set to the local cache" do
+    $cache.expects(:set).at_least_once.returns(@story)
+    ActsAsCached::LocalCache.local_cache.expects(:[]=).with('Story:1', @story).returns(@story)
+    @story.set_cache
+  end
+
+  specify "expire_cache should clear from the local cache" do
+    @story2.get_cache
+    $cache.expects(:delete).at_least_once
+    ActsAsCached::LocalCache.local_cache.expects(:delete).with('Story:2')
+    @story2.expire_cache
+  end
+
+  specify "clear_cache should clear from the local cache" do
+    @story2.get_cache
+    $cache.expects(:delete).at_least_once
+    ActsAsCached::LocalCache.local_cache.expects(:delete).with('Story:2')
+    @story2.clear_cache
+  end
+
+  specify "cached? should check the local cache" do
+    @story2.get_cache
+    $cache.expects(:get).never
+    @story2.cached?
+  end
+end

data/test/sti_test.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+context "An STI subclass acting as cached" do
+  include StoryCacheSpecSetup
+
+  setup do
+    @feature   = Feature.new(:id => 3, :title => 'Behind the scenes of acts_as_cached')
+    @interview = Interview.new(:id => 4, :title => 'An interview with the Arcade Fire')
+    @feature.expire_cache
+    @interview.expire_cache
+    $stories.update 3 => @feature, 4 => @interview
+  end
+
+  specify "should be just as retrievable as any other cachable Ruby object" do
+    Feature.cached?(3).should.equal false
+    Feature.get_cache(3)
+    Feature.cached?(3).should.equal true
+  end
+
+  specify "should have a key corresponding to its parent class" do
+    @feature.cache_key.should.equal "Story:3"
+    @interview.cache_key.should.equal "Story:4"
+  end
+
+  specify "should be able to get itself from the cache via its parent class" do
+    Story.get_cache(3).should.equal @feature
+    Story.get_cache(4).should.equal @interview
+  end
+
+  specify "should take on its parents cache options but be able to set its own" do
+    @feature.cache_key.should.equal "Story:3"
+    Feature.cache_config[:version] = 1
+    @feature.cache_key.should.equal "Story:1:3"
+    @story.cache_key.should.equal "Story:1"
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: cache_fu
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.2
+platform: ruby
+authors: 
+- ""
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.0"
+  type: :development
+  version_requirements: *id002
+description: This gem is kreetitech's fork (http://github.com/kreetitech/cache_fu).
+email: 
+- ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rails/init.rb
+- lib/acts_as_cached/benchmarking.rb
+- lib/acts_as_cached/cache_methods.rb
+- lib/acts_as_cached/config.rb
+- lib/acts_as_cached/disabled.rb
+- lib/acts_as_cached/fragment_cache.rb
+- lib/acts_as_cached/local_cache.rb
+- lib/acts_as_cached/railtie.rb
+- lib/acts_as_cached/recipes.rb
+- lib/cache_fu.rb
+- lib/cache_fu.rb~
+- lib/cache_fu.rb~5453d1247ce57bb1ea5ad70936b97707d5dbdab0
+- lib/cache_fu.rb~5453d1247ce57bb1ea5ad70936b97707d5dbdab0_0
+- lib/tasks/memcached.rake
+- test/benchmarking_test.rb
+- test/cache_test.rb
+- test/config_test.rb
+- test/disabled_test.rb
+- test/extensions_test.rb
+- test/fragment_cache_test.rb
+- test/helper.rb
+- test/local_cache_test.rb
+- test/sti_test.rb
+- defaults/extensions.rb.default
+- defaults/memcached.yml.default
+- defaults/memcached_ctl.default
+- LICENSE
+- README
+homepage: http://github.com/kreetitech/cache_fu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.3
+signing_key: 
+specification_version: 3
+summary: Makes caching easy for ActiveRecord models
+test_files: []
+