simple_cacheable 1.4.1 → 1.5.0

data/lib/cacheable/types/method_cache.rb

@@ -9,10 +9,17 @@ module Cacheable
       end
 
       methods.each do |meth|
-        define_method("cached_#{meth}") do
-          Rails.cache.fetch method_cache_key(meth) do
-            send(meth)
+        method_name = "cached_#{meth}"
+        define_method(method_name) do
+          iv = Cacheable.escape_punctuation("@#{method_name}")
+          if instance_variable_get(iv).nil?
+            instance_variable_set(iv,
+              (Cacheable.fetch method_cache_key(meth) do
+                send(meth)
+              end)
+            )
           end
+          instance_variable_get(iv)
         end
       end
     end

data/lib/cacheable/version.rb

@@ -1,3 +1,3 @@
 module Cacheable
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

data/spec/cacheable/expiry_cache_spec.rb

@@ -2,41 +2,40 @@ require 'spec_helper'
 
 describe Cacheable do
   let(:cache) { Rails.cache }
-  let(:user)  { User.create(:login => 'flyerhzm') }
-  let(:descendant) { Descendant.create(:login => "scotterc")}
 
   before :all do
-    @post1 = user.posts.create(:title => 'post1')
-    user2 = User.create(:login => 'PelegR')
+    @user       = User.create(:login => 'flyerhzm')
+    @descendant = Descendant.create(:login => "scotterc")
+    @post1      = @user.posts.create(:title => 'post1')
+    user2       = User.create(:login => 'PelegR')
     user2.posts.create(:title => 'post3')
-    @post3 = descendant.posts.create(:title => 'post3')
+    @post3      = @descendant.posts.create(:title => 'post3')
   end
 
   before :each do
-    cache.clear
-    user.reload
+    @user.reload
   end
 
   context "expire_model_cache" do
     it "should delete with_key cache" do
-      User.find_cached(user.id)
-      Rails.cache.read("users/#{user.id}").should_not be_nil
-      user.expire_model_cache
-      Rails.cache.read("users/#{user.id}").should be_nil
+      User.find_cached(@user.id)
+      Rails.cache.read("users/#{@user.id}").should_not be_nil
+      @user.expire_model_cache
+      Rails.cache.read("users/#{@user.id}").should be_nil
     end
 
     it "should delete with_attribute cache" do
-      user = User.find_cached_by_login("flyerhzm")
-      Rails.cache.read("users/attribute/login/flyerhzm").should == user
-      user.expire_model_cache
+      @user = User.find_cached_by_login("flyerhzm")
+      Rails.cache.read("users/attribute/login/flyerhzm").should == {:class => @user.class, 'attributes' => @user.attributes}
+      @user.expire_model_cache
       Rails.cache.read("users/attribute/login/flyerhzm").should be_nil
     end
 
     it "should delete with_method cache" do
-      user.cached_last_post
-      Rails.cache.read("users/#{user.id}/method/last_post").should_not be_nil
-      user.expire_model_cache
-      Rails.cache.read("users/#{user.id}/method/last_post").should be_nil
+      @user.cached_last_post
+      Rails.cache.read("users/#{@user.id}/method/last_post").should_not be_nil
+      @user.expire_model_cache
+      Rails.cache.read("users/#{@user.id}/method/last_post").should be_nil
     end
 
     it "should delete with_class_method cache (default_post)" do
@@ -71,10 +70,10 @@ describe Cacheable do
     end
 
     it "should delete associations cache" do
-      user.cached_images
-      Rails.cache.read("users/#{user.id}/association/images").should_not be_nil
-      user.expire_model_cache
-      Rails.cache.read("users/#{user.id}/association/images").should be_nil
+      @user.cached_images
+      Rails.cache.read("users/#{@user.id}/association/images").should_not be_nil
+      @user.expire_model_cache
+      Rails.cache.read("users/#{@user.id}/association/images").should be_nil
     end
 
   end
@@ -92,7 +91,7 @@ describe Cacheable do
 
       it "should have cached_methods" do
         User.cached_methods.should_not be_nil
-        User.cached_methods.should == [:last_post]
+        User.cached_methods.should == [:last_post, :bad_iv_name!, :bad_iv_name?, :admin?, :hash_with_class_key]
       end
     end
 
@@ -101,7 +100,7 @@ describe Cacheable do
         Rails.cache.read("users/class_method/default_name").should be_nil
         User.cached_default_name
         Rails.cache.read("users/class_method/default_name").should == "flyerhzm"
