simple_cacheable 1.4.1 → 1.5.0

data/spec/cacheable/types/attribute_cache_spec.rb

@@ -2,18 +2,17 @@ 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')
-    @post2 = user.posts.create(:title => 'post2')
-    @post3 = descendant.posts.create(:title => 'post3')
+    @user       = User.create(:login => 'flyerhzm')
+    @descendant = Descendant.create(:login => "scotterc")
+    @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
+    @user.reload
   end
 
   context "with_attribute" do
@@ -22,13 +21,13 @@ describe Cacheable do
     end
 
     it "should cache by User.find_by_login" do
-      User.find_cached_by_login("flyerhzm").should == user
-      Rails.cache.read("users/attribute/login/flyerhzm").should == user
+      User.find_cached_by_login("flyerhzm").should == @user
+      Rails.cache.read("users/attribute/login/flyerhzm").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
+      User.find_cached_by_login("flyerhzm").should == @user
     end
 
     it "should escape whitespace" do
@@ -37,23 +36,31 @@ describe Cacheable do
     end
 
     it "should handle fixed numbers" do
-      Post.find_cached_by_user_id(user.id).should == @post1
-      Rails.cache.read("posts/attribute/user_id/#{user.id}").should == @post1
+      Post.find_cached_by_user_id(@user.id).should == @post1
+      Rails.cache.read("posts/attribute/user_id/#{@user.id}").should == {:class => @post1.class, 'attributes' => @post1.attributes}
+    end
+
+    it "should return correct nil values" do
+      User.find_cached_by_login("ducksauce").should be_nil
+      User.find_cached_by_login("ducksauce").should be_nil
+      User.find_cached_all_by_login("ducksauce").should == []
+      User.find_cached_all_by_login("ducksauce").should == []
     end
 
     context "find_all" do
       it "should not cache Post.find_all_by_user_id" do
-        Rails.cache.read("posts/attribute/user_id/all/#{user.id}").should be_nil
+        Rails.cache.read("posts/attribute/user_id/all/#{@user.id}").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]
-        Rails.cache.read("posts/attribute/user_id/all/#{user.id}").should == [@post1, @post2]
+        Post.find_cached_all_by_user_id(@user.id).should == [@post1, @post2]
+        Rails.cache.read("posts/attribute/user_id/all/#{@user.id}").should == [{:class => @post1.class, 'attributes' => @post1.attributes},
+                                                                              {:class => @post2.class, '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]
+        Post.find_cached_all_by_user_id(@user.id)
+        Post.find_cached_all_by_user_id(@user.id).should == [@post1, @post2]
       end
 
     end
@@ -61,17 +68,17 @@ describe Cacheable do
 
   context "descendant" do
     it "should not cache Descendant.find_by_login" do
-      Rails.cache.read("descendants/attribute/login/scotterc").should be_nil
+      Rails.cache.read("users/attribute/login/scotterc").should be_nil
     end
 
     it "should cache by Descendant.find_by_login" do
-      Descendant.find_cached_by_login("scotterc").should == descendant
-      Rails.cache.read("descendants/attribute/login/scotterc").should == descendant
+      Descendant.find_cached_by_login("scotterc").should == @descendant
+      Rails.cache.read("users/attribute/login/scotterc").should == {:class => @descendant.class, '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
+      Descendant.find_cached_by_login("scotterc").should == @descendant
     end
 
     it "should escape whitespace" do
@@ -80,9 +87,9 @@ describe Cacheable do
     end
 
     it "maintains cached methods" do
-      Rails.cache.read("descendants/#{descendant.id}/method/name").should be_nil
-      descendant.cached_name.should == descendant.name
-      Rails.cache.read("descendants/#{descendant.id}/method/name").should == descendant.name
+      Rails.cache.read("users/#{@descendant.id}/method/name").should be_nil
+      @descendant.cached_name.should == @descendant.name
+      Rails.cache.read("users/#{@descendant.id}/method/name").should == @descendant.name
     end
   end
 

data/spec/cacheable/types/class_method_cache_spec.rb

@@ -2,42 +2,70 @@ 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')
+    @user  = User.create(:login => 'flyerhzm', :email => 'flyerhzm@mail.com')
+    @post1 = @user.posts.create(:title => 'post1')
+    @post2 = @user.posts.create(:title => 'post2')
   end
 
   before :each do
-    cache.clear
-    user.reload
+    @user.reload
   end
 
-  context "with_class_method" do
-    it "should not cache Post.default_post" do
-      Rails.cache.read("posts/class_method/default_post").should be_nil
+  it "should not cache Post.default_post" do
+    Rails.cache.read("posts/class_method/default_post").should be_nil
+  end
+
+  it "should cache Post.default_post" do
+    Post.cached_default_post.should == @post1
+    Rails.cache.read("posts/class_method/default_post").should == coder(@post1)
+  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
+    Post.cached_retrieve_with_user_id(1).should == @post1
+    Rails.cache.read("posts/class_method/retrieve_with_user_id/1").should == coder(@post1)
+  end
+
+  it "should cache Post.retrieve_with_both with multiple arguments" do
+    Post.cached_retrieve_with_both(1, 1).should be_true
+    Rails.cache.read("posts/class_method/retrieve_with_both/1+1").should be_true
+  end
+
+  describe "argument types" do
+    it "should handle methods with a number argument" do
+      result = User.cached_user_with_id(1)
+      key = User.class_method_cache_key("user_with_id", 1)
+      Rails.cache.read(key).should == coder(result)
     end
 
-    it "should cache Post.default_post" do
-      Post.cached_default_post.should == @post1
-      Rails.cache.read("posts/class_method/default_post").should == @post1
+    it "should handle methods with a string argument" do
+      result = User.cached_user_with_email("flyerhzm@mail.com")
+      key = User.class_method_cache_key("user_with_email", "flyerhzm@mail.com")
+      Rails.cache.read(key).should == coder(result)
     end
 
-    it "should cache Post.default_post multiple times" do
-      Post.cached_default_post
-      Post.cached_default_post.should == @post1
+    it "should handle methods with an array argument" do
+      result = User.cached_users_with_ids([ 1 ])
+      key = User.class_method_cache_key("users_with_ids", [ 1 ])
+      Rails.cache.read(key).should == coder(result)
     end
 
-    it "should cache Post.retrieve_with_user_id" do
-      Post.cached_retrieve_with_user_id(1).should == @post1
-      Rails.cache.read("posts/class_method/retrieve_with_user_id/1").should == @post1
+    it "should handle methods with a range argument" do
+      result = User.cached_users_with_ids_in( (1...3) )
+      key = User.class_method_cache_key("users_with_ids_in", (1...3))
+      Rails.cache.read(key).should == coder(result)
     end
 
-    it "should cache Post.retrieve_with_both with multiple arguments" do
-      Post.cached_retrieve_with_both(1, 1).should be_true
-      Rails.cache.read("posts/class_method/retrieve_with_both/1+1").should be_true
+    it "should handle methods with a hash argument" do
+      result = Post.cached_where_options_are(:title => 'post1')
+      key = Post.class_method_cache_key("where_options_are", {:title => 'post1'})
+      Rails.cache.read(key).should == coder(result)
     end
   end
-
 end

data/spec/cacheable/types/key_cache_spec.rb

@@ -2,26 +2,65 @@ require 'spec_helper'
 
 describe Cacheable do
   let(:cache) { Rails.cache }
-  let(:user)  { User.create(:login => 'flyerhzm') }
+
+  before :all do
+    @user  = User.create(:login => 'flyerhzm')
+    @post1 = @user.posts.create(:title => 'post1')
+  end
 
   before :each do
-    cache.clear
-    user.reload
+    @user.reload
+  end
+
+  it "should not cache key" do
+    Rails.cache.read("users/#{@user.id}").should be_nil
   end
 
-  context "with_key" do
-    it "should not cache key" do
-      Rails.cache.read("users/#{user.id}").should be_nil
+  it "should cache by User#id" do
+    User.find_cached(@user.id).should == @user
+    Rails.cache.read("users/#{@user.id}").should == coder(@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
+
+  describe "it should handle slugs as keys" do
+    it "should have a slug" do
+      @post1.slug.should == @post1.title
+    end
+
+    it "should be accessed by slug" do
+      Post.find(@post1.slug).should == @post1
     end
 
-    it "should cache by User#id" do
-      User.find_cached(user.id).should == user
-      Rails.cache.read("users/#{user.id}").should == user
+    it "should cache it with id" do
+      Rails.cache.read("posts/#{@post1.id}").should == nil
+      Post.find_cached(@post1.id)
+      Rails.cache.read("posts/#{@post1.id}").should == coder(@post1)
     end
 
-    it "should get cached by User#id multiple times" do
-      User.find_cached(user.id)
-      User.find_cached(user.id).should == user
+    it "should cache it with slug" do
+      Rails.cache.read("posts/#{@post1.slug}").should == nil
+      Post.find_cached(@post1.slug)
+      Rails.cache.read("posts/#{@post1.slug}").should == coder(@post1)
+    end
+
+    describe "it should expire both" do
+      it "should expire it with id" do
+        Post.find_cached(@post1.id)
+        Rails.cache.read("posts/#{@post1.id}").should == coder(@post1)
+        @post1.save
+        Rails.cache.read("posts/#{@post1.id}").should == nil
+      end
+
+      it "should expire it with slug" do
+        Post.find_cached(@post1.slug)
+        Rails.cache.read("posts/#{@post1.slug}").should == coder(@post1)
+        @post1.save
+        Rails.cache.read("posts/#{@post1.slug}").should == nil
+      end
     end
   end
 

data/spec/cacheable/types/method_cache_spec.rb

@@ -2,66 +2,105 @@ 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')
-    @post2 = user.posts.create(:title => 'post2')
-    @post3 = descendant.posts.create(:title => 'post3')
+    @user       = User.create(:login => 'flyerhzm')
+    @descendant = Descendant.create(:login => "scotterc")
+    @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
+    @user.reload
   end
 
-  context "with_method" do
-    it "should not cache User.last_post" do
-      Rails.cache.read("users/#{user.id}/method/last_post").should be_nil
+  it "should not cache User.last_post" do
+    Rails.cache.read("users/#{@user.id}/method/last_post").should be_nil
+  end
+
+  it "should cache User#last_post" do
+    @user.cached_last_post.should == @user.last_post
+    Rails.cache.read("users/#{@user.id}/method/last_post").should == coder(@user.last_post)
+  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
+      Rails.cache.read("users/#{@descendant.id}/method/last_post").should be_nil
     end
 
-    it "should cache User#last_post" do
-      user.cached_last_post.should == user.last_post
-      Rails.cache.read("users/#{user.id}/method/last_post").should == user.last_post
+    it "should cache Descendant#last_post" do
+      @descendant.cached_last_post.should == @descendant.last_post
+      Rails.cache.read("users/#{@descendant.id}/method/last_post").should == coder(@descendant.last_post)
     end
 
-    it "should cache User#last_post multiple times" do
-      user.cached_last_post
-      user.cached_last_post.should == user.last_post
+    it "should cache Descendant#last_post multiple times" do
+      @descendant.cached_last_post
+      @descendant.cached_last_post.should == @descendant.last_post
     end
 
-    context "descendant should inherit methods" do
-      it "should not cache Descendant.last_post" do
-        Rails.cache.read("descendants/#{descendant.id}/method/last_post").should be_nil
+    context "as well as new methods" do
+      it "should not cache Descendant.name" do
+        Rails.cache.read("users/#{@descendant.id}/method/name").should be_nil
       end
 
-      it "should cache Descendant#last_post" do
-        descendant.cached_last_post.should == descendant.last_post
-        Rails.cache.read("descendants/#{descendant.id}/method/last_post").should == descendant.last_post
+      it "should cache Descendant#name" do
+        @descendant.cached_name.should == @descendant.name
+        Rails.cache.read("users/#{@descendant.id}/method/name").should == @descendant.name
       end
 
-      it "should cache Descendant#last_post multiple times" do
-        descendant.cached_last_post
-        descendant.cached_last_post.should == descendant.last_post
+      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.expire_model_cache
+    end
 
-      context "as well as new methods" do
-        it "should not cache Descendant.name" do
-          Rails.cache.read("descendants/#{descendant.id}/method/name").should be_nil
-        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 "should cache Descendant#name" do
-          descendant.cached_name.should == descendant.name
-          Rails.cache.read("descendants/#{descendant.id}/method/name").should == descendant.name
-        end
+    it "hits the cache only once" do
+      Cacheable.expects(:fetch).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 cache Descendant#name multiple times" do
-          descendant.cached_name
-          descendant.cached_name.should == descendant.name
-        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
 
+  describe "data types" do
+
+    it "handles boolean values" do
+      Rails.cache.read("users/#{@user.id}/method/admin?").should be_nil
+      @user.cached_admin?.should == false
+      Rails.cache.read("users/#{@user.id}/method/admin?").should be_false
+    end
+  end
+
 end

data/spec/cacheable_spec.rb

@@ -2,28 +2,27 @@ require 'spec_helper'
 
 describe Cacheable do
   let(:cache) { Rails.cache }
-  let(:user)  { User.create(:login => 'flyerhzm') }
 
   before :all do
-    @group1 = Group.create(name: "Ruby On Rails")
-    @account = user.create_account(group: @group1)
-    @post1 = user.posts.create(:title => 'post1')
-    @image1 = @post1.images.create
+    @user     = User.create(:login => 'flyerhzm')
+    @group1   = Group.create(name: "Ruby On Rails")
+    @account  = @user.create_account(group: @group1)
+    @post1    = @user.posts.create(:title => 'post1')
+    @image1   = @post1.images.create
     @comment1 = @post1.comments.create
-    @tag1 = @post1.tags.create(title: "Rails")
+    @tag1     = @post1.tags.create(title: "Rails")
   end
 
   before :each do
-    cache.clear
-    user.reload
+    @user.reload
   end
 
   context "Association Expires on Save" do
     it "should delete has_many with_association cache" do
-      user.cached_posts
-      Rails.cache.read("users/#{user.id}/association/posts").should_not be_nil
+      @user.cached_posts
+      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
+      Rails.cache.read("users/#{@user.id}/association/posts").should be_nil
     end
 
     it "should delete has_many with polymorphic with_association cache" do
@@ -34,17 +33,17 @@ describe Cacheable do
     end
 
     it "should delete has_many through with_association cache" do
-      user.cached_images
-      Rails.cache.read("users/#{user.id}/association/images").should_not be_nil
+      @user.cached_images
+      Rails.cache.read("users/#{@user.id}/association/images").should_not be_nil
       @image1.save
-      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 delete has_one with_association cache" do
-      user.cached_account
-      Rails.cache.read("users/#{user.id}/association/account").should_not be_nil
+      @user.cached_account
+      Rails.cache.read("users/#{@user.id}/association/account").should_not be_nil
       @account.save
-      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 delete has_and_belongs_to_many with_association cache" do
@@ -56,9 +55,9 @@ describe Cacheable do
 
     it "should delete has_one through belongs_to with_association cache" do
       @group1.save
-      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 == @group1
+      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)
     end
   end
 end