cached-models 0.0.2

data/tasks/cached_models_tasks.rake

@@ -0,0 +1,90 @@
+require 'rubygems'
+require 'active_record'
+require 'active_record/fixtures'
+
+path_to_fixtures = File.dirname(__FILE__) + '/../test/fixtures'
+fixtures = %w( authors blogs posts comments tags )
+
+desc 'Run default task (test)'
+task :cached_models => 'cached_models:test'
+
+namespace :cached_models do
+  desc 'Reset the CachedModels data'
+  task :reset => [ :teardown, :setup ]
+
+  desc 'Create CachedModels test database tables and load fixtures'
+  task :setup => [ :create_tables, :load_fixtures ]
+
+  desc 'Remove all CachedModels data'
+  task :teardown => :drop_tables
+
+  desc 'Create CachedModels test database tables'
+  task :create_tables => :environment do
+    ActiveRecord::Schema.define do
+      create_table :authors, :force => true do |t|
+        t.integer :blog_id
+        t.string  :first_name
+        t.string  :last_name
+        t.integer :age
+
+        t.timestamps
+      end
+      
+      create_table :blogs, :force => true do |t|
+        t.string :title
+        
+        t.timestamps
+      end
+      
+      create_table :posts, :force => true do |t|
+        t.integer :author_id
+        t.integer :blog_id
+        t.string :title
+        t.text :text
+        t.datetime :published_at
+
+        t.timestamps
+      end
+      
+      create_table :comments, :force => true do |t|
+        t.integer :post_id
+        t.string :email
+        t.text :text
+        
+        t.timestamps
+      end
+      
+      create_table :tags, :force => true do |t|
+        t.integer :taggable_id
+        t.string :taggable_type
+        t.string :name
+        
+        t.timestamps
+      end
+    end
+  end
+
+  desc 'Drops CachedModels test database tables'
+  task :drop_tables => :environment do
+    ActiveRecord::Base.connection.drop_table :authors
+    ActiveRecord::Base.connection.drop_table :posts
+    ActiveRecord::Base.connection.drop_table :comments
+    ActiveRecord::Base.connection.drop_table :tags
+  end
+
+  desc 'Load fixtures'
+  task :load_fixtures => :environment do
+    fixtures.each { |f| Fixtures.create_fixtures(path_to_fixtures, f) }
+  end
+
+  desc 'Test CachedModels'
+  task :test => [ :setup, 'test:all' ]
+
+  namespace :test do
+    desc 'Run CachedModels tests'
+    Rake::TestTask.new(:all) do |t|
+      t.test_files = FileList["#{File.dirname( __FILE__ )}/../test/**/*_test.rb"]
+      t.verbose = true
+    end
+  end
+end

data/test/active_record/associations/has_many_association_test.rb