-        user.expire_model_cache
+        @user.expire_model_cache
         Rails.cache.read("users/class_method/default_name").should be_nil
       end
     end
@@ -119,49 +118,49 @@ describe Cacheable do
 
       it "should have cached_methods" do
         Descendant.cached_methods.should_not be_nil
-        Descendant.cached_methods.should == [:last_post, :name]
+        Descendant.cached_methods.should == [:last_post, :bad_iv_name!, :bad_iv_name?, :admin?, :hash_with_class_key, :name]
       end
 
       context "expiring method cache" do
         it "expires correctly from inherited attributes" do
-          Rails.cache.read("descendants/#{descendant.id}/method/last_post").should be_nil
-          descendant.cached_last_post.should == descendant.last_post
-          Rails.cache.read("descendants/#{descendant.id}/method/last_post").should == descendant.last_post
-          descendant.expire_model_cache
-          Rails.cache.read("descendants/#{descendant.id}/method/last_post").should be_nil
+          Rails.cache.read("users/#{@descendant.id}/method/last_post").should be_nil
+          @descendant.cached_last_post.should == @descendant.last_post
+          Rails.cache.read("users/#{@descendant.id}/method/last_post").should == {:class => @descendant.last_post.class,
+                                                                                  'attributes' => @descendant.last_post.attributes}
+          @descendant.expire_model_cache
+          Rails.cache.read("users/#{@descendant.id}/method/last_post").should be_nil
         end
       end
 
       context "expiring attribute cache" do
         it "expires correctly from inherited attributes" do
-          Rails.cache.read("descendants/attribute/login/scotterc").should be_nil
-          Descendant.find_cached_by_login("scotterc").should == descendant
-          Rails.cache.read("descendants/attribute/login/scotterc").should == descendant
-          descendant.expire_model_cache
-          Rails.cache.read("descendants/attribute/login/scotterc").should be_nil
+          Rails.cache.read("users/attribute/login/scotterc").should be_nil
+          Descendant.find_cached_by_login("scotterc").should == @descendant
+          Rails.cache.read("users/attribute/login/scotterc").should == {:class => @descendant.class, 'attributes' => @descendant.attributes}
+          @descendant.expire_model_cache
+          Rails.cache.read("users/attribute/login/scotterc").should be_nil
         end
       end
 
       context "expiring association cache" do
         it "expires correctly from inherited attributes" do
-          Rails.cache.read("descendants/#{descendant.id}/association/posts").should be_nil
-          descendant.cached_posts.should == [@post3]
-          Rails.cache.read("descendants/#{descendant.id}/association/posts").should == [@post3]
-          descendant.expire_model_cache
-          Rails.cache.read("descendants/#{descendant.id}/association/posts").should be_nil
+          Rails.cache.read("users/#{@descendant.id}/association/posts").should be_nil
+          @descendant.cached_posts.should == [@post3]
+          Rails.cache.read("users/#{@descendant.id}/association/posts").should == [coder(@post3)]
+          @descendant.expire_model_cache
+          Rails.cache.read("users/#{@descendant.id}/association/posts").should be_nil
         end
       end
 
       context "expiring class_method cache" do
         it "expires correctly from inherited attributes" do
-          Rails.cache.read("descendants/class_method/default_name").should be_nil
+          Rails.cache.read("users/class_method/default_name").should be_nil
           Descendant.cached_default_name
-          Rails.cache.read("descendants/class_method/default_name").should == "ScotterC"
-          descendant.expire_model_cache
-          Rails.cache.read("descendants/class_method/default_name").should be_nil
+          Rails.cache.read("users/class_method/default_name").should == "ScotterC"
+          @descendant.expire_model_cache
+          Rails.cache.read("users/class_method/default_name").should be_nil
         end
       end
     end
   end
-
 end

data/spec/cacheable/model_fetch_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Cacheable do
+
+  let(:cache) { Rails.cache }
+
+  before :all do
+    @user   = User.create(:login => 'flyerhzm')
+    @post1  = @user.posts.create(:title => 'post1')
+    @post2  = @user.posts.create(:title => 'post2')
+  end
+
+  describe "singleton fetch" do
+    it "should find an object by id" do
+      key = User.instance_cache_key(1)
+      Cacheable.fetch(key) do
+        User.find(1)
+      end.should == @user
+    end
+  end
+
+  describe "association fetch" do
+    it "should find associations by name" do
+      key = @user.have_association_cache_key(:posts)
+      Cacheable.fetch(key) do
+        @user.send(:posts)
+      end.should == [@post1, @post2]
+    end
+  end
+
+  describe "unit tests" do
+    describe "#write" do
+      it "should write an encoded object to the cache" do
+        Rails.cache.read(@user.model_cache_key).should be_nil
+        Cacheable.send(:write, @user.model_cache_key, @user)
+        Rails.cache.read(@user.model_cache_key).should == { :class => @user.class, 'attributes' => @user.attributes }
+      end
+    end
+
+    describe "#read" do
+      it "should decode an encoded object read from the cache" do
+        Rails.cache.read(@user.model_cache_key).should be_nil
+        Rails.cache.write(@user.model_cache_key, {:class => @user.class, 'attributes' => @user.attributes} )
+        Cacheable.send(:read, @user.model_cache_key).should == @user
+      end
+
+      it "returns nil if value is nil" do
+        Cacheable.send(:read, "clearly_a_nil_key").should be_nil
+      end
+    end
+
+    describe "#coder_from_record" do
+      it "should encode an object" do
+        Cacheable.send(:coder_from_record, @user).should == {:class => @user.class, 'attributes' => @user.attributes}
+      end
+
+      it "returns nil if record is nil" do
+        Cacheable.send(:coder_from_record, nil).should be_nil
+      end
+
+      it "returns the record if it's not an AR object" do
+        Cacheable.send(:coder_from_record, false).should be_false
+      end
+    end
+
+    describe "#record_from_coder" do
+      it "should decode an object" do
+        Cacheable.send(:record_from_coder, {:class => @user.class,
+                                    'attributes' => @user.attributes}).should == @user
+      end
+
+      it "returns the object if it's not a hash" do
+        Cacheable.send(:record_from_coder, false).should be_false
+        Cacheable.send(:record_from_coder, @user).should == @user
+      end
+    end
+  end
+
+  describe "returning a hash with class key" do
+    it "handles a hash with a class key" do
+      hash_value = {:foo => "Bar", :class => "batman"}
+      @user.cached_hash_with_class_key.should == hash_value
+      @user.cached_hash_with_class_key.should == hash_value
+    end
+  end
+end

data/spec/cacheable/types/association_cache_spec.rb

@@ -2,63 +2,106 @@ require 'spec_helper'
 
 describe Cacheable do
   let(:cache) { Rails.cache }
-  let(:user)  { User.create(:login => 'flyerhzm') }
 
   before :all do
-    @post1 = user.posts.create(:title => 'post1')
-    @post2 = user.posts.create(:title => 'post2')
-    @image1 = @post1.images.create
-    @image2 = @post1.images.create
+    @user     = User.create(:login => 'flyerhzm')
+    @user2    =  User.create(:login => 'ScotterC')
+    @post1    = @user.posts.create(:title => 'post1')
+    @post2    = @user.posts.create(:title => 'post2')
+    @post3    = Post.create
+    @image1   = @post1.images.create
+    @image2   = @post1.images.create
     @comment1 = @post1.comments.create
     @comment2 = @post1.comments.create
-    @tag1 = @post1.tags.create(title: "Rails")
-    @tag2 = @post1.tags.create(title: "Caching")
-    @group1 = Group.create(name: "Ruby On Rails")
-    @account = user.create_account(group: @group1)
+    @tag1     = @post1.tags.create(title: "Rails")
+    @tag2     = @post1.tags.create(title: "Caching")
+    @group1   = Group.create(name: "Ruby On Rails")
+    @account  = @user.create_account(group: @group1)
     @location = @post1.create_location(city: "New York")
+    @account_location = @account.create_account_location(city: "New Orleans")
+    @account.save # @account doesn't persist location id?
   end
 
   before :each do
-    cache.clear
-    user.reload
+    @user.reload
+    @post1.reload
   end
 
   context "with_association" do
+    before :each do
+      @post1.instance_variable_set("@cached_user", nil)
+      @comment1.instance_variable_set("@cached_commentable", nil)
+    end
+
     context "belongs_to" do
       it "should not cache association" do
-        Rails.cache.read("users/#{user.id}").should be_nil
+        Rails.cache.read("users/#{@user.id}").should be_nil
       end
 
       it "should cache Post#user" do
-        @post1.cached_user.should == user
-        Rails.cache.read("users/#{user.id}").should == user
+        @post1.cached_user.should == @user
+        Rails.cache.read("users/#{@user.id}").should == coder(@user)
       end
 
       it "should cache Post#user multiple times" do
         @post1.cached_user
-        @post1.cached_user.should == user
+        @post1.cached_user.should == @user
+      end
+
+      it "should not expire cached user on save" do
+        Rails.cache.read("users/#{@user.id}").should be_nil
+        @post1.cached_user.should == @user
+        Rails.cache.read("users/#{@user.id}").should == coder(@user)
+        @post1.save
+        Rails.cache.read("users/#{@user.id}").should == coder(@user)
       end
 
       it "should cache Comment#commentable with polymorphic" do
         Rails.cache.read("posts/#{@post1.id}").should be_nil
         @comment1.cached_commentable.should == @post1
-        Rails.cache.read("posts/#{@post1.id}").should == @post1
+        Rails.cache.read("posts/#{@post1.id}").should == coder(@post1)
+      end
+
+      it "should return nil if there are none" do
+        @post3.cached_user.should be_nil
       end
     end
 
     context "has_many" do
       it "should not cache associations" do
-        Rails.cache.read("users/#{user.id}/association/posts").should be_nil
+        Rails.cache.read("users/#{@user.id}/association/posts").should be_nil
       end
 
       it "should cache User#posts" do
-        user.cached_posts.should == [@post1, @post2]
-        Rails.cache.read("users/#{user.id}/association/posts").should == [@post1, @post2]
+        @user.cached_posts.should == [@post1, @post2]
+        Rails.cache.read("users/#{@user.id}/association/posts").should == [coder(@post1), coder(@post2)]
       end
 
       it "should cache User#posts multiple times" do
-        user.cached_posts
-        user.cached_posts.should == [@post1, @post2]
+        @user.cached_posts
+        @user.cached_posts.should == [@post1, @post2]
+      end
+
+      it "should expire associations on save of associated objects" do
+        pending #heisenbug.  When inspected it works fine
+        Rails.cache.read("users/#{@user.id}/association/posts").should be_nil
+        @user.cached_posts.should == [@post1, @post2]
+        Rails.cache.read("users/#{@user.id}/association/posts").should_not be_nil
+        @post1.save
+        Rails.cache.read("users/#{@user.id}/association/posts").should be_nil
+      end
+
+      it "should expire associations on save of parent" do
+        pending #heisenbug.  When inspected it works fine
+        Rails.cache.read("users/#{@user.id}/association/posts").should be_nil
+        @user.cached_posts.should == [@post1, @post2]
+        Rails.cache.read("users/#{@user.id}/association/posts").should_not be_nil
+        @user.save
+        Rails.cache.read("users/#{@user.id}/association/posts").should be_nil
+      end
+
+      it "should return empty if there are none" do
+        @user2.cached_posts.should == []
       end
     end
 
@@ -69,69 +112,127 @@ describe Cacheable do
 
       it "should cache Post#comments" do
         @post1.cached_comments.should == [@comment1, @comment2]
-        Rails.cache.read("posts/#{@post1.id}/association/comments").should == [@comment1, @comment2]
+        Rails.cache.read("posts/#{@post1.id}/association/comments").should == [coder(@comment1), coder(@comment2)]
       end
 
       it "should cache Post#comments multiple times" do
         @post1.cached_comments
         @post1.cached_comments.should == [@comment1, @comment2]
       end
+
+      it "should expire associations on save" do
+        pending
+        Rails.cache.read("posts/#{@post1.id}/association/comments").should be_nil
+        @post1.cached_comments.should == [@comment1, @comment2]
+        Rails.cache.read("posts/#{@post1.id}/association/comments").should == [coder(@comment1), coder(@comment2)]
+        @post1.save
+        Rails.cache.read("posts/#{@post1.id}/association/comments").should be_nil
+      end
+
+      it "should return empty if there are none" do
+        @post3.cached_comments.should == []
+      end
     end
 
     context "has_one" do
       it "should not cache associations" do
-        Rails.cache.read("users/#{user.id}/association/account").should be_nil
+        Rails.cache.read("users/#{@user.id}/association/account").should be_nil
       end
 
       it "should cache User#posts" do
-        user.cached_account.should == @account
-        Rails.cache.read("users/#{user.id}/association/account").should == @account
+        @user.cached_account.should == @account
+        Rails.cache.read("users/#{@user.id}/association/account").should == coder(@account)
       end
 
       it "should cache User#posts multiple times" do
-        user.cached_account
-        user.cached_account.should == @account
+        @user.cached_account
+        @user.cached_account.should == @account
+      end
+
+      it "should expire association on save" do
+        pending
+        Rails.cache.read("users/#{@user.id}/association/account").should be_nil
+        @user.cached_account.should == @account
+        Rails.cache.read("users/#{@user.id}/association/account").should == coder(@account)
+        @user.save
+        Rails.cache.read("users/#{@user.id}/association/account").should be_nil
+      end
+
+      it "should return nil if there are none" do
+        @user2.cached_account.should be_nil
       end
     end
 
     context "has_many through" do
       it "should not cache associations" do
-        Rails.cache.read("users/#{user.id}/association/images").should be_nil
+        Rails.cache.read("users/#{@user.id}/association/images").should be_nil
       end
 
       it "should cache User#images" do
-        user.cached_images.should == [@image1, @image2]
-        Rails.cache.read("users/#{user.id}/association/images").should == [@image1, @image2]
+        @user.cached_images.should == [@image1, @image2]
+        Rails.cache.read("users/#{@user.id}/association/images").should == [coder(@image1), coder(@image2)]
       end
 
       it "should cache User#images multiple times" do
-        user.cached_images
-        user.cached_images.should == [@image1, @image2]
+        @user.cached_images
+        @user.cached_images.should == [@image1, @image2]
+      end
+
+      it "should expire associations on save" do
+        pending
+        Rails.cache.read("users/#{@user.id}/association/images").should be_nil
+        @user.cached_images.should == [@image1, @image2]
+        Rails.cache.read("users/#{@user.id}/association/images").should == [coder(@image1), coder(@image2)]
+        @user.save
+        Rails.cache.read("users/#{@user.id}/association/images").should be_nil
       end
 
       context "expiry" do
+        before :each do
+          @user.instance_variable_set("@cached_images", nil)
+        end
+
         it "should have the correct collection" do
           @image3 = @post1.images.create
-          Rails.cache.read("users/#{user.id}/association/images").should be_nil
-          user.cached_images.should == [@image1, @image2, @image3]
-          Rails.cache.read("users/#{user.id}/association/images").should == [@image1, @image2, @image3]
+          Rails.cache.read("users/#{@user.id}/association/images").should be_nil
+          @user.cached_images.should == [@image1, @image2, @image3]
+          Rails.cache.read("users/#{@user.id}/association/images").should == [coder(@image1),
+                                                                             coder(@image2),
+                                                                             coder(@image3)]
         end
       end
+
+      it "should return empty if there are none" do
+        @user2.cached_images.should == []
+      end
     end
 
     context "has_one through belongs_to" do
       it "should not cache associations" do
-        Rails.cache.read("users/#{user.id}/association/group").should be_nil
+        Rails.cache.read("users/#{@user.id}/association/group").should be_nil
       end
 
       it "should cache User#group" do
-        user.cached_group.should == @group1
-        Rails.cache.read("users/#{user.id}/association/group").should == @group1
+        @user.cached_group.should == @group1
+        Rails.cache.read("users/#{@user.id}/association/group").should == coder(@group1)
       end
 
       it "should cache User#group multiple times" do
-        user.cached_group
-        user.cached_group.should == @group1
+        @user.cached_group
+        @user.cached_group.should == @group1
+      end
+
+      it "should expire association on save" do
+        pending
+        Rails.cache.read("users/#{@user.id}/association/group").should be_nil
+        @user.cached_group.should == @group1
+        Rails.cache.read("users/#{@user.id}/association/group").should == coder(@group1)
+        @user.save
+        Rails.cache.read("users/#{@user.id}/association/group").should be_nil
+      end
+
+      it "should return nil if there are none" do
+        @user2.cached_group.should be_nil
       end
 
     end
@@ -144,7 +245,7 @@ describe Cacheable do
 
       it "should cache Post#tags" do
         @post1.cached_tags.should == [@tag1, @tag2]
-        Rails.cache.read("posts/#{@post1.id}/association/tags").should == [@tag1, @tag2]
+        Rails.cache.read("posts/#{@post1.id}/association/tags").should == [coder(@tag1), coder(@tag2)]
       end
 
       it "should handle multiple requests" do
@@ -152,12 +253,31 @@ describe Cacheable do
         @post1.cached_tags.should == [@tag1, @tag2]
       end
 
+      it "should expire association on save" do
+        pending
+        Rails.cache.read("posts/#{@post1.id}/association/tags").should be_nil
+        @post1.cached_tags.should == [@tag1, @tag2]
+        Rails.cache.read("posts/#{@post1.id}/association/tags").should == [coder(@tag1), coder(@tag2)]
+        @post1.save
+        Rails.cache.read("posts/#{@post1.id}/association/tags").should be_nil
+      end
+
+      it "should return empty if there are none" do
+        @post3.cached_tags.should == []
+      end
+
       context "expiry" do
+        before :each do
+          @post1.instance_variable_set("@cached_tags", nil)
+        end
+
         it "should have the correct collection" do
           @tag3 = @post1.tags.create!(title: "Invalidation is hard")
           Rails.cache.read("posts/#{@post1.id}/association/tags").should be_nil
           @post1.cached_tags.should == [@tag1, @tag2, @tag3]
-          Rails.cache.read("posts/#{@post1.id}/association/tags").should == [@tag1, @tag2, @tag3]
+          Rails.cache.read("posts/#{@post1.id}/association/tags").should == [coder(@tag1),
+                                                                             coder(@tag2),
+                                                                             coder(@tag3)]
         end
       end
     end
@@ -187,7 +307,7 @@ describe Cacheable do
 
     it "shouldn't hit location" do
       @location.expects(:expire_association_cache).with(:images).never
-      user.save
+      @user.save
     end
 
     context "with a user" do
@@ -214,4 +334,108 @@ describe Cacheable do
 
   end
 
+  # https://github.com/Shopify/identity_cache/pull/55/files
+  describe "rails association cache" do
+    it "should not load associated records" do
+      @user.posts
+      cached_user = User.find_cached(@user.id)
+      cached_user.posts.loaded?.should be_false
+    end
+  end
+
+  describe "memoization" do
+    describe "belongs to" do
+      before :each do
+        @post1.instance_variable_set("@cached_user", nil)
+        @post1.expire_model_cache
+      end
+
+      it "memoizes cache calls" do
+        @post1.instance_variable_get("@cached_user").should be_nil
+        @post1.cached_user.should == @post1.user
+        @post1.instance_variable_get("@cached_user").should == @post1.user
+      end
+
+      it "hits the cache only once" do
+        Rails.cache.expects(:read).returns(coder(@post1.user)).once
+        @post1.cached_user.should == @post1.user
+        @post1.cached_user.should == @post1.user
+      end
+    end
+
+    describe "has through" do
+      before :each do
+        @user.instance_variable_set("@cached_images", nil)
+        @user.expire_model_cache
+      end
+
+      it "memoizes cache calls" do
+        @user.instance_variable_get("@cached_images").should be_nil
+        @user.cached_images.should == @user.images
+        @user.instance_variable_get("@cached_images").should == @user.images
+      end
+
+      it "hits the cache only once" do
+        Rails.cache.expects(:read).returns(coder(@user.images)).once
+        @user.cached_images.should == @user.images
+        @user.cached_images.should == @user.images
+      end
+    end
+
+    describe "has and belongs to many" do
+      before :each do
+        @post1.instance_variable_set("@cached_tags", nil)
+        @post1.expire_model_cache
+      end
+
+      it "memoizes cache calls" do
+        @post1.instance_variable_get("@cached_tags").should be_nil
+        @post1.cached_tags.should == @post1.tags
+        @post1.instance_variable_get("@cached_tags").should == @post1.tags
+      end
+
+      it "hits the cache only once" do
+        Rails.cache.expects(:read).returns(coder(@post1.tags)).once
+        @post1.cached_tags.should == @post1.tags
+        @post1.cached_tags.should == @post1.tags
+      end
+    end
+
+    describe "one to many" do
+      before :each do
+        @user.instance_variable_set("@cached_posts", nil)
+        @user.expire_model_cache
+      end
+
+      it "memoizes cache calls" do
+        @user.instance_variable_get("@cached_posts").should be_nil
+        @user.cached_posts.should == @user.posts
+        @user.instance_variable_get("@cached_posts").should == @user.posts
+      end
+
+      it "hits the cache only once" do
+        Rails.cache.expects(:read).returns(coder(@user.posts)).once
+        @user.cached_posts.should == @user.posts
+        @user.cached_posts.should == @user.posts
+      end
+    end
+  end
+
+  describe "empty polymorphic" do
+    let(:comment) { Comment.new }
+
+    it "should save" do
+      expect {
+        comment.save
+      }.to_not raise_exception
+    end
+  end
+
+  describe "association class name bug" do
+    it "should handle associations with different names" do
+      @user.account.account_location.should == @account_location
+      @user.cached_account.cached_account_location.should == @account_location
+    end
+  end
+
 end