cache-machine 0.1.10 → 0.2.0

data/spec/lib/cache_machine/adapters/rails_spec.rb

@@ -0,0 +1,149 @@
+require "spec_helper"
+
+if ENV["ADAPTER"] != 'redis'
+
+  describe CacheMachine::Adapters::Rails do
+    subject { CacheMachine::Cache::map_adapter }
+
+    let(:cacher) { Cacher.create }
+
+    before :each do
+      CacheMachine::Cache::Mapper.new do
+        resource Cacher do
+          collection :has_many_cacheables
+        end
+      end
+    end
+
+    describe "#append_id_to_map" do
+      let(:key) { subject.get_map_key(cacher, :joins) }
+
+      it "works" do
+        ::Rails.cache.should_receive(:write).with(key, [1])
+        subject.append_id_to_map(cacher, :joins, 1)
+      end
+
+      it "appends keys" do
+        subject.append_id_to_map(cacher, :joins, 1)
+        ::Rails.cache.should_receive(:write).with(key, [1, 2])
+        subject.append_id_to_map(cacher, :joins, 2)
+      end
+
+      it "does not append duplicate key" do
+        subject.append_id_to_map(cacher, :joins, 1)
+        ::Rails.cache.should_receive(:write).with(key, [1])
+        subject.append_id_to_map(cacher, :joins, 1)
+      end
+    end
+
+    describe "#append_id_to_reverse_map" do
+      let(:join) { cacher.joins.create }
+      let(:key) { subject.get_reverse_map_key(Cacher, :joins, join) }
+
+      it "works" do
+        ::Rails.cache.should_receive(:write).with(key, [1])
+        subject.append_id_to_reverse_map(Cacher, :joins, join, 1)
+      end
+
+      it "appends keys" do
+        subject.append_id_to_reverse_map(Cacher, :joins, join, 1)
+        ::Rails.cache.should_receive(:write).with(key, [1, 2])
+        subject.append_id_to_reverse_map(Cacher, :joins, join, 2)
+      end
+
+      it "does not append duplicate key" do
+        subject.append_id_to_reverse_map(Cacher, :joins, join, 1)
+        ::Rails.cache.should_receive(:write).with(key, [1])
+        subject.append_id_to_reverse_map(Cacher, :joins, join, 1)
+      end
+    end
+
+    describe "#association_ids" do
+      let(:cacher) { Cacher.create(:name => 'foo') }
+
+      before :each do
+        Rails.cache.clear
+        cacher.has_many_cacheables.create :id => 1
+        cacher.has_many_cacheables.create :id => 2
+      end
+
+      context "with clear cache" do
+        it("returns ids of an association") do
+          subject.association_ids(cacher, :has_many_cacheables).should =~ [1, 2]
+        end
+      end
+
+      context "filled cache" do
+        it "returns ids from cache if has already requested before" do
+          Rails.cache.should_receive(:fetch).and_return [1, 2]
+          subject.association_ids(cacher, :has_many_cacheables).should =~ [1, 2]
+        end
+      end
+    end
+
+    describe "#fetch" do
+      let(:cache_key) { 'test' }
+      let(:key) { subject.get_content_key(cache_key) }
+
+      it "works" do
+        ::Rails.cache.should_receive(:fetch).with(key, {})
+        subject.fetch(cache_key) { 'cached' }
+      end
+    end
+
+    describe "#fetch_timestamp" do
+      let(:cache_key) { 'test' }
+      let(:key) { subject.get_timestamp_key(cache_key) }
+
+      it "works" do
+        ::Rails.cache.should_receive(:fetch).with(key, {})
+        subject.fetch_timestamp(cache_key) { 'cached' }
+      end
+    end
+
+    describe "#delete" do
+      it "works" do
+        ::Rails.cache.should_receive(:delete).with('test')
+        subject.delete('test')
+      end
+    end
+
+    describe "#delete_content" do
+      let(:content_key) { 'test' }
+      let(:key) { subject.get_content_key(content_key) }
+
+      it "works" do
+        ::Rails.cache.should_receive(:delete).with(key)
+        subject.delete_content(content_key)
+      end
+    end
+
+    describe "#reset_timestamp" do
+      let(:timestamp) { 'test' }
+      let(:key) { subject.get_timestamp_key(timestamp) }
+
+      it "works" do
+        ::Rails.cache.should_receive(:delete).with(key)
+        subject.reset_timestamp(timestamp)
+      end
+    end
+
+    describe "#reverse_association_ids" do
+      let(:target) { cacher.has_many_cacheables.create }
+
+      context "with clear cache" do
+        it "returns ids of an association" do
+          subject.reverse_association_ids(Cacher, :has_many_cacheables, target).should == [cacher.id]
+        end
+      end
+
+      context "filled cache" do
+        it "returns ids from cache if has already requested before" do
+          subject.reverse_association_ids(Cacher, :has_many_cacheables, target)
+          target.should_not_receive(:cache_map_ids)
+          subject.reverse_association_ids(Cacher, :has_many_cacheables, target)
+        end
+      end
+    end
+  end
+end

data/spec/lib/cache_machine/cache/associations_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe CacheMachine::Cache::Associations do
+
+  let(:cacher) { cacher = Cacher.create }
+  let(:join)   { cacher.joins.create    }
+  let(:hmt)    { HasManyThroughCacheable.create(:cachers => [cacher]) }
+
+  before :each do
+    CacheMachine::Cache::Mapper.new do
+      resource Cacher do
+        collection :joins
+        collection :has_many_through_cacheables
+      end
+    end
+  end
+
+  describe "#association_ids" do
+    it "works" do
+      join
+      cacher.association_ids(:joins).should == [join.id]
+    end
+  end
+
+  describe "#associated_from_cache" do
+    it "works" do
+      hmt
+      cacher.associated_from_cache(:has_many_through_cacheables).should == [hmt]
+      cacher.associated_from_cache(:has_many_through_cacheables).should == [hmt]
+    end
+  end
+end

data/spec/lib/cache_machine/cache/class_timestam_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe CacheMachine::Cache::ClassTimestamp do
+  before :each do
+    CacheMachine::Cache::Mapper.new do
+      resource Cacher
+    end
+  end
+
+  describe "#timestamp" do
+    it "works" do
+      Cacher.timestamp
+    end
+
+    it "expires when collection changed" do
+      Cacher.should_receive(:reset_timestamp)
+      Cacher.create
+    end
+  end
+
+  describe "#reset_timestamp" do
+    it "works" do
+      old_timestamp = Cacher.timestamp
+      Time.stub("now").and_return('9999')
+      Cacher.create
+      Cacher.timestamp.should_not == old_timestamp
+    end
+  end
+end

data/spec/lib/cache_machine/cache/collection_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe CacheMachine::Cache::Collection do
+
+  let(:cacher) { cacher = Cacher.create }
+  let(:join)   { cacher.joins.create    }
+  let(:hm)     { cacher.has_many_cacheables.create }
+  let(:hmt)    { HasManyThroughCacheable.create(:cachers => [cacher]) }
+  let(:phm)    { cacher.polymorphics.create }
+
+  before :each do
+    CacheMachine::Cache::Mapper.new do
+      resource Cacher do
+        collection :joins do
+          members :one, :two
+        end
+        collection :has_many_through_cacheables
+        collection :has_many_cacheables
+        collection :polymorphics
+      end
+    end
+  end
+
+  describe "#register_cache_dependency" do
+    let(:register_options) do
+      { :scopes  => :scoped,
+        :on      => :after_save,
+        :members => [:one, :two]
+      }
+    end
+
+    it "registers cache memebers" do
+      Join.cache_map_members.should == { Cacher => { :joins => register_options } }
+    end
+
+    it "appends callbacks" do
+      join.should_receive(:update_resource_collections_cache!).once.with(Cacher)
+      join.save
+    end
+
+    it "hooks update_map callback" do
+      Join.any_instance.should_receive(:update_cache_map!).once.with(cacher, :joins)
+      cacher.joins.create
+    end
+  end
+
+  describe "#update_map!" do
+    after :each do
+      cacher.joins.create
+    end
+
+    it "updates direct association map" do
+      CacheMachine::Cache.map_adapter.should_receive(:append_id_to_map).with(cacher, :joins, kind_of(Numeric))
+    end
+
+    it "updates reverse collection map" do
+      CacheMachine::Cache.map_adapter.should_receive(:append_id_to_reverse_map).with(Cacher, :joins, kind_of(Join), cacher.id)
+    end
+  end
+
+  describe "#update_resource_collections_cache!" do
+
+    context "on has one relation" do
+      after(:each) { join }
+
+      it "works" do
+        CacheMachine::Cache::Map.should_receive(:reset_cache_on_map).with(Cacher, [cacher.id], :one)
+        CacheMachine::Cache::Map.should_receive(:reset_cache_on_map).with(Cacher, [cacher.id], :two)
+        CacheMachine::Cache::Map.should_receive(:reset_cache_on_map).with(Cacher, [cacher.id], :joins)
+      end
+    end
+
+    context "on has many relation" do
+      it "works" do
+        CacheMachine::Cache::Map.should_receive(:reset_cache_on_map).with(Cacher, [cacher.id], :has_many_cacheables)
+        hm
+      end
+
+      it "works on after_add callback" do
+        pending "<<, concat do not call after_add by some reason" do
+          CacheMachine::Cache::Map.should_receive(:reset_cache_on_map).with(Cacher, [cacher.id], :has_many_cacheables)
+          hmc = HasManyCacheable.create
+          cacher.has_many_cacheables << hmc
+        end
+      end
+    end
+
+    context "on has many through relation" do
+      before(:each) { hmt }
+      after(:each) { hmt.save }
+
+      it "works" do
+        CacheMachine::Cache::Map.should_receive(:reset_cache_on_map).with(Cacher, [cacher.id], :has_many_through_cacheables)
+      end
+    end
+
+    context "on polymorphic relation" do
+      before(:each) { phm }
+      after(:each) { phm.save }
+
+      it "works" do
+        CacheMachine::Cache::Map.should_receive(:reset_cache_on_map).with(Cacher, [cacher.id], :polymorphics)
+      end
+    end
+  end
+end

data/spec/lib/cache_machine/cache/map_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe CacheMachine::Cache::Map do
+
+  let(:cacher) { cacher = Cacher.create }
+  let(:join1)  { cacher.joins.create    }
+  let(:join2)  { cacher.joins.create    }
+
+  before :each do
+    CacheMachine::Cache::Mapper.new do
+      resource Cacher do
+        collection :joins
+      end
+    end
+  end
+
+  describe "::fill_associations_map" do
+    before :each do
+      cacher and join1 and join2
+      CacheMachine::Cache::map_adapter.delete(CacheMachine::Cache::map_adapter.get_map_key(cacher, :joins))
+    end
+
+    it "really breaks" do
+      cacher.should_receive(:association_ids)
+      CacheMachine::Cache::map_adapter.association_ids(cacher, :joins)
+    end
+
+    it "works" do
+      CacheMachine::Cache::Map.fill_associations_map(Cacher)
+      cacher.should_not_receive(:association_ids)
+      CacheMachine::Cache::map_adapter.association_ids(cacher, :joins).should =~ [join1.id, join2.id]
+    end
+  end
+end

data/spec/lib/cache_machine/cache/mapper_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe CacheMachine::Cache::Mapper do
+  subject { CacheMachine::Cache::Mapper.new }
+
+  its(:scope) { should == :root }
+
+  describe "#resource" do
+    before :each do
+      subject.resource(Cacher)
+    end
+
+    it "makes module be a resource" do
+      Cacher.include?(CacheMachine::Cache::Resource).should be_true
+    end
+
+    it "changes scope back" do
+      subject.scope.should == :root
+    end
+
+    it "registers model" do
+      CacheMachine::Cache::Map.registered_models.should == [Cacher]
+    end
+  end
+
+  describe "#collection" do
+    let(:register_options) do
+      { :scopes  => :scoped,
+        :on      => :after_save,
+        :members => [:one, :two]
+      }
+    end
+
+    before :each do
+      Join.should_receive(:register_cache_dependency).with(Cacher, :joins, register_options)
+
+      subject.resource(Cacher) do
+        collection(:joins) do
+          member :one
+          member :two
+        end
+      end
+    end
+
+    it "includes collection module in associated class" do
+      Join.include?(CacheMachine::Cache::Collection).should be_true
+    end
+
+    it "changes scope back" do
+      subject.scope.should == :root
+    end
+
+    it "raises an exception when collection is not defined as an association" do
+      lambda {
+        subject.resource(Cacher) do
+          collection :unexisted_relation
+        end
+      }.should raise_error(ArgumentError, "Relation 'unexisted_relation' is not set on the class Cacher")
+    end
+  end
+end

data/spec/lib/cache_machine/cache/resource_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe CacheMachine::Cache::Resource do
+
+  let(:cacher) { cacher = Cacher.create }
+  let(:join)   { cacher.joins.create    }
+  let(:hm)     { cacher.has_many_cacheables.create }
+  let(:hmt)    { HasManyThroughCacheable.create(:cachers => [cacher]) }
+  let(:phm)    { cacher.polymorphics.create }
+
+  before :each do
+    CacheMachine::Cache::Mapper.new do
+      resource Cacher do
+        collection :joins do
+          member :one
+          member :two
+        end
+        collection :has_many_through_cacheables
+        collection :has_many_cacheables
+        collection :polymorphics
+      end
+    end
+  end
+
+  describe "#fetch_cache_of" do
+    it "works" do
+      cacher.fetch_cache_of(:has_many_cacheables) { 'cached' }.should == 'cached'
+      cacher.fetch_cache_of(:has_many_cacheables) { 'non-cached' }.should == 'cached'
+      hm
+      cacher.fetch_cache_of(:has_many_cacheables) { 'updated' }.should == 'updated'
+    end
+
+    context "with timestamps" do
+      it "works" do
+        cacher.fetch_cache_of(:has_many_cacheables, :timestamp => :resource_test_timestamp)  { 'cached' }.should == 'cached'
+        Time.stub(:now).and_return(1)
+        cacher.fetch_cache_of(:has_many_cacheables, :timestamp => :resource_test_timestamp)  { 'non-cached' }.should == 'cached'
+        Time.stub(:now).and_return(2)
+        cacher.fetch_cache_of(:has_many_cacheables, :timestamp => :resource_test_timestamp2) { 'cached-2' }.should == 'cached-2'
+      end
+
+      it "updates when collection changed" do
+        cacher.fetch_cache_of(:has_many_cacheables, :timestamp => :resource_test_timestamp) { 'cached' }.should == 'cached'
+        hm
+        Time.stub("now").and_return('another time comes')
+        cacher.fetch_cache_of(:has_many_cacheables, :timestamp => :resource_test_timestamp) { 'updated' }.should == 'updated'
+      end
+    end
+  end
+
+  describe "#delete_cache_of_only" do
+    it "works" do
+      cacher.fetch_cache_of(:test) { 'cached' }
+      cacher.delete_cache_of_only(:test)
+      cacher.fetch_cache_of(:test) { 'updated' }.should == 'updated'
+    end
+  end
+
+  describe "#delete_cache_of" do
+    context "on collection member" do
+      it "works" do
+        HasManyCacheable.should_receive(:reset_resource_cache).once.with(cacher, :has_many_cacheables)
+        cacher.delete_cache_of(:has_many_cacheables)
+      end
+    end
+
+    context "on virtual member" do
+      it "works" do
+        cacher.should_receive(:delete_cache_of_only).with(:test)
+        cacher.delete_cache_of(:test)
+      end
+    end
+  end
+
+  describe "#delete_all_caches" do
+    it "works" do
+      cacher.fetch_cache_of(:has_many_cacheables) { 'cached' }
+      cacher.fetch_cache_of(:has_many_through_cacheables) { 'cached' }
+
+      cacher.delete_all_caches
+
+      cacher.fetch_cache_of(:has_many_cacheables) { 'updated' }.should == 'updated'
+      cacher.fetch_cache_of(:has_many_through_cacheables) { 'updated' }.should == 'updated'
+    end
+  end
+end