@@ -0,0 +1,401 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'active_record/associations/has_many_association'
+
+class HasManyAssociationTest < Test::Unit::TestCase
+  include ActiveRecord::Associations
+  
+  def setup
+    cache.clear rescue nil
+  end
+
+  uses_mocha 'HasManyAssociationTest' do
+    def test_should_always_use_cache_for_all_instances_which_reference_the_same_record
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      expected = authors(:luca).cached_posts
+      actual = Author.first.cached_posts
+      assert_equal expected, actual
+    end
+    
+    def test_should_expire_cache_on_update
+      author = authors(:luca)
+      old_cache_key = author.cache_key
+
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      cache.expects(:delete).with("#{cache_key}/cached_posts").returns true
+
+      author.cached_posts # force cache loading
+      author.update_attributes :first_name => author.first_name.upcase
+
+      # assert_not_equal old_cache_key, author.cache_key
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_not_expire_cache_on_update_on_missing_updated_at
+      author = authors(:luca)
+      old_cache_key = author.cache_key
+
+      author.stubs(:[]).with(:updated_at).returns nil
+      author.expects(:[]).with('blog_id').returns author.blog_id
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      cache.expects(:delete).with("#{cache_key}/cached_posts").never
+      cache.expects(:delete).with("#{cache_key}/cached_comments").never
+      cache.expects(:delete).with("#{cache_key}/cached_posts_with_comments").never
+
+      author.cached_posts # force cache loading
+      author.update_attributes :first_name => author.first_name.upcase
+
+      # assert_not_equal old_cache_key, author.cache_key
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_use_cache_when_find_with_scope
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+
+      post = authors(:luca).cached_posts.find(posts(:welcome).id)
+      assert_equal posts(:welcome), post
+    end
+
+    def test_should_use_cache_when_find_with_scope_using_multiple_ids
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+
+      ids = posts_by_author(:luca).map(&:id)
+      assert_equal posts_by_author(:luca),
+        authors(:luca).cached_posts.find(ids)
+    end
+
+    def test_should_use_cache_when_fetch_first_from_collection
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+      # cache.expects(:read).with("#{cache_key}/cached_posts").returns posts_by_author(:luca)
+
+      assert_equal [ posts_by_author(:luca).first ],
+        authors(:luca).cached_posts.first(1)
+    end
+
+    def test_should_use_cache_when_fetch_last_from_collection
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+      # cache.expects(:read).with("#{cache_key}/cached_posts").returns posts_by_author(:luca)
+
+      assert_equal [ posts_by_author(:luca).last ],
+        authors(:luca).cached_posts.last(1)
+    end
+
+    def test_should_use_cache_when_reset_collection
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+
+      assert_false authors(:luca).cached_posts.reset
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_expire_cache_when_delete_all_elements_from_collection
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      # cache.expects(:read).with("#{cache_key}/cached_posts").returns posts_by_author(:luca)
+
+      authors(:luca).cached_posts.delete_all
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_expire_cache_when_destroy_all_elements_from_collection
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      # cache.expects(:read).with("#{cache_key}/cached_posts").returns posts_by_author(:luca)
+
+      authors(:luca).cached_posts.destroy_all
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_use_cache_on_collection_sum
+      cache.expects(:fetch).with("#{blogs(:weblog).cache_key}/authors").returns authors_association_proxy
+
+      assert_equal authors_by_blog(:weblog).map(&:age).sum,
+        blogs(:weblog).authors.sum(:age)
+    end
+
+    def test_should_not_use_cache_on_false_cached_option
+      cache.expects(:fetch).never
+      authors(:luca).posts
+      authors(:luca).posts(true) # force reload
+    end
+    
+    def test_should_cache_associated_objects
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns(posts_by_author(:luca))
+
+      posts = authors(:luca).cached_posts
+      assert_equal posts, authors(:luca).cached_posts
+    end
+    
+    def test_should_reload_association_and_refresh_the_cache_on_force_reload
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns(posts_by_author(:luca))
+
+      reloaded_posts = authors(:luca).cached_posts(true)
+      assert_equal reloaded_posts, authors(:luca).cached_posts
+    end
+    
+    def test_should_cache_associated_ids
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      cache.expects(:fetch).with("#{cache_key}/cached_post_ids").times(2).returns(posts_by_author(:luca).map(&:id))
+      ids = authors(:luca).cached_post_ids
+      assert_equal ids, authors(:luca).cached_post_ids
+    end
+    
+    def test_should_not_cache_associated_ids_on_false_cached_option
+      cache.expects(:fetch).never
+      authors(:luca).post_ids
+    end
+    
+    def test_should_cache_all_eager_loaded_objects
+      cache.expects(:fetch).with("#{cache_key}/cached_posts_with_comments").times(2).returns(posts_by_author(:luca, true))
+      posts = authors(:luca).cached_posts_with_comments
+      assert_equal posts, authors(:luca).cached_posts_with_comments
+    end
+    
+    def test_should_not_cache_eager_loaded_objects_on_false_cached_option
+      cache.expects(:fetch).never
+      authors(:luca).posts_with_comments
+    end
+    
+    def test_should_cache_polymorphic_associations
+      cache.expects(:fetch).with("#{posts(:cached_models).cache_key}/cached_tags").times(2).returns(tags_by_post(:cached_models))
+      tags = posts(:cached_models).cached_tags
+      assert_equal tags, posts(:cached_models).cached_tags
+    end
+    
+    def test_should_not_cache_polymorphic_associations_on_false_cached_option
+      cache.expects(:fetch).never
+      posts(:cached_models).tags
+    end
+    
+    def test_should_cache_habtm_associations
+      cache.expects(:fetch).with("#{cache_key}/cached_comments").times(2).returns(comments_by_author(:luca))
+      comments = authors(:luca).cached_comments
+      assert_equal comments, authors(:luca).cached_comments
+    end
+    
+    def test_should_not_cache_habtm_associations_on_false_cached_option
+      cache.expects(:fetch).never
+      authors(:luca).comments
+    end
+
+    def test_should_refresh_cache_when_associated_elements_change
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      
+      post = authors(:luca).cached_posts.last # force cache loading and fetch a post
+      post.update_attributes :title => 'Cached Models!'
+      
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_refresh_cache_when_pushing_element_to_association
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      cache.expects(:write).with("#{cache_key}/cached_posts", association_proxy).returns true
+
+      post = create_post :author_id => nil
+      authors(:luca).cached_posts << post
+
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_refresh_caches_when_pushing_element_to_association_belonging_to_another_model
+      cache.expects(:fetch).with("#{authors(:chuck).cache_key}/cached_posts").times(2).returns association_proxy(:chuck)
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+
+      post = authors(:chuck).cached_posts.last
+      authors(:luca).cached_posts << post
+
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+      assert_equal posts_by_author(:chuck), authors(:chuck).cached_posts
+    end
+
+    def test_should_refresh_caches_when_pushing_element_to_polymorphic_association_belonging_to_another_model
+      cache.expects(:fetch).with("#{posts(:welcome).cache_key}/cached_tags").times(2).returns tags_association_proxy
+      cache.expects(:fetch).with("#{posts(:cached_models).cache_key}/cached_tags").times(2).returns tags_association_proxy(:cached_models)
+      tag = posts(:welcome).cached_tags.last
+
+      posts(:cached_models).cached_tags << tag
+
+      # NOTE for some weird reason the assertion fails, even if the collections are equals.
+      # I forced the comparision between the ids.
+      assert_equal tags_by_post(:cached_models).map(&:id).sort,
+        posts(:cached_models).cached_tags.map(&:id).sort
+      assert_equal tags_by_post(:welcome), posts(:welcome).cached_tags
+    end
+
+    def test_should_not_use_cache_when_pushing_element_to_association_on_false_cached_option
+      cache.expects(:write).never
+
+      post = create_post :author_id => nil
+      authors(:luca).posts << post
+    end
+
+    def test_should_not_use_cache_when_pushing_element_to_association_belonging_to_anotner_model_on_false_cached_option
+      cache.expects(:delete).with("#{blogs(:weblog).cache_key}/posts").never
+      post = blogs(:weblog).posts.last
+      blogs(:blog).posts << post
+
+      assert_equal posts_by_blog(:blog), blogs(:blog).posts
+    end
+
+    def test_should_not_use_cache_when_pushing_element_to_polymorphic_association_belonging_to_another_model_on_false_cached_option
+      cache.expects(:delete).never
+      tag = posts(:welcome).tags.last
+      posts(:cached_models).tags << tag
+      
+      assert_equal tags_by_post(:cached_models), posts(:cached_models).tags
+    end
+    
+    def test_should_update_cache_when_pushing_element_with_build
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+
+      author = authors(:luca)
+      post = author.cached_posts.build post_options
+      post.save
+      
+      assert_equal posts_by_author(:luca), author.cached_posts
+    end
+    
+    def test_should_update_cache_when_pushing_element_with_create
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+
+      author = authors(:luca)
+      author.cached_posts.create post_options(:title => "CM Overview")
+      
+      assert_equal posts_by_author(:luca), author.cached_posts
+    end
+
+    def test_should_update_cache_when_pushing_element_with_create_bang_method
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+
+      author = authors(:luca)
+      author.cached_posts.create! post_options(:title => "CM Overview!!")
+
+      assert_equal posts_by_author(:luca), author.cached_posts
+    end
+
+    def test_should_update_cache_when_deleting_element_from_collection
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+
+      authors(:luca).cached_posts.delete(posts_by_author(:luca).first)
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_update_cache_when_clearing_collection
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      authors(:luca).cached_posts.clear
+      
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_update_cache_when_clearing_collection_with_dependent_destroy_option
+      cache.expects(:fetch).with("#{cache_key}/cached_dependent_posts").times(2).returns association_proxy
+      authors(:luca).cached_dependent_posts.clear
+
+      assert_equal posts_by_author(:luca), authors(:luca).cached_dependent_posts
+    end
+    
+    def test_should_update_cache_when_directly_assigning_a_new_collection
+      posts = [ posts_by_author(:luca).first ]
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      authors(:luca).cached_posts = posts
+
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_update_cache_when_replace_collection
+      post = create_post; post.save
+      posts = [ posts_by_author(:luca).first, post ]
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+      authors(:luca).cached_posts.replace(posts)
+
+      assert_equal posts_by_author(:luca), authors(:luca).cached_posts
+    end
+
+    def test_should_use_cache_for_collection_size
+      # cache.expects(:fetch).with("#{cache_key}/cached_posts").times(2).returns association_proxy
+
+      assert_equal posts_by_author(:luca).size,
+        authors(:luca).cached_posts.size
+    end
+
+    def test_should_use_cache_for_collection_length
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+
+      assert_equal posts_by_author(:luca).length,
+        authors(:luca).cached_posts.length
+    end
+
+    def test_should_use_cache_for_collection_empty
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+
+      assert_equal posts_by_author(:luca).empty?,
+        authors(:luca).cached_posts.empty?
+    end
+
+    def test_should_use_cache_for_collection_any
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+
+      assert_equal posts_by_author(:luca).any?,
+        authors(:luca).cached_posts.any?
+    end
+
+    def test_should_use_cache_for_collection_include
+      cache.expects(:fetch).with("#{cache_key}/cached_posts").returns association_proxy
+
+      post = posts_by_author(:luca).first
+      assert authors(:luca).cached_posts.include?(post)
+    end
+  end
+
+  private
+    def posts_by_author(author, include_comments = false)
+      conditions = include_comments ? { :include => :comments } : { }
+      Post.find_all_by_author_id(authors(author).id, conditions)
+    end
+
+    def posts_by_blog(blog)
+      Post.find_all_by_blog_id(blogs(blog).id)
+    end
+
+    def tags_by_post(post)
+      Tag.find_all_by_taggable_id(posts(post).id)
+    end
+
+    def comments_by_author(author)
+      Comment.find(:all, :conditions => ["post_id IN (?)", authors(author).post_ids])
+    end
+
+    def authors_by_blog(blog)
+      Author.find_all_by_blog_id(blogs(blog).id)
+    end
+
+    def association_proxy(author = :luca)
+      HasManyAssociation.new(authors(author), Author.reflect_on_association(:cached_posts))
+    end
+
+    def authors_association_proxy(blog = :weblog)
+      HasManyAssociation.new(blogs(blog), Blog.reflect_on_association(:authors))
+    end
+
+    def tags_association_proxy(post = :welcome)
+      HasManyAssociation.new(posts(post), Post.reflect_on_association(:cached_tags))
+    end
+
+    def comments_association_proxy(author = :luca)
+      HasManyThroughAssociation.new(authors(author), Author.reflect_on_association(:cached_comments))
+    end
+
+    def create_post(options = {})
+      Post.new({ :author_id => 1,
+        :title => 'CachedModels',
+        :text => 'Introduction to CachedModels plugin',
+        :published_at => 1.week.ago }.merge(options))
+    end
+
+    def post_options(options = {})
+      { :blog_id => blogs(:weblog).id,
+        :title => "Cached models review",
+        :text => "Cached models review..",
+        :published_at => 1.week.ago }.merge(options)
+    end
+
+    def cache_key
+      @cache_key ||= authors(:luca).cache_key
+    end
+end

