generation_cacheable 1.0.0

data/spec/gen_cache/cache_types/attribute_cache_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe GenCache 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')
+    @post2 = user.posts.create(:title => 'post2')
+    @post3 = descendant.posts.create(:title => 'post3')
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  context "with_attribute" do
+    it "should not cache User.find_by_login" do
+      key = GenCache.attribute_key(User, :login, "flyerhzm")
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should cache by User.find_by_login" do
+      User.find_cached_by_login("flyerhzm").should == user
+      key = GenCache.attribute_key(User, :login, 'flyerhzm')
+      Rails.cache.read(key[:key]).should == {:class => user.class, 'attributes' => user.attributes}
+    end
+
+    it "should get cached by User.find_by_login multiple times" do
+      User.find_cached_by_login("flyerhzm")
+      User.find_cached_by_login("flyerhzm").should == user
+    end
+
+    it "should escape whitespace" do
+      new_user = User.create(:login => "user space")
+      User.find_cached_by_login("user space").should == new_user
+    end
+
+    it "should handle fixed numbers" do
+      Post.find_cached_by_user_id(user.id).should == @post1
+      key = GenCache.attribute_key(Post, :user_id, user.id)
+      Rails.cache.read(key[:key]).should == {:class => @post1.class, 'attributes' => @post1.attributes}
+    end
+
+    context "find_all" do
+      it "should not cache Post.find_all_by_user_id" do
+        key = GenCache.attribute_key(Post, :user_id, user.id, all: true)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache by Post.find_cached_all_by_user_id" do
+        Post.find_cached_all_by_user_id(user.id).should == [@post1, @post2]
+        key = GenCache.attribute_key(Post, :user_id, user.id, all: true)
+        Rails.cache.read(key[:key]).should == [{:class => Post, 'attributes' => @post1.attributes},
+                                                                              {:class => Post, 'attributes' => @post2.attributes}]
+      end
+
+      it "should get cached by Post.find_cached_all_by_user_id multiple times" do
+        Post.find_cached_all_by_user_id(user.id)
+        Post.find_cached_all_by_user_id(user.id).should == [@post1, @post2]
+      end
+
+    end
+  end
+
+  context "descendant" do
+    it "should not cache Descendant.find_by_login" do
+      key = GenCache.attribute_key(Descendant, :login, "scotterc")
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should cache by Descendant.find_by_login" do
+      Descendant.find_cached_by_login("scotterc").should == descendant
+      key = GenCache.attribute_key(Descendant, :login, "scotterc")
+      Rails.cache.read(key[:key]).should == {:class => Descendant, 'attributes' => descendant.attributes}
+    end
+
+    it "should get cached by Descendant.find_by_login multiple times" do
+      Descendant.find_cached_by_login("scotterc")
+      Descendant.find_cached_by_login("scotterc").should == descendant
+    end
+
+    it "should escape whitespace" do
+      new_descendant = Descendant.create(:login => "descendant space")
+      Descendant.find_cached_by_login("descendant space").should == new_descendant
+    end
+
+    it "maintains cached methods" do
+      key = GenCache.method_key(descendant, :name)
+      Rails.cache.read(key[:key]).should be_nil
+      descendant.cached_name.should == descendant.name
+      Rails.cache.read(key[:key]).should == descendant.name
+    end
+  end
+
+end

data/spec/gen_cache/cache_types/class_method_cache_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe GenCache do
+  let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm', :email => 'flyerhzm@mail.com') }
+
+  before :all do
+    @post1 = user.posts.create(:title => 'post1')
+    @post2 = user.posts.create(:title => 'post2')
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  it "should not cache Post.default_post" do
+    key = GenCache.class_method_key(Post, :default_post)
+    Rails.cache.read(key[:key]).should be_nil
+  end
+
+  it "should cache Post.default_post" do
+    key = GenCache.class_method_key(Post, :default_post)
+    Post.cached_default_post.should == @post1
+    Rails.cache.read(key[:key]).should == {:class => @post1.class, 'attributes' => @post1.attributes}
+  end
+
+  it "should cache Post.default_post multiple times" do
+    Post.cached_default_post
+    Post.cached_default_post.should == @post1
+  end
+
+  it "should cache Post.retrieve_with_user_id" do
+    result = Post.cached_retrieve_with_user_id(1)
+    Post.cached_retrieve_with_user_id(1).should == @post1
+    key = GenCache.class_method_key(Post, :retrieve_with_user_id)
+    Rails.cache.read(key[:key]).should == {:"1" => {:class => @post1.class, 'attributes' => @post1.attributes }}
+  end
+
+  it "should cache Post.retrieve_with_both with multiple arguments" do
+    Post.cached_retrieve_with_both(1, 1).should be_true
+    key = GenCache.class_method_key(Post, :retrieve_with_both)
+    Rails.cache.read(key[:key]).should == { :"1+1" => true }
+  end
+
+  describe "marshalling" do
+
+    it "should handle methods with a number argument" do
+      result = User.cached_user_with_id(1)
+      key = GenCache.class_method_key(User, :user_with_id)
+      Rails.cache.read(key[:key]).should == {:"1" => {:class => user.class, 'attributes' => user.attributes }}
+    end
+
+    it "should handle methods with a string argument" do
+      result = User.cached_user_with_email("flyerhzm@mail.com")
+      key = GenCache.class_method_key(User, :user_with_email)
+      Rails.cache.read(key[:key]).should == {:"flyerhzm@mail.com" => {:class => user.class, 'attributes' => user.attributes} }
+    end
+
+    it "should handle methods with an array argument" do
+      result = User.cached_users_with_ids([ 1 ])
+      key = GenCache.class_method_key(User, :users_with_ids)
+      Rails.cache.read(key[:key]).should == {:"1" => [{:class => user.class, 'attributes' => user.attributes}]}
+    end
+
+    it "should handle methods with a range argument" do
+      result = User.cached_users_with_ids_in( (1...3) )
+      key = GenCache.class_method_key(User, "users_with_ids_in")
+      Rails.cache.read(key[:key]).should == {:"1...3" => [{:class => user.class, 'attributes' => user.attributes }] }
+    end
+  end
+end

data/spec/gen_cache/cache_types/key_cache_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe GenCache do
+  let(:cache) { Rails.cache }
+  let(:user)  { User.create(:login => 'flyerhzm') }
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  it "should not cache key" do
+    cache_key = GenCache.instance_key(User, user.id)
+    Rails.cache.read(cache_key[:key]).should be_nil
+  end
+
+  it "should cache by User#id" do
+    User.find_cached(user.id).should == user
+    cache_key = GenCache.instance_key(User, user.id)
+    Rails.cache.read(cache_key[:key]).should == {:class => user.class, 'attributes' => user.attributes}
+  end
+
+  it "should parse formatted cache read successfully" do
+    User.find_cached(user.id)
+    cache_key = GenCache.instance_key(User, user.id)
+    GenCache.fetch(cache_key).should == user
+  end
+
+  it "should get cached by User#id multiple times" do
+    User.find_cached(user.id)
+    User.find_cached(user.id).should == user
+  end
+
+end

data/spec/gen_cache/cache_types/method_cache_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe GenCache 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')
+    @post2 = user.posts.create(:title => 'post2')
+    @post3 = descendant.posts.create(:title => 'post3')
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  it "should not cache User.last_post" do
+    key = GenCache.method_key(user, :last_post)
+    Rails.cache.read(key[:key]).should be_nil
+  end
+
+  it "should cache User#last_post" do
+    user.cached_last_post.should == user.last_post
+    coder = GenCache.format_with_key(user.last_post, :object)
+    key = GenCache.method_key(user, :last_post)
+    Rails.cache.read(key[:key]).should == coder
+  end
+
+  it "should cache User#last_post multiple times" do
+    user.cached_last_post
+    user.cached_last_post.should == user.last_post
+  end
+
+  context "descendant should inherit methods" do
+
+    it "should not cache Descendant.last_post" do
+      key = GenCache.method_key(user, :last_post)
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should cache Descendant#last_post" do
+      descendant.cached_last_post.should == descendant.last_post
+      key = GenCache.method_key(descendant, :last_post)
+      coder = GenCache.format_with_key(descendant.last_post, :object)
+      Rails.cache.read(key[:key]).should == coder
+    end
+
+    it "should cache Descendant#last_post multiple times" do
+      descendant.cached_last_post
+      descendant.cached_last_post.should == descendant.last_post
+    end
+
+    context "as well as new methods" do
+      it "should not cache Descendant.name" do
+        key = GenCache.method_key(descendant, :name)
+        Rails.cache.read(key[:key]).should be_nil
+      end
+
+      it "should cache Descendant#name" do
+        descendant.cached_name.should == descendant.name
+        key = GenCache.method_key(descendant, :name)
+        Rails.cache.read(key[:key]).should == descendant.name
+      end
+
+      it "should cache Descendant#name multiple times" do
+        descendant.cached_name
+        descendant.cached_name.should == descendant.name
+      end
+    end
+  end
+
+  describe "memoization" do
+
+    before :each do
+      user.instance_variable_set("@cached_last_post", nil)
+      user.update_attribute(:login, "pathouse")
+    end
+
+    it "memoizes cache calls" do
+      user.instance_variable_get("@cached_last_post").should be_nil
+      user.cached_last_post.should == user.last_post
+      user.instance_variable_get("@cached_last_post").should == user.last_post
+    end
+
+    it "hits the cache only once" do
+      Rails.cache.expects(:read).returns(user.last_post).once
+      user.cached_last_post.should == user.last_post
+      user.cached_last_post.should == user.last_post
+    end
+
+    describe "bad iv names stripped" do
+      it "should deal with queries" do
+        user.instance_variable_get("@cached_bad_iv_name_bang").should be_nil
+        user.cached_bad_iv_name!.should == 42
+        user.instance_variable_get("@cached_bad_iv_name_bang").should == 42
+      end
+
+      it "should deal with bangs" do
+        user.instance_variable_get("@cached_bad_iv_name_query").should be_nil
+        user.cached_bad_iv_name?.should == 44
+        user.instance_variable_get("@cached_bad_iv_name_query").should == 44
+      end
+    end
+  end
+
+end

data/spec/gen_cache/expiry_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe GenCache 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')
+    user2.posts.create(:title => 'post3')
+    @post3 = descendant.posts.create(:title => 'post3')
+  end
+
+  before :each do
+    cache.clear
+    user.reload
+  end
+
+  context "expire_model_cache" do
+    it "should delete with_key cache" do
+      User.find_cached(user.id)
+      key = GenCache.instance_key(User, user.id)
+      Rails.cache.read(key[:key]).should_not be_nil
+      user.expire_all
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should delete with_attribute cache" do
+      user = User.find_cached_by_login("flyerhzm")
+      key = GenCache.attribute_key(User, :login, "flyerhzm")
+      Rails.cache.read(key[:key]).should == {:class => user.class, 'attributes' => user.attributes}
+      user.expire_all
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should delete with_method cache" do
+      user.cached_last_post
+      key = GenCache.method_key(user, :last_post)
+      Rails.cache.read(key[:key]).should_not be_nil
+      user.update_attribute(:login, "pathouse")
+      key = GenCache.method_key(user, :last_post)
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should delete with_class_method cache (default_post)" do
+      Post.cached_default_post
+      key = GenCache.class_method_key(Post, :default_post)
+      Rails.cache.read(key[:key]).should_not be_nil
+      @post1.expire_all
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should delete with_class_method cache (retrieve_with_user_id)" do
+      Post.cached_retrieve_with_user_id(1)
+      key = GenCache.class_method_key(Post, :retrieve_with_user_id)
+      Rails.cache.read(key[:key]).should_not be_nil
+      @post1.expire_all
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should delete with_class_method cache (retrieve_with_user_id) with different arguments" do
+      Post.cached_retrieve_with_user_id(1)
+      Post.cached_retrieve_with_user_id(2)
+      key = GenCache.class_method_key(Post, :retrieve_with_user_id)
+      Rails.cache.read(key[:key]).should_not be_nil
+      @post1.expire_all
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should delete with_class_method cache (retrieve_with_both)" do
+      Post.cached_retrieve_with_both(1, 1)
+      key = GenCache.class_method_key(Post, :retrieve_with_both)
+      Rails.cache.read(key[:key]).should_not be_nil
+      @post1.expire_all
+      Rails.cache.read(key[:key]).should be_nil
+    end
+
+    it "should delete associations cache" do
+      user.cached_images
+      key = GenCache.association_key(user, :images)
+      Rails.cache.read(key[:key]).should_not be_nil
+      user.update_attribute(:login, 'pathouse')
+      key = GenCache.association_key(user, :images)
+      Rails.cache.read(key[:key]).should == []
+    end
+  end
+
+  context "single table inheritance bug" do
+    context "user" do
+      it "has cached indices" do
+        User.cached_indices.should_not be_nil
+      end
+
+      it "has specific cached indices" do
+        User.cached_indices.keys.should include :login
+        User.cached_indices.keys.should_not include :email
+      end
+
+      it "should have cached_methods" do
+        User.cached_methods.should_not be_nil
+        User.cached_methods.should == [:last_post, :bad_iv_name!, :bad_iv_name?]
+      end
+    end
+
+    context "expiring class_method cache" do
+      it "expires correctly from inherited attributes" do
+        key = GenCache.class_method_key(User, :default_name)
+        Rails.cache.read(key[:key]).should be_nil
+        User.cached_default_name
+        Rails.cache.read(key[:key]).should == "flyerhzm"
+        user.expire_all
+        Rails.cache.read(key[:key]).should be_nil
+      end
+    end
+
+    context "descendant" do
+
+      it "should have cached indices hash" do
+        Descendant.cached_indices.should_not be_nil
+      end
+
+      it "has specific cached indices" do
+        Descendant.cached_indices.keys.should include :login
+        Descendant.cached_indices.keys.should include :email
+      end
+
+      it "should have cached_methods" do
+        Descendant.cached_methods.should_not be_nil
+        Descendant.cached_methods.should == [:last_post, :bad_iv_name!, :bad_iv_name?, :name]
+      end
+
+      context "expiring method cache" do
+        it "expires correctly from inherited attributes" do
+          key = GenCache.method_key(descendant, :last_post)
+          Rails.cache.read(key[:key]).should be_nil
+          descendant.cached_last_post.should == descendant.last_post
+          Rails.cache.read(key[:key]).should == {:class => descendant.last_post.class, 'attributes' => descendant.last_post.attributes}
+          descendant.update_attribute(:login, 'pathouse')
+          key = GenCache.method_key(descendant, :last_post)
+          Rails.cache.read(key[:key]).should be_nil
+        end
+      end
+
+      context "expiring attribute cache" do
+        it "expires correctly from inherited attributes" do
+          descendant.update_attribute(:login, "scotterc")
+          key = GenCache.attribute_key(Descendant, :login, "scotterc")
+          Rails.cache.read(key[:key]).should be_nil
+          Descendant.find_cached_by_login("scotterc").should == descendant
+          Rails.cache.read(key[:key]).should == {:class => descendant.class, 'attributes' => descendant.attributes}
+          descendant.expire_all
+          Rails.cache.read(key[:key]).should be_nil
+        end
+      end
+
+      context "expiring association cache" do
+        it "expires correctly from inherited attributes" do
+          key = GenCache.association_key(descendant, :posts)
+          Rails.cache.read(key[:key]).should be_nil
+          descendant.cached_posts.should == [@post3]
+          Rails.cache.read(key[:key]).should == [GenCache.instance_key(Post, @post3.id)]
+          descendant.update_attribute(:login, "pathouse")
+          key = GenCache.association_key(descendant, :posts)
+          Rails.cache.read(key[:key]).should be_nil
+        end
+      end
+
+      context "expiring class_method cache" do
+        it "expires correctly from inherited attributes" do
+          key = GenCache.class_method_key(Descendant, :default_name)
+          Rails.cache.read(key[:key]).should be_nil
+          Descendant.cached_default_name
+          Rails.cache.read(key[:key]).should == "ScotterC"
+          descendant.expire_all
+          Rails.cache.read(key[:key]).should be_nil
+        end
+      end
+    end
+  end
+
+end