revo-cache_fu 1.0.0

data/tasks/memcached.rake

@@ -0,0 +1,43 @@
+require 'yaml'
+require 'erb'
+
+namespace :memcached do
+  desc "Start memcached locally" 
+  task :start do
+    memcached config_args
+    puts "memcached started"
+  end
+
+  desc "Restart memcached locally" 
+  task :restart do
+    Rake::Task['memcached:stop'].invoke
+    Rake::Task['memcached:start'].invoke
+  end
+
+  desc "Stop memcached locally" 
+  task :stop do
+    `killall memcached`
+    puts "memcached killed"
+  end
+end
+
+def config
+  return @config if @config
+  config  = YAML.load(ERB.new(IO.read(File.dirname(__FILE__) + '/../../../../config/memcached.yml')).result)
+  @config = config['defaults'].merge(config['development'])
+end
+
+def config_args
+  args = {
+    '-p' => Array(config['servers']).first.split(':').last,
+    '-c' => config['c_threshold'],
+    '-m' => config['memory'],
+    '-d' => ''
+  }
+
+  args.to_a * ' '
+end
+
+def memcached(*args)
+  `/usr/bin/env memcached #{args * ' '}`
+end

data/test/benchmarking_test.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+ActsAsCached.config.clear
+config = YAML.load_file(File.join(File.dirname(__FILE__), '../defaults/memcached.yml.default'))
+config['test'] = config['development']
+ActsAsCached.config = config
+Story.send :acts_as_cached
+
+context "When benchmarking is enabled" do
+  specify "ActionController::Base should respond to rendering_runtime_with_memcache" do
+    ActionController::Base.new.should.respond_to :rendering_runtime_with_memcache
+  end
+
+  specify "cachable Ruby classes should be respond to :logger" do
+    Story.should.respond_to :logger
+  end
+
+  specify "a cached object should gain a fetch_cache with and without benchmarking methods" do
+    Story.should.respond_to :fetch_cache_with_benchmarking
+    Story.should.respond_to :fetch_cache_without_benchmarking
+  end
+
+  specify "cache_benchmark should yield and time any action" do
+    ActsAsCached::Benchmarking.cache_runtime.should.equal 0.0
+
+    level = Class.new { |k| def k.method_missing(*args) true end }
+    Story.stubs(:logger).returns(level)
+
+    Story.cache_benchmark("Seriously, nothing.", true) {
+      sleep 0.01
+     "Nothing."
+    }.should.equal "Nothing."
+
+    ActsAsCached::Benchmarking.cache_runtime.should.be > 0.0
+  end
+end

data/test/cache_test.rb

@@ -0,0 +1,281 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+context "A Ruby class acting as cached (in general)" do
+  include StoryCacheSpecSetup
+
+  specify "should be able to retrieve a cached instance from the cache" do
+    Story.get_cache(1).should.equal Story.find(1)
+  end
+
+  specify "should set to the cache if its not already set when getting" do
+    Story.should.not.have.cached 1
+    Story.get_cache(1).should.equal Story.find(1)
+    Story.should.have.cached 1
+  end
+
+  specify "should not set to the cache if is already set when getting" do
+    Story.expects(:set_cache).never
+    Story.should.have.cached 2
+    Story.get_cache(2).should.equal Story.find(2)
+    Story.should.have.cached 2
+  end
+
+  specify "should be able to tell if a key is cached" do
+    Story.is_cached?(1).should.equal false
+    Story.should.not.have.cached 1
+    Story.should.have.cached 2
+  end
+
+  specify "should be able to cache arbitrary methods using #caches" do
+    Story.cache_store.expects(:get).returns(nil)
+    Story.cache_store.expects(:set).with('Story:something_cool', :redbull, 1500)
+    Story.caches(:something_cool).should.equal :redbull
+
+    Story.cache_store.expects(:get).returns(:redbull)
+    Story.cache_store.expects(:set).never
+    Story.caches(:something_cool).should.equal :redbull
+  end
+
+  specify "should be able to cache arbitrary methods with arguments using #caches and :with" do
+    with = :mongrel
+
+    Story.cache_store.expects(:get).returns(nil)
+    Story.cache_store.expects(:set).with("Story:block_on:#{with}", with, 1500)
+    Story.caches(:block_on, :with => with).should.equal with
+
+    Story.cache_store.expects(:get).with("Story:block_on:#{with}").returns(:okay)
+    Story.cache_store.expects(:set).never
+    Story.caches(:block_on, :with => with).should.equal :okay
+  end
+
+  specify "should be able to cache arbitrary methods with a nil argument using #caches and :with" do
+    with = nil
+
+    Story.cache_store.expects(:get).returns(nil)
+    Story.cache_store.expects(:set).with("Story:pass_through:#{with}", :_nil, 1500)
+    Story.caches(:pass_through, :with => with).should.equal with
+  end
+
+  specify "should be able to cache arbitrary methods with arguments using #caches and :withs" do
+    withs = [ :first, :second ] 
+
+    cached_string = "first: #{withs.first} | second: #{withs.last}"
+
+    Story.cache_store.expects(:get).returns(nil)
+    Story.cache_store.expects(:set).with("Story:two_params:#{withs}", cached_string, 1500)
+    Story.caches(:two_params, :withs => withs).should.equal cached_string
+
+    Story.cache_store.expects(:get).with("Story:two_params:#{withs}").returns(:okay)
+    Story.cache_store.expects(:set).never
+    Story.caches(:two_params, :withs => withs).should.equal :okay
+  end
+
+  specify "should set nil when trying to set nil" do
+    Story.set_cache(3, nil).should.equal nil
+    Story.get_cache(3).should.equal nil
+  end
+
+  specify "should set false when trying to set false" do
+    Story.set_cache(3, false).should.equal false
+    Story.get_cache(3).should.equal false
+  end
+
+  specify "should be able to expire a cache key" do
+    Story.should.have.cached 2
+    Story.expire_cache(2).should.equal true
+    Story.should.not.have.cached 2
+  end
+
+  specify "should return true when trying to expire the cache" do
+    Story.should.not.have.cached 1
+    Story.expire_cache(1).should.equal true
+    Story.should.have.cached 2
+    Story.expire_cache(2).should.equal true
+  end
+
+  specify "should be able to reset a cache key, returning the cached object if successful" do
+    Story.expects(:find).with(2).returns(@story2)
+    Story.should.have.cached 2
+    Story.reset_cache(2).should.equal @story2
+    Story.should.have.cached 2
+  end
+
+  specify "should be able to cache the value of a block" do
+    Story.should.not.have.cached :block
+    Story.get_cache(:block) { "this is a block" }
+    Story.should.have.cached :block
+    Story.get_cache(:block).should.equal "this is a block"
+  end
+
+  specify "should be able to define a class level ttl" do
+    ttl = 1124
+    Story.cache_config[:ttl] = ttl
+    Story.cache_config[:store].expects(:set).with(Story.cache_key(1), @story, ttl)
+    Story.get_cache(1)
+  end
+
+  specify "should be able to define a per-key ttl" do
+    ttl = 3262
+    Story.cache_config[:store].expects(:set).with(Story.cache_key(1), @story, ttl)
+    Story.get_cache(1, :ttl => ttl)
+  end
+
+  specify "should be able to skip cache gets" do
+    Story.should.have.cached 2
+    ActsAsCached.skip_cache_gets = true
+    Story.expects(:find).at_least_once
+    Story.get_cache(2)
+    ActsAsCached.skip_cache_gets = false
+  end
+
+  specify "should be able to use an arbitrary finder method via :finder" do
+    Story.expire_cache(4)
+    Story.cache_config[:finder] = :find_live
+    Story.expects(:find_live).with(4).returns(false)
+    Story.get_cache(4)
+  end
+
+  specify "should raise an exception if no finder method is found" do
+    Story.cache_config[:finder] = :find_penguins
+    proc { Story.get_cache(1) }.should.raise(NoMethodError)
+  end
+
+  specify "should be able to use an abitrary cache_id method via :cache_id" do
+    Story.expire_cache(4)
+    Story.cache_config[:cache_id] = :title
+    story = Story.get_cache(1)
+    story.cache_id.should.equal story.title
+  end
+
+  specify "should modify its cache key to reflect a :version option" do
+    Story.cache_config[:version] = 'new' 
+    Story.cache_key(1).should.equal 'Story:new:1'
+  end
+  
+  specify "should truncate the key normally if we dont have a namespace" do
+    Story.stubs(:cache_namespace).returns(nil)
+    key = "a" * 260
+    Story.cache_key(key).length.should == 250
+  end
+  
+  specify "should truncate key with length over 250, including namespace if set" do
+    Story.stubs(:cache_namespace).returns("37-power-moves-app" )
+    key = "a" * 260
+    (Story.cache_namespace + Story.cache_key(key)).length.should == (250 - 1)
+  end
+
+  specify "should raise an informative error message when trying to set_cache with a proc" do
+    Story.cache_config[:store].expects(:set).raises(TypeError.new("Can't marshal Proc"))
+    proc { Story.set_cache('proc:d', proc { nil }) }.should.raise(ActsAsCached::MarshalError)
+  end
+end
+
+context "Passing an array of ids to get_cache" do
+  include StoryCacheSpecSetup
+
+  setup do
+    @grab_stories = proc do 
+      @stories = Story.get_cache(1, 2, 3)
+    end 
+
+    @keys = 'Story:1', 'Story:2', 'Story:3'
+    @hash = {
+      'Story:1' => nil,
+      'Story:2' => $stories[2],
+      'Story:3' => nil
+    }
+
+    # TODO: doh, probably need to clean this up...
+    @cache = $with_memcache ? CACHE : $cache
+
+    @cache.expects(:get_multi).with(*@keys).returns(@hash)
+  end
+
+  specify "should try to fetch those ids using get_multi" do
+    @grab_stories.call
+
+    @stories.size.should.equal 3
+    @stories.should.be.an.instance_of Hash
+    @stories.each { |id, story| story.should.be.an.instance_of Story }
+  end
+
+  specify "should pass the cache miss ids to #find" do
+    Story.expects(:find).with(%w(1 3)).returns($stories[1], $stories[3])
+    @grab_stories.call
+  end
+end
+
+context "Passing an array of ids to get_cache using a cache which doesn't support get_multi" do
+  include StoryCacheSpecSetup
+
+  setup do
+    @grab_stories = proc do 
+      @stories = Story.get_cache(1, 2, 3)
+    end 
+
+    # TODO: doh, probably need to clean this up...
+    @cache = $with_memcache ? CACHE : $cache
+  end
+
+  specify "should raise an exception" do
+    class << @cache; undef :get_multi end
+    proc { @grab_stories.call }.should.raise(ActsAsCached::NoGetMulti)
+  end
+end
+
+context "A Ruby object acting as cached" do
+  include StoryCacheSpecSetup
+
+  specify "should be able to retrieve a cached version of itself" do
+    Story.expects(:get_cache).with(1, {}).at_least_once
+    @story.get_cache
+  end
+
+  specify "should be able to set itself to the cache" do
+    Story.expects(:set_cache).with(1, @story, nil).at_least_once
+    @story.set_cache
+  end
+
+  specify "should cache the value of a passed block" do
+    @story.should.not.have.cached :block
+    @story.get_cache(:block) { "this is a block" }
+    @story.should.have.cached :block
+    @story.get_cache(:block).should.equal "this is a block"
+  end
+  
+  specify "should allow setting custom options by passing them to get_cache" do
+    Story.expects(:set_cache).with('1:options', 'cached value', 1.hour)
+    @story.get_cache(:options, :ttl => 1.hour) { 'cached value' }
+  end
+
+  specify "should be able to expire its cache" do
+    Story.expects(:expire_cache).with(2)
+    @story2.expire_cache
+  end
+
+  specify "should be able to reset its cache" do
+    Story.expects(:reset_cache).with(2)
+    @story2.reset_cache
+  end
+
+  specify "should be able to tell if it is cached" do
+    @story.should.not.be.cached
+    @story2.should.be.cached
+  end
+
+  specify "should be able to set itself to the cache with an arbitrary ttl" do
+    ttl = 1500
+    Story.expects(:set_cache).with(1, @story, ttl)
+    @story.set_cache(ttl)
+  end
+
+  specify "should be able to cache arbitrary instance methods using caches" do
+    Story.cache_store.expects(:get).returns(nil)
+    Story.cache_store.expects(:set).with('Story:1:something_flashy', :molassy, 1500)
+    @story.caches(:something_flashy).should.equal :molassy
+
+    Story.cache_store.expects(:get).returns(:molassy)
+    Story.cache_store.expects(:set).never
+    @story.caches(:something_flashy).should.equal :molassy
+  end
+end

data/test/config_test.rb

@@ -0,0 +1,128 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+context "The global cache configuration" do
+  # Pass in a hash to update the config.
+  # If the first arg is a symbol, an expectation will be set.
+  def setup_config(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    @config[RAILS_ENV].update options.stringify_keys
+    ActsAsCached::Config.expects(args.first) if args.first.is_a? Symbol
+    ActsAsCached.config = @config
+  end
+
+  setup do
+    ActsAsCached.config.clear
+    @config = YAML.load_file('defaults/memcached.yml.default')
+    @config['test'] = @config['development'].merge('benchmarking' => false, 'disabled' => false)
+  end
+
+  specify "should be able to set itself as the session store" do
+    setup_config :setup_session_store, :sessions => true
+  end
+
+  specify "should be able to set itself as the fragment store" do
+    setup_config :setup_fragment_store!, :fragments => true
+  end
+
+  specify "should construct a namespace from the environment and a config value" do
+    setup_config
+    ActsAsCached.config[:namespace].should.equal "app-#{RAILS_ENV}"
+  end
+
+  specify "should be able to set a global default ttl" do
+    setup_config
+    Story.send :acts_as_cached
+    ActsAsCached.config[:ttl].should.not.be.nil
+    Story.cache_config[:ttl].should.equal ActsAsCached.config[:ttl]
+  end
+
+  specify "should be able to swallow errors" do
+    setup_config :raise_errors => false
+    Story.send :acts_as_cached
+    Story.stubs(:find).returns(Story.new)
+    Story.cache_config[:store].expects(:get).raises(MemCache::MemCacheError)
+    Story.cache_config[:store].expects(:set).returns(true)
+    proc { Story.get_cache(1) }.should.not.raise(MemCache::MemCacheError)
+  end
+
+  specify "should not swallow marshal errors" do
+    setup_config :raise_errors => false
+    Story.send :acts_as_cached
+    Story.stubs(:find).returns(Story.new)
+    Story.cache_config[:store].expects(:get).returns(nil)
+    Story.cache_config[:store].expects(:set).raises(TypeError.new("Some kind of Proc error"))
+    proc { Story.get_cache(1) }.should.raise(ActsAsCached::MarshalError)
+  end
+
+  specify "should be able to re-raise errors" do
+    setup_config :raise_errors => true
+    Story.send :acts_as_cached
+    Story.cache_config[:store].expects(:get).raises(MemCache::MemCacheError)
+    proc { Story.get_cache(1) }.should.raise(MemCache::MemCacheError)
+  end
+
+  specify "should be able to enable benchmarking" do
+    setup_config :benchmarking => true
+    ActsAsCached.config[:benchmarking].should.equal true
+    Story.send :acts_as_cached
+    Story.methods.should.include 'fetch_cache_with_benchmarking'
+  end
+
+  specify "should be able to disable all caching" do
+    setup_config :disabled => true
+    Story.send :acts_as_cached
+    Story.should.respond_to :fetch_cache_with_disabled
+    ActsAsCached.config[:disabled].should.equal true
+  end
+
+  specify "should be able to use a global store other than memcache" do
+    setup_config :store => 'HashStore'
+    ActsAsCached.config[:store].should.equal HashStore.new
+    Story.send :acts_as_cached
+    Story.cache_config[:store].should.be ActsAsCached.config[:store]
+  end
+
+  specify "should be able to override the memcache-client hashing algorithm" do
+    setup_config :fast_hash => true
+    ActsAsCached.config[:fast_hash].should.equal true
+    CACHE.hash_for('eatingsnotcheating').should.equal 1919
+  end
+
+  specify "should be able to override the memcache-client hashing algorithm" do
+    setup_config :fastest_hash => true
+    ActsAsCached.config[:fastest_hash].should.equal true
+    CACHE.hash_for(string = 'eatingsnotcheating').should.equal string.hash
+  end
+  
+end
+
+
+context "The class configuration" do
+  # Setups up the Story class with acts_as_cached using options
+  def setup_cached(options = {})
+    Story.send :acts_as_cached, options
+  end
+
+  specify "should save unknown keys as options and not config" do
+    setup_cached :pengiuns => true
+    Story.cache_options.should.include :pengiuns
+    Story.cache_config.should.not.include :pengiuns
+  end
+
+  specify "should be able to override the default finder" do
+    setup_cached :finder => :find_by_title
+    Story.cache_config[:finder].should.equal :find_by_title
+  end
+  
+  specify "should be able to override the default cache_id" do
+    setup_cached :cache_id => :title
+    Story.cache_config[:cache_id].should.equal :title
+  end
+  
+  specify "should be able to override the default finder and the cache_id using find_by" do
+    setup_cached :find_by => :title
+    Story.cache_config.should.not.include :find
+    Story.cache_config[:finder].should.equal :find_by_title
+    Story.cache_config[:cache_id].should.equal :title
+  end
+end

data/test/disabled_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+context "When the cache is disabled" do
+  setup do
+    @story  = Story.new(:id => 1, :title => "acts_as_cached 2 released!")
+    @story2 = Story.new(:id => 2, :title => "BDD is something you can use")
+    $stories = { 1 => @story, 2 => @story2 }
+
+    config = YAML.load_file('defaults/memcached.yml.default')
+    config['test'] = config['development'].merge('disabled' => true, 'benchmarking' => false)
+    ActsAsCached.config = config
+    Story.send :acts_as_cached
+  end
+
+  specify "get_cache should call through to the finder" do
+    Story.expects(:find).at_least_once.returns(@story2)
+    @story2.get_cache.should.equal @story2
+  end
+
+  specify "expire_cache should return true" do
+    $cache.expects(:delete).never
+    @story2.expire_cache.should.equal true
+  end
+
+  specify "reset_cache should return the object" do
+    $cache.expects(:set).never
+    Story.expects(:find).at_least_once.returns(@story2)
+    @story2.reset_cache.should.equal @story2
+  end
+  
+  specify "set_cache should just return the object" do
+    $cache.expects(:set).never
+    @story2.set_cache.should.equal @story2
+  end
+
+  specify "cached? should return false" do
+    $cache.expects(:get).never
+    @story2.should.not.be.cached
+  end
+end

data/test/extensions_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+module ActsAsCached
+  module Extensions
+    module ClassMethods
+      def user_defined_class_method
+        true
+      end
+    end
+
+    module InstanceMethods
+      def user_defined_instance_method
+        true
+      end
+    end
+  end
+end
+
+context "When Extensions::ClassMethods exists" do
+  include StoryCacheSpecSetup
+
+  specify "caching classes should extend it" do
+    Story.singleton_methods.should.include 'user_defined_class_method'
+  end
+end
+
+context "When Extensions::InstanceMethods exists" do
+  include StoryCacheSpecSetup
+
+  specify "caching classes should include it" do
+    Story.instance_methods.should.include 'user_defined_instance_method'
+  end
+end