data/test/active_record/base_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class BaseTest < Test::Unit::TestCase
+  fixtures :authors
+
+  def test_should_have_cache
+    assert_equal RAILS_CACHE, ActiveRecord::Base.rails_cache if defined? Rails
+    assert_kind_of ActiveSupport::Cache::Store, ActiveRecord::Base.rails_cache
+  end
+  
+  def test_should_wrap_rails_cache
+    assert_equal RAILS_CACHE, Post.new.send(:rails_cache) if defined? Rails
+    assert_kind_of ActiveSupport::Cache::Store, Post.new.send(:rails_cache)
+  end
+  
+  def test_reflection_cache_key
+    author = authors(:luca)
+    actual = author.send(:reflection_cache_key, Author.reflections[:cached_posts])
+    assert_equal "#{author.cache_key}/cached_posts", actual
+  end
+  
+  def test_cached_association
+    author = authors(:luca)
+    assert_equal({}, author.send(:cached_associations))
+    
+    author.cached_posts # force cache loading
+    assert_equal({:cached_posts => true}, author.send(:cached_associations))
+    
+    author.send(:cache_delete, Author.reflections[:cached_posts])
+    assert_equal({:cached_posts => false}, author.send(:cached_associations))
+  end
+end

data/test/fixtures/authors.yml

@@ -0,0 +1,13 @@
+luca:
+  id: 1
+  blog_id: 1
+  first_name: Luca
+  last_name: Guidi
+  age: <%= Time.now.year - 1982 %>
+
+chuck:
+  id: 2
+  blog_id: 1
+  first_name: Chuck
+  last_name: Palahniuk
+  age: <%= Time.now.year - 1962 %>

data/test/fixtures/blogs.yml

@@ -0,0 +1,7 @@
+weblog:
+  id: 1
+  title: "Luca Guidi weblog"
+
+blog:
+  id: 2
+  title: "TDC"

data/test/fixtures/comments.yml

@@ -0,0 +1,19 @@
+comment:
+  post_id: 1
+  email: john@doe.com
+  text: Good luck for your blog.
+
+positive_comment:
+  post_id: 2
+  email: john@doe.com
+  text: Very nice plugin, thank you!
+
+negative_comment:
+  post_id: 2
+  email: doe@john.com
+  text: Crappy stuff!
+
+comment_for_fight_club:
+  post_id: 3
+  email: john@doe.com
+  text: Awsome book!

data/test/fixtures/posts.yml

@@ -0,0 +1,23 @@
+welcome:
+  id: 1
+  blog_id: 1
+  author_id: 1
+  title: Welcome
+  text: Welcome to my blog
+  published_at: <%= 3.years.ago %>
+
+cached_models:
+  id: 2
+  blog_id: 1
+  author_id: 1
+  title: Cached Models
+  text: Cached Models plugin overview
+  published_at: <%= 2.weeks.ago %>
+
+fight_club:
+  id: 3
+  blog_id: 2
+  author_id: 2
+  title: Fight Club
+  text: This is a Fight Club review
+  published_at: <%= 1.week.ago %>

data/test/fixtures/tags.yml

@@ -0,0 +1,14 @@
+announcements_on_welcome:
+  taggable_id: 1
+  taggable_type: Post
+  name: announcements
+
+plugin_on_cached_models:
+  taggable_id: 2
+  taggable_type: Post
+  name: plugin
+
+rails_on_cached_models:
+  taggable_id: 2
+  taggable_type: Post
+  name: rails

data/test/models/author.rb

@@ -0,0 +1,10 @@
+class Author < ActiveRecord::Base
+  belongs_to :blog, :cached => true
+  has_many :posts
+  has_many :cached_posts, :cached => true, :class_name => 'Post'
+  has_many :cached_dependent_posts, :cached => true, :class_name => 'Post', :dependent => :destroy
+  has_many :posts_with_comments, :class_name => 'Post', :include => :comments
+  has_many :cached_posts_with_comments, :class_name => 'Post', :include => :comments, :cached => true
+  has_many :comments, :through => :posts
+  has_many :cached_comments, :through => :posts, :source => :comments, :cached => true
+end

data/test/models/blog.rb

@@ -0,0 +1,4 @@
+class Blog < ActiveRecord::Base
+  has_many :authors, :cached => true
+  has_many :posts
+end

data/test/models/comment.rb

@@ -0,0 +1,3 @@
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end

data/test/models/post.rb

@@ -0,0 +1,7 @@
+class Post < ActiveRecord::Base
+  belongs_to :author, :cached => true
+  belongs_to :blog
+  has_many :comments
+  has_many :tags, :as => :taggable
+  has_many :cached_tags, :as => :taggable, :class_name => 'Tag', :cached => true
+end

data/test/models/tag.rb

@@ -0,0 +1,3 @@
+class Tag < ActiveRecord::Base
+  belongs_to :taggable, :polymorphic => true
+end

data/test/test_helper.rb

@@ -0,0 +1,42 @@
+ENV["RAILS_ENV"] = "test"
+
+require 'test/unit'
+require 'rubygems'
+require 'active_support'
+require 'action_controller'
+require 'active_support/test_case'
+require 'active_record/fixtures'
+require 'action_controller/integration'
+
+# FIXME load path
+require File.dirname(__FILE__) + '/../../../../config/environment'
+$:.unshift File.dirname(__FILE__) + '/models'
+require 'author'
+require 'post'
+
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures"
+ActionController::IntegrationTest.fixture_path = Test::Unit::TestCase.fixture_path
+
+class Test::Unit::TestCase
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+  fixtures :all
+  
+  # Assert the given condition is false
+  def assert_false(condition, message = nil)
+    assert !condition, message
+  end
+
+  private
+    def cache
+      ActiveRecord::Base.rails_cache
+    end
+end
+
+def uses_mocha(description)
+  require 'rubygems'
+  require 'mocha'
+  yield
+rescue LoadError
+  $stderr.puts "Skipping #{description} tests. `gem install mocha` and try again."
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here