garner 0.4.5 → 0.5.0

data/spec/garner/strategies/binding/key/cache_key_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Binding::Key::CacheKey do
+
+  before(:each) do
+    @mock = double('model')
+    @mock.stub(:cache_key) { 'mocks/4' }
+  end
+
+  subject { Garner::Strategies::Binding::Key::CacheKey }
+
+  it_behaves_like 'Garner::Strategies::Binding::Key strategy' do
+    let(:known_bindings) { [@mock] }
+    let(:unknown_bindings) { [@mock.class] }
+  end
+
+  describe 'apply' do
+    it "returns the object's cache key, or nil" do
+      subject.apply(@mock).should eq 'mocks/4'
+    end
+  end
+
+  context 'with real objects' do
+    it_behaves_like 'Garner::Strategies::Binding::Key strategy' do
+      let(:known_bindings) { [Activist.create, Monger.create] }
+      let(:unknown_bindings) { [Monger.identify('m1'), Monger] }
+    end
+  end
+end

data/spec/garner/strategies/binding/key/safe_cache_key_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Binding::Key::SafeCacheKey do
+
+  before(:each) do
+    @new_mock = double('model')
+    @new_mock.stub(:cache_key) { 'mocks/4' }
+    @persisted_mock = double('model')
+    @time_dot_now = Time.now
+    @persisted_mock.stub(:cache_key) { "mocks/4-#{@time_dot_now.utc.to_s(:number)}" }
+    @persisted_mock.stub(:updated_at) { @time_dot_now }
+  end
+
+  subject { Garner::Strategies::Binding::Key::SafeCacheKey }
+
+  it_behaves_like 'Garner::Strategies::Binding::Key strategy' do
+    let(:known_bindings) { [@persisted_mock] }
+    let(:unknown_bindings) { [@new_mock] }
+  end
+
+  describe 'apply' do
+    it "returns the object's cache key + milliseconds if defined" do
+      timestamp = @time_dot_now.utc.to_s(:number)
+      subject.apply(@persisted_mock).should =~ /^mocks\/4-#{timestamp}.[0-9]{10}$/
+    end
+
+    it 'returns nil if :cache_key is undefined or nil' do
+      @persisted_mock.unstub(:cache_key)
+      subject.apply(@persisted_mock).should be_nil
+      @persisted_mock.stub(:cache_key) { nil }
+      subject.apply(@persisted_mock).should be_nil
+    end
+
+    it 'returns nil if :updated_at is undefined or nil' do
+      @persisted_mock.unstub(:updated_at)
+      subject.apply(@persisted_mock).should be_nil
+      @persisted_mock.stub(:updated_at) { nil }
+      subject.apply(@persisted_mock).should be_nil
+    end
+  end
+
+  context 'with real objects' do
+    before(:each) do
+      Garner.configure do |config|
+        config.mongoid_identity_fields = [:_id, :_slugs]
+      end
+
+      @monger = Monger.create(name: 'M1')
+      @food = Food.create(name: 'F1')
+    end
+
+    it_behaves_like 'Garner::Strategies::Binding::Key strategy' do
+      let(:known_bindings) do
+        [Activist.create, @monger, Monger.identify(@monger.id), Monger.identify('m1'), Monger]
+      end
+      let(:unknown_bindings) do
+        [Monger.identify('m2'), Food.identify(nil), Monger.new, Activist.new]
+      end
+    end
+  end
+end

data/spec/garner/strategies/context/key/caller_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Context::Key::Caller do
+  before(:each) do
+    @cache_identity = Garner::Cache::Identity.new
+    @mock_context = double('object')
+  end
+
+  subject { Garner::Strategies::Context::Key::Caller }
+
+  it_behaves_like 'Garner::Strategies::Context::Key strategy'
+
+  it 'ignores nil caller' do
+    @mock_context.stub(:caller) { nil }
+    subject.apply(@cache_identity, @mock_context)
+    @cache_identity.key_hash[:caller].should be_nil
+  end
+
+  it 'ignores nil caller location' do
+    @mock_context.stub(:caller) { [nil] }
+    subject.apply(@cache_identity, @mock_context)
+    @cache_identity.key_hash[:caller].should be_nil
+  end
+
+  it 'ignores blank caller location' do
+    @mock_context.stub(:caller) { [''] }
+    subject.apply(@cache_identity, @mock_context)
+    @cache_identity.key_hash[:caller].should be_nil
+  end
+
+  context 'with default Garner.config.caller_root' do
+    before(:each) do
+      raw_gemfile_parent = File.join(__FILE__, '..', '..', '..', '..', '..', '..')
+      @gemfile_root = Pathname.new(raw_gemfile_parent).realpath.to_s
+    end
+
+    it 'sets default_root to the nearest ancestor with a Gemfile' do
+      subject.default_root.should eq @gemfile_root
+    end
+
+    it 'sets Garner.config.caller_root to the nearest ancestor with a Gemfile' do
+      Garner.config.caller_root.should eq @gemfile_root
+    end
+
+    it 'sets an appropriate value for :caller' do
+      truncated = __FILE__.gsub(@gemfile_root + File::SEPARATOR, '')
+      subject.apply(@cache_identity, self)
+      @cache_identity.key_hash[:caller].should eq "#{truncated}:#{__LINE__ - 1}"
+    end
+  end
+
+  context 'with Rails.root defined' do
+    before(:each) do
+      class Rails
+      end
+      Rails.stub(:root) { Pathname.new(File.dirname(__FILE__)) }
+    end
+
+    it 'sets default_root to Rails.root' do
+      subject.default_root.should eq ::Rails.root.realpath.to_s
+    end
+
+    it 'sets Garner.config.caller_root to Rails.root' do
+      Garner.config.caller_root.should eq ::Rails.root.realpath.to_s
+    end
+
+    it 'sets an appropriate value for :caller' do
+      truncated = File.basename(__FILE__)
+      subject.apply(@cache_identity, self)
+      @cache_identity.key_hash[:caller].should eq "#{truncated}:#{__LINE__ - 1}"
+    end
+  end
+
+  context 'with custom Garner.config.caller_root' do
+    before(:each) do
+      Garner.configure do |config|
+        config.caller_root = File.dirname(__FILE__)
+      end
+    end
+
+    it 'sets an appropriate value for :caller' do
+      truncated = File.basename(__FILE__)
+      subject.apply(@cache_identity, self)
+      @cache_identity.key_hash[:caller].should eq "#{truncated}:#{__LINE__ - 1}"
+    end
+  end
+
+  context 'with Garner.config.caller_root unset' do
+    before(:each) do
+      Garner.configure do |config|
+        config.caller_root = nil
+      end
+    end
+
+    it 'sets an appropriate value for :caller' do
+      subject.apply(@cache_identity, self)
+      @cache_identity.key_hash[:caller].should eq "#{__FILE__}:#{__LINE__ - 1}"
+    end
+
+    it "doesn't require ActiveSupport" do
+      String.any_instance.stub(:blank?) { fail NoMethodError.new }
+      subject.apply(@cache_identity, self)
+      @cache_identity.key_hash[:caller].should eq "#{__FILE__}:#{__LINE__ - 1}"
+    end
+  end
+end

data/spec/garner/strategies/context/key/jsonp_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Context::Key::Jsonp do
+  before(:each) do
+    @cache_identity = Garner::Cache::Identity.new
+    @request = Rack::Request.new('REQUEST_METHOD' => 'GET', 'QUERY_STRING' => 'callback=jQuery21435&_=34234')
+
+    @mock_context = double('object')
+    @mock_context.stub(:request) { @request }
+  end
+
+  subject { Garner::Strategies::Context::Key::Jsonp }
+
+  it_behaves_like 'Garner::Strategies::Context::Key strategy'
+
+  it 'removes JSONP params from the key hash' do
+    request_get = Garner::Strategies::Context::Key::RequestGet
+    applied_identity = request_get.apply(@cache_identity, @mock_context)
+    subject.apply(applied_identity, @mock_context)
+    @cache_identity.key_hash[:request_params].should eq({})
+  end
+end

data/spec/garner/strategies/context/key/request_get_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Context::Key::RequestGet do
+  %w(GET HEAD).each do |method|
+    context method do
+
+      before(:each) do
+        @cache_identity = Garner::Cache::Identity.new
+        @request = Rack::Request.new('REQUEST_METHOD' => method, 'QUERY_STRING' => 'foo=bar')
+
+        @mock_context = double('object')
+        @mock_context.stub(:request) { @request }
+      end
+
+      subject { Garner::Strategies::Context::Key::RequestGet }
+
+      it_behaves_like 'Garner::Strategies::Context::Key strategy'
+
+      it 'adds :request_params to the key' do
+        subject.apply(@cache_identity, @mock_context)
+        @cache_identity.key_hash[:request_params].should eq('foo' => 'bar')
+      end
+
+      it 'appends to an existing key hash' do
+        @cache_identity.key(x: :y)
+        subject.apply(@cache_identity, @mock_context).key_hash.should eq(
+          x: :y,
+          request_params: { 'foo' => 'bar' }
+        )
+      end
+    end
+  end
+end

data/spec/garner/strategies/context/key/request_path_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Context::Key::RequestPath do
+  before(:each) do
+    @cache_identity = Garner::Cache::Identity.new
+    @request = Rack::Request.new('PATH_INFO' => '/foo')
+
+    @mock_context = double('object')
+    @mock_context.stub(:request) { @request }
+  end
+
+  subject { Garner::Strategies::Context::Key::RequestPath }
+
+  it_behaves_like 'Garner::Strategies::Context::Key strategy'
+
+  it 'adds :request_params to the key' do
+    subject.apply(@cache_identity, @mock_context)
+    @cache_identity.key_hash[:request_path].should eq '/foo'
+  end
+
+  it 'appends to an existing key hash' do
+    @cache_identity.key(x: :y)
+    subject.apply(@cache_identity, @mock_context).key_hash.should eq(
+      x: :y,
+      request_path: '/foo'
+    )
+  end
+end

data/spec/garner/strategies/context/key/request_post_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Context::Key::RequestPost do
+  before(:each) do
+    @cache_identity = Garner::Cache::Identity.new
+    @request = Rack::Request.new(
+      Rack::MockRequest.env_for(
+        '/?foo=quux',
+        'REQUEST_METHOD' => 'POST',
+        :input => 'foo=bar'
+      )
+    )
+
+    @mock_context = double('object')
+    @mock_context.stub(:request) { @request }
+  end
+
+  subject { Garner::Strategies::Context::Key::RequestPost }
+
+  it_behaves_like 'Garner::Strategies::Context::Key strategy'
+
+  it 'adds :request_params to the key' do
+    subject.apply(@cache_identity, @mock_context)
+    @cache_identity.key_hash[:request_params].should eq('foo' => 'bar')
+  end
+
+  it 'appends to an existing key hash' do
+    @cache_identity.key(x: :y)
+    subject.apply(@cache_identity, @mock_context).key_hash.should eq(
+      x: :y,
+      request_params: { 'foo' => 'bar' }
+    )
+  end
+end

data/spec/garner/version_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Garner::VERSION do
+  subject do
+    Garner::VERSION
+  end
+  it 'is valid' do
+    subject.should_not be_nil
+    (!!Gem::Version.correct?(subject)).should be_truthy
+  end
+end

data/spec/integration/active_record_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe 'ActiveRecord integration' do
+  context 'using the Garner::Strategies::Binding::Key::CacheKey strategy' do
+
+    describe 'cache key generation' do
+      subject { Garner::Strategies::Binding::Key::CacheKey }
+
+      it_behaves_like 'Garner::Strategies::Binding::Key strategy' do
+        let(:known_bindings) { [Activist.create, Activist.new] }
+        let(:unknown_bindings) { [Activist] }
+      end
+
+      it "returns the object's cache key, or nil" do
+        new_activist = Activist.new
+        subject.apply(new_activist).should eq 'activists/new'
+
+        persisted_activist = Activist.create
+        timestamp = persisted_activist.updated_at.utc.to_s(persisted_activist.cache_timestamp_format)
+        expected_key = "activists/#{persisted_activist.id}-#{timestamp}"
+        subject.apply(persisted_activist).should eq expected_key
+      end
+    end
+
+    describe 'garner_cache_key' do
+      context 'instance' do
+        subject { Activist.create }
+
+        it 'returns a non-nil cache_key' do
+          subject.garner_cache_key.should_not be_nil
+        end
+      end
+
+      context 'class' do
+        subject { Activist }
+
+        it 'should not ' do
+          expect { subject.garner_cache_key }.not_to raise_error
+        end
+      end
+    end
+  end
+end

data/spec/integration/grape_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'garner/mixins/rack'
+require 'grape'
+
+describe 'Grape integration' do
+  class TestCachebuster < Grape::Middleware::Base
+    def after
+      @app_response[1]['Expires'] = Time.at(0).utc.to_s
+      @app_response
+    end
+  end
+
+  let(:app) do
+    class TestGrapeApp < Grape::API
+      helpers Garner::Mixins::Rack
+      use Rack::ConditionalGet
+      use Rack::ETag
+      use TestCachebuster
+
+      format :json
+
+      get '/' do
+        garner do
+          { meaning_of_life: 42 }.to_json
+        end
+      end
+    end
+
+    TestGrapeApp.new
+  end
+
+  it_behaves_like 'Rack::ConditionalGet server'
+end

data/spec/integration/mongoid_spec.rb

@@ -0,0 +1,355 @@
+require 'spec_helper'
+require 'garner/mixins/mongoid'
+
+describe 'Mongoid integration' do
+  before(:each) do
+    @app = Class.new.tap do |app|
+      app.send(:extend, Garner::Cache::Context)
+    end
+  end
+
+  {
+    # Garner::Strategies::Binding::Key::SafeCacheKey => Garner::Strategies::Binding::Invalidation::Touch,
+    Garner::Strategies::Binding::Key::BindingIndex => Garner::Strategies::Binding::Invalidation::BindingIndex
+  }.each do |key_strategy, invalidation_strategy|
+    context "using #{key_strategy} with #{invalidation_strategy}" do
+      before(:each) do
+        Garner.configure do |config|
+          config.binding_key_strategy = key_strategy
+          config.binding_invalidation_strategy = invalidation_strategy
+        end
+      end
+
+      describe 'end-to-end caching and invalidation' do
+        context 'binding at the instance level' do
+          before(:each) do
+            @object = Monger.create!(name: 'M1')
+          end
+
+          describe 'garnered_find' do
+            before(:each) do
+              Garner.configure do |config|
+                config.mongoid_identity_fields = [:_id, :_slugs]
+              end
+            end
+
+            it 'caches one copy across all callers' do
+              Monger.stub(:find) { @object }
+              Monger.should_receive(:find).once
+              2.times { Monger.garnered_find('m1') }
+            end
+
+            it 'returns the instance requested' do
+              Monger.garnered_find('m1').should eq @object
+            end
+
+            it 'can be called with an array of one object, and will return an array' do
+              Monger.garnered_find(['m1']).should eq [@object]
+            end
+
+            it 'is invalidated on changing identity field' do
+              Monger.garnered_find('m1').name.should eq 'M1'
+              @object.update_attributes!(name: 'M2')
+              Monger.garnered_find('m1').name.should eq 'M2'
+            end
+
+            it 'is invalidated on destruction' do
+              Monger.garnered_find('m1').name.should eq 'M1'
+              @object.destroy
+              Monger.garnered_find('m1').should be_nil
+            end
+
+            context 'with case-insensitive find' do
+              before(:each) do
+                find_method = Monger.method(:find)
+                Monger.stub(:find) do |param|
+                  find_method.call(param.to_s.downcase)
+                end
+              end
+
+              it 'does not cache a nil identity' do
+                Monger.garnered_find('M1').should eq @object
+                Monger.garnered_find('foobar').should be_nil
+              end
+            end
+
+            context 'on finding multiple objects' do
+              before(:each) do
+                @object2 = Monger.create!(name: 'M2')
+              end
+
+              it 'returns the instances requested' do
+                Monger.garnered_find('m1', 'm2').should eq [@object, @object2]
+              end
+
+              it 'can take an array' do
+                Monger.garnered_find(%w(m1 m2)).should eq [@object, @object2]
+              end
+
+              it 'is invalidated when one of the objects is changed' do
+                Monger.garnered_find('m1', 'm2').should eq [@object, @object2]
+                @object2.update_attributes!(name: 'M3')
+                Monger.garnered_find('m1', 'm2').last.name.should eq 'M3'
+              end
+
+              it 'is invalidated when one of the objects is changed, passed as an array' do
+                Monger.garnered_find(%w(m1 m2)).should eq [@object, @object2]
+                @object2.update_attributes!(name: 'M3')
+                Monger.garnered_find(%w(m1 m2)).last.name.should eq 'M3'
+              end
+
+              it 'does not return a match when the objects cannot be found' do
+                Monger.garnered_find('m3').should be_nil
+                Monger.garnered_find('m3', 'm4').should eq []
+                Monger.garnered_find(%w(m3 m4)).should eq []
+              end
+
+              it 'does not return a match when some of the objects cannot be found, and returns those that can' do
+                Monger.garnered_find('m1', 'm2').should eq [@object, @object2]
+                @object2.destroy
+                Monger.garnered_find('m1', 'm2').should eq [@object]
+              end
+
+              it 'correctly returns a single object when first asked for a single object as an array' do
+                Monger.garnered_find(['m1']).should eq [@object]
+                Monger.garnered_find('m1').should eq @object
+              end
+
+              it 'correctly returns an array of a single object, when first asked for a single object' do
+                Monger.garnered_find('m1').should eq @object
+                Monger.garnered_find(['m1']).should eq [@object]
+              end
+
+              it 'caches properly when called with an array' do
+                Monger.stub(:find) { @object }
+                Monger.should_receive(:find).once
+                2.times { Monger.garnered_find(%w(m1 m2)) }
+              end
+
+            end
+          end
+
+          [:find, :identify].each do |selection_method|
+            context "binding via #{selection_method}" do
+              let(:cached_object_namer) do
+                lambda do
+                  binding = Monger.send(selection_method, @object.id)
+                  object = Monger.find(@object.id)
+                  @app.garner.bind(binding) { object.name }
+                end
+              end
+
+              it 'invalidates on update' do
+                cached_object_namer.call.should eq 'M1'
+                @object.update_attributes!(name: 'M2')
+                cached_object_namer.call.should eq 'M2'
+              end
+
+              it 'invalidates on destroy' do
+                cached_object_namer.call.should eq 'M1'
+                @object.destroy
+                cached_object_namer.should raise_error
+              end
+
+              it 'invalidates by explicit call to invalidate_garner_caches' do
+                cached_object_namer.call.should eq 'M1'
+                if Mongoid.mongoid3?
+                  @object.set(:name, 'M2')
+                else
+                  @object.set(name: 'M2')
+                end
+                @object.invalidate_garner_caches
+                cached_object_namer.call.should eq 'M2'
+              end
+
+              it 'does not invalidate results for other like-classed objects' do
+                cached_object_namer.call.should eq 'M1'
+                if Mongoid.mongoid3?
+                  @object.set(:name, 'M2')
+                else
+                  @object.set(name: 'M2')
+                end
+                new_monger = Monger.create!(name: 'M3')
+                new_monger.update_attributes!(name: 'M4')
+                new_monger.destroy
+
+                cached_object_namer.call.should eq 'M1'
+              end
+
+              context 'with racing destruction' do
+                before(:each) do
+                  # Define two Mongoid objects for the race
+                  @monger1, @monger2 = 2.times.map { Monger.find(@object.id) }
+                end
+
+                it 'invalidates caches properly (Type I)' do
+                  cached_object_namer.call
+                  @monger1.remove
+                  if Mongoid.mongoid3?
+                    @monger2.set(:name, 'M2')
+                  else
+                    @monger2.set(name: 'M2')
+                  end
+                  @monger1.destroy
+                  @monger2.save
+                  cached_object_namer.should raise_error
+                end
+
+                it 'invalidates caches properly (Type II)' do
+                  cached_object_namer.call
+                  if Mongoid.mongoid3?
+                    @monger2.set(:name, 'M2')
+                  else
+                    @monger2.set(name: 'M2')
+                  end
+                  @monger1.remove
+                  @monger2.save
+                  @monger1.destroy
+                  cached_object_namer.should raise_error
+                end
+              end
+
+              context 'with inheritance' do
+                before(:each) do
+                  @monger = Monger.create!(name: 'M1')
+                  @object = Cheese.create!(name: 'Swiss', monger: @monger)
+                end
+
+                let(:cached_object_namer) do
+                  lambda do
+                    binding = Food.send(selection_method, @object.id)
+                    object = Food.find(@object.id)
+                    @app.garner.bind(binding) { object.name }
+                  end
+                end
+
+                it 'binds to the correct object' do
+                  cached_object_namer.call.should eq 'Swiss'
+                  @object.update_attributes!(name: 'Havarti')
+                  cached_object_namer.call.should eq 'Havarti'
+                end
+              end
+
+              context 'with an embedded document' do
+                before(:each) do
+                  @monger = Monger.create!(name: 'M1')
+                  @fish = @monger.create_fish(name: 'Trout')
+                end
+
+                let(:cached_object_namer) do
+                  lambda do
+                    found = Monger.where('fish._id' => @fish.id).first.fish
+                    @app.garner.bind(found) { found.name }
+                  end
+                end
+
+                it 'binds to the correct object' do
+                  cached_object_namer.call.should eq 'Trout'
+                  @fish.update_attributes!(name: 'Sockeye')
+                  cached_object_namer.call.should eq 'Sockeye'
+                end
+
+                context 'with :invalidate_mongoid_root = true' do
+                  before(:each) do
+                    Garner.configure do |config|
+                      config.invalidate_mongoid_root = true
+                    end
+                  end
+
+                  let(:root_cached_object_namer) do
+                    lambda do
+                      binding = Monger.send(selection_method, @monger.id)
+                      @app.garner.bind(binding) { @monger.fish.name }
+                    end
+                  end
+
+                  it 'invalidates the root document' do
+                    root_cached_object_namer.call.should eq 'Trout'
+                    @fish.update_attributes!(name: 'Sockeye')
+                    root_cached_object_namer.call.should eq 'Sockeye'
+                  end
+                end
+              end
+
+              context 'with multiple identities' do
+                before(:each) do
+                  Garner.configure do |config|
+                    config.mongoid_identity_fields = [:_id, :_slugs]
+                  end
+                end
+
+                let(:cached_object_namer_by_slug) do
+                  lambda do |slug|
+                    binding = Monger.send(selection_method, slug)
+                    object = Monger.find(slug)
+                    @app.garner.bind(binding) { object.name }
+                  end
+                end
+
+                it 'invalidates all identities' do
+                  cached_object_namer.call.should eq 'M1'
+                  cached_object_namer_by_slug.call('m1').should eq 'M1'
+                  @object.update_attributes!(name: 'M2')
+                  cached_object_namer.call.should eq 'M2'
+                  cached_object_namer_by_slug.call('m1').should eq 'M2'
+                end
+              end
+            end
+          end
+        end
+
+        context 'binding at the class level' do
+          ['top-level class', 'subclass'].each do |level|
+            context "to a #{level}" do
+              let(:klass) { level == 'subclass' ? Cheese : Food }
+
+              let(:cached_object_name_concatenator) do
+                lambda do
+                  @app.garner.bind(klass) do
+                    klass.all.order_by(_id: :asc).map(&:name).join(', ')
+                  end
+                end
+              end
+
+              it 'invalidates on create' do
+                Cheese.create(name: 'M1')
+                cached_object_name_concatenator.call.should eq 'M1'
+                Cheese.create(name: 'M3')
+                cached_object_name_concatenator.call.should eq 'M1, M3'
+              end
+
+              it 'invalidates on update' do
+                m1 = Cheese.create(name: 'M1')
+                Cheese.create(name: 'M3')
+                cached_object_name_concatenator.call.should eq 'M1, M3'
+                m1.update_attributes(name: 'M2')
+                cached_object_name_concatenator.call.should eq 'M2, M3'
+              end
+
+              it 'invalidates on destroy' do
+                m1 = Cheese.create(name: 'M1')
+                Cheese.create(name: 'M3')
+                cached_object_name_concatenator.call.should eq 'M1, M3'
+                m1.destroy
+                cached_object_name_concatenator.call.should eq 'M3'
+              end
+
+              it 'invalidates by explicit call to invalidate_garner_caches' do
+                m1 = Cheese.create(name: 'M1')
+                Cheese.create(name: 'M3')
+                cached_object_name_concatenator.call.should eq 'M1, M3'
+                if Mongoid.mongoid3?
+                  m1.set(:name, 'M2')
+                else
+                  m1.set(name: 'M2')
+                end
+                klass.invalidate_garner_caches
+                cached_object_name_concatenator.call.should eq 'M2, M3'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end