garner 0.4.5 → 0.5.0

data/spec/garner/mixins/mongoid/document_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'garner/mixins/mongoid'
+
+describe Garner::Mixins::Mongoid::Document do
+  context 'at the instance level' do
+    before(:each) do
+      Garner.configure do |config|
+        config.mongoid_identity_fields = [:_id, :_slugs]
+      end
+
+      @monger = Monger.create(name: 'M1')
+      @cheese = Cheese.create(name: 'M1')
+    end
+
+    describe 'proxied_classes' do
+      it 'returns all Mongoid superclasses' do
+        @monger.proxied_classes.should eq [Monger]
+        @cheese.proxied_classes.should eq [Cheese, Food]
+      end
+    end
+  end
+
+  context 'at the class level' do
+    subject { Monger }
+
+    describe '_latest_by_updated_at' do
+      it 'returns a Mongoid::Document instance' do
+        subject.create
+        subject.send(:_latest_by_updated_at).should be_a(subject)
+      end
+
+      it 'returns the _latest_by_updated_at document by :updated_at' do
+        mongers = 3.times.map { |i| subject.create(name: "M#{i}") }
+        mongers[1].touch
+
+        subject.send(:_latest_by_updated_at)._id.should eq mongers[1]._id
+        subject.send(:_latest_by_updated_at).updated_at.should eq mongers[1].reload.updated_at
+      end
+
+      it 'returns nil if there are no documents' do
+        subject.send(:_latest_by_updated_at).should be_nil
+      end
+
+      it 'returns nil if updated_at does not exist' do
+        subject.create
+        subject.stub(:fields) { {} }
+        subject.send(:_latest_by_updated_at).should be_nil
+      end
+    end
+
+    describe 'proxy_binding' do
+      it 'returns the _latest_by_updated_at document' do
+        subject.create
+        subject.proxy_binding.should be_a(Monger)
+      end
+
+      it 'responds to :touch' do
+        subject.create
+        subject.any_instance.should_receive(:touch)
+        subject.proxy_binding.touch
+      end
+
+      describe 'cache_key' do
+        it 'matches what would be returned from the full object' do
+          monger = subject.create
+          subject.proxy_binding.cache_key.should eq monger.reload.cache_key
+        end
+
+        context 'with Mongoid subclasses' do
+          subject { Cheese }
+
+          it 'matches what would be returned from the full object' do
+            cheese = subject.create
+            subject.proxy_binding.cache_key.should eq cheese.reload.cache_key
+          end
+        end
+      end
+    end
+  end
+end

data/spec/garner/mixins/mongoid/identity_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'garner/mixins/mongoid'
+
+describe Garner::Mixins::Mongoid::Identity do
+  before(:each) do
+    @mock_strategy = double('strategy')
+    @mock_strategy.stub(:apply)
+    @mock_mongoid_strategy = double('mongoid_strategy')
+    @mock_mongoid_strategy.stub(:apply)
+  end
+
+  describe 'from_class_and_handle' do
+    before(:each) do
+      Garner.configure do |config|
+        config.mongoid_identity_fields = [:_id, :_slugs]
+      end
+    end
+
+    subject { Garner::Mixins::Mongoid::Identity }
+
+    it 'raises an exception if called on a non-Mongoid class' do
+      expect do
+        subject.from_class_and_handle(Class.new, 'id')
+      end.to raise_error
+
+      expect do
+        subject.from_class_and_handle(Monger.new, 'id')
+      end.to raise_error
+    end
+
+    it 'raises an exception if called on an embedded document' do
+      expect do
+        subject.from_class_and_handle(Fish, 'id')
+      end.to raise_error
+    end
+
+    it 'sets klass, handle and a conditions hash' do
+      identity = subject.from_class_and_handle(Monger, 'id')
+      identity.klass.should eq Monger
+      identity.handle.should eq 'id'
+      identity.conditions['$or'].should eq [
+        { _id: 'id' },
+        { _slugs: 'id' }
+      ]
+    end
+
+    context 'on a Mongoid subclass' do
+      it 'sets klass to parent and includes the _type field' do
+        identity = subject.from_class_and_handle(Cheese, 'id')
+        identity.klass.should eq Cheese
+        identity.conditions[:_type].should eq('$in' => ['Cheese'])
+        identity.conditions['$or'].should eq [
+          { _id: 'id' },
+          { _slugs: 'id' }
+        ]
+      end
+    end
+  end
+
+  describe 'to_s' do
+    subject { Monger.identify('m1').to_s }
+
+    it 'stringizes the binding and includes klass and handle' do
+      subject.should be_a(String)
+      subject.should =~ /Monger/
+      subject.should =~ /m1/
+    end
+
+    it 'should not change across identical instances' do
+      subject.should eq Monger.identify('m1').to_s
+    end
+
+    it 'should be different across different instances' do
+      subject.should_not == Monger.identify('m2').to_s
+    end
+  end
+
+  context 'with default configuration and real documents' do
+    before(:each) do
+      Garner.configure do |config|
+        config.mongoid_identity_fields = [:_id, :_slugs]
+      end
+
+      @monger = Monger.create(name: 'M1')
+      @cheese = Cheese.create(name: 'Havarti')
+      @cheese.reload
+    end
+
+    describe 'proxy_binding' do
+      it 'returns nil for nonexistent bindings' do
+        Monger.identify('m2').proxy_binding.should be_nil
+      end
+
+      it 'returns nil for nil bindings' do
+        @monger.unset(:_slugs)
+        Monger.identify(nil).proxy_binding.should be_nil
+      end
+
+      it 'limits the query' do
+        Mongoid::Slug::Criteria.any_instance.should_receive(:limit).with(1).and_return([@monger])
+        Monger.identify('m1').proxy_binding
+      end
+
+      describe 'cache_key' do
+        it "generates a cache key equal to Mongoid::Document's" do
+          Monger.identify('m1').proxy_binding.cache_key.should eq @monger.cache_key
+
+          # Also test for Mongoid subclasses
+          Cheese.identify('havarti').proxy_binding.cache_key.should eq @cheese.cache_key
+          Food.identify(@cheese.id).proxy_binding.cache_key.should eq @cheese.cache_key
+        end
+
+        context 'without Mongoid::Timestamps' do
+          before(:each) do
+            @monger.unset(:updated_at)
+            @cheese.unset(:updated_at)
+          end
+
+          it "generates a cache key equal to Mongoid::Document's" do
+            Monger.identify('m1').proxy_binding.cache_key.should eq @monger.cache_key
+
+            # Also test for Mongoid subclasses
+            Cheese.identify('havarti').proxy_binding.cache_key.should eq @cheese.cache_key
+            Food.identify(@cheese.id).proxy_binding.cache_key.should eq @cheese.cache_key
+          end
+        end
+      end
+
+      describe 'updated_at' do
+        it "returns :updated_at equal to Mongoid::Document's" do
+          Monger.identify('m1').proxy_binding.updated_at.should eq Monger.find('m1').updated_at
+
+          # Also test for Mongoid subclasses
+          Cheese.identify('havarti').proxy_binding.updated_at.should eq @cheese.updated_at
+          Food.identify(@cheese.id).proxy_binding.updated_at.should eq @cheese.updated_at
+        end
+      end
+    end
+  end
+end

data/spec/garner/mixins/rack_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'garner/mixins/rack'
+
+describe Garner::Mixins::Rack do
+
+  describe 'garner' do
+
+    before(:each) do
+      class MockApp
+        include Garner::Mixins::Rack
+
+        def request
+          Rack::Request.new('REQUEST_METHOD' => 'GET', 'QUERY_STRING' => 'foo=bar')
+        end
+      end
+
+      @mock_app = MockApp.new
+    end
+
+    subject do
+      -> { @mock_app.garner }
+    end
+
+    it 'returns a Garner::Cache::Identity' do
+      subject.call.should be_a(Garner::Cache::Identity)
+    end
+
+    it "sets the identity's ruby_binding to self" do
+      subject.call.ruby_context.should eq @mock_app
+    end
+
+    it 'applies each of Garner.config.rack_context_key_strategies' do
+      # Default :context_key_strategies
+      subject.call.key_hash[:caller].should_not be_nil
+      subject.call.key_hash[:request_params].should eq('foo' => 'bar')
+
+      # Custom :context_key_strategies
+      Garner.configure do |config|
+        config.rack_context_key_strategies = [
+          Garner::Strategies::Context::Key::RequestGet
+        ]
+      end
+      subject.call.key_hash[:caller].should be_nil
+      subject.call.key_hash[:request_params].should eq('foo' => 'bar')
+    end
+
+  end
+end

data/spec/garner/strategies/binding/invalidation/binding_index_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Binding::Invalidation::BindingIndex do
+
+  before(:each) do
+    @mock = double('model')
+    @mock.stub(:touch)
+  end
+
+  subject { Garner::Strategies::Binding::Invalidation::BindingIndex }
+
+  it_behaves_like 'Garner::Strategies::Binding::Invalidation strategy'
+
+end

data/spec/garner/strategies/binding/invalidation/touch_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Binding::Invalidation::Touch do
+
+  before(:each) do
+    @mock = double('model')
+    @mock.stub(:touch)
+  end
+
+  subject { Garner::Strategies::Binding::Invalidation::Touch }
+
+  it_behaves_like 'Garner::Strategies::Binding::Invalidation strategy'
+
+  it 'calls :touch on the object' do
+    @mock.should_receive(:touch)
+    subject.apply(@mock)
+  end
+
+  it 'does not raise error if :touch is undefined' do
+    @mock.unstub(:touch)
+    expect { subject.apply(@mock) }.to_not raise_error
+  end
+end

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

@@ -0,0 +1,245 @@
+require 'spec_helper'
+
+describe Garner::Strategies::Binding::Key::BindingIndex do
+
+  before(:each) do
+    @new_mock = double('new_mock')
+
+    @persisted_mock = double('persisted_mock')
+    @persisted_mock.stub(:identity_string) { 'Mocker/id=4' }
+    @persisted_mock.stub(:updated_at) { @time_dot_now }
+
+    @persisted_mock_alias = double('persisted_mock_alias')
+    @persisted_mock_alias.stub(:identity_string) { 'MockerAlias/id=alias-4' }
+    @persisted_mock_alias.stub(:proxy_binding) { @persisted_mock }
+
+    subject.stub(:canonical?) do |binding|
+      binding == @persisted_mock
+    end
+
+    # Marshal.load will return a new mock object, breaking equivalence tests
+    # when fetching from cache.
+    load_method = Marshal.method(:load)
+    Marshal.stub(:load) do |dump|
+      default = load_method.call(dump)
+      if default.is_a?(RSpec::Mocks::Double) &&
+         default.instance_variable_get(:@name) == 'persisted_mock'
+        @persisted_mock
+      else
+        default
+      end
+    end
+
+    # Stub SecureRandom.hex()-generated keys for consistency.
+    @mock_key = 'cc318d04bac07d5d91f06f8c'
+    @mock_alias_key = 'f254b853d7b32406b5749410'
+    @random_key = 'b1d44bb6b369903b28549271'
+    subject.stub(:new_cache_key_for) do |binding|
+      if binding == @persisted_mock
+        @mock_key
+      elsif binding == @persisted_mock_alias
+        @mock_alias_key
+      else
+        SecureRandom.hex(12)
+      end
+    end
+  end
+
+  subject { Garner::Strategies::Binding::Key::BindingIndex }
+
+  it_behaves_like 'Garner::Strategies::Binding::Key strategy' do
+    let(:known_bindings) { [@persisted_mock, @persisted_mock_alias] }
+    let(:unknown_bindings) { [] }
+  end
+
+  describe 'apply' do
+    it 'calls fetch_cache_key_for' do
+      subject.should_receive(:fetch_cache_key_for).with(@persisted_mock)
+      subject.apply(@persisted_mock)
+    end
+  end
+
+  describe 'fetch_cache_key_for' do
+    context 'with a canonical binding' do
+      it 'returns a cache key string' do
+        subject.fetch_cache_key_for(@persisted_mock).should eq @mock_key
+      end
+
+      it 'stores the cache key to cache' do
+        subject.fetch_cache_key_for(@persisted_mock)
+        Garner.config.cache.read(
+                                   strategy: subject,
+                                   proxied_binding: 'Mocker/id=4'
+                                 ).should eq @mock_key
+      end
+    end
+
+    context 'with a non-canonical binding' do
+      it 'returns a cache key string' do
+        subject.fetch_cache_key_for(@persisted_mock_alias).should eq @mock_key
+      end
+
+      it 'stores the canonical binding to cache' do
+        subject.fetch_cache_key_for(@persisted_mock_alias)
+        Garner.config.cache.read(
+                                   strategy: subject,
+                                   proxied_binding: 'MockerAlias/id=alias-4'
+                                 ).should eq @persisted_mock
+      end
+
+      it 'stores the cache key to cache' do
+        subject.fetch_cache_key_for(@persisted_mock_alias)
+        Garner.config.cache.read(
+                                   strategy: subject,
+                                   proxied_binding: 'Mocker/id=4'
+                                 ).should eq @mock_key
+      end
+
+      context 'whose canonical binding is nil' do
+        before(:each) do
+          @persisted_mock_alias.stub(:proxy_binding) { nil }
+        end
+
+        it 'returns a nil cache key' do
+          subject.fetch_cache_key_for(@persisted_mock_alias).should be_nil
+        end
+
+        it 'does not store the cache key to cache' do
+          subject.fetch_cache_key_for(@persisted_mock_alias)
+          Garner.config.cache.read(
+                                     strategy: subject,
+                                     proxied_binding: ''
+                                   ).should be_nil
+        end
+      end
+    end
+  end
+
+  describe 'write_cache_key_for' do
+    context 'with a canonical binding' do
+      it 'returns a cache key string' do
+        subject.write_cache_key_for(@persisted_mock).should eq @mock_key
+      end
+    end
+
+    context 'with a non-canonical binding' do
+      it 'returns a cache key string' do
+        subject.write_cache_key_for(@persisted_mock_alias).should eq @mock_key
+      end
+
+      context 'whose canonical binding is nil' do
+        before(:each) do
+          @persisted_mock_alias.stub(:proxy_binding) { nil }
+        end
+
+        it 'returns a nil cache key' do
+          subject.write_cache_key_for(@persisted_mock_alias).should be_nil
+        end
+      end
+    end
+  end
+
+  describe 'fetch_canonical_binding_for' do
+    context 'with a canonical binding' do
+      it 'returns the canonical binding' do
+        subject.fetch_canonical_binding_for(@persisted_mock).should eq @persisted_mock
+      end
+    end
+
+    context 'with a non-canonical binding' do
+      it 'returns the canonical binding' do
+        subject.fetch_canonical_binding_for(@persisted_mock_alias).should eq @persisted_mock
+      end
+
+      it 'stores the canonical binding to cache' do
+        subject.fetch_canonical_binding_for(@persisted_mock_alias)
+        Garner.config.cache.read(
+                                   strategy: subject,
+                                   proxied_binding: 'MockerAlias/id=alias-4'
+                                 ).should eq @persisted_mock
+      end
+    end
+
+    context 'with a proxyless binding' do
+      it 'returns nil' do
+        subject.fetch_canonical_binding_for(@new_mock).should.nil?
+      end
+    end
+  end
+
+  describe 'write_canonical_binding_for' do
+    context 'with a canonical binding' do
+      it 'returns the canonical binding' do
+        subject.write_canonical_binding_for(@persisted_mock).should eq @persisted_mock
+      end
+    end
+
+    context 'with a non-canonical binding' do
+      it 'returns the canonical binding' do
+        subject.write_canonical_binding_for(@persisted_mock_alias).should eq @persisted_mock
+      end
+    end
+
+    context 'with a proxyless binding' do
+      it 'returns nil' do
+        subject.write_canonical_binding_for(@new_mock).should.nil?
+      end
+    end
+  end
+
+  context 'with real objects' do
+    before(:each) do
+      subject.unstub(:canonical?)
+      subject.unstub(:new_cache_key_for)
+      Garner.configure do |config|
+        config.mongoid_identity_fields = [:_id, :_slugs]
+      end
+
+      @cheese = Cheese.create(name: 'M1')
+      @food = Food.create(name: 'F1')
+    end
+
+    it_behaves_like 'Garner::Strategies::Binding::Key strategy' do
+      let(:known_bindings) do
+        [Cheese, @cheese, Cheese.identify(@cheese.id), Cheese.identify('m1')]
+      end
+
+      let(:unknown_bindings) do
+        [Cheese.identify('m2'), Food.identify(nil)]
+      end
+    end
+
+    describe 'apply' do
+      it 'retrieves the correct key' do
+        key = subject.apply(Cheese.find('m1'))
+        subject.apply(Cheese.identify('m1')).should eq key
+      end
+
+      it 'stores the appropriate values to cache' do
+        key1 = subject.apply(Food.identify(@cheese.id))
+        key2 = subject.apply(Cheese.identify('m1'))
+        key1.should eq key2
+
+        Garner.config.cache.read(
+                                   strategy: subject,
+                                   proxied_binding: "Garner::Mixins::Mongoid::Identity/klass=Food,handle=#{@cheese.id}"
+                                 ).should eq @cheese
+
+        Garner.config.cache.read(
+                                   strategy: subject,
+                                   proxied_binding: 'Garner::Mixins::Mongoid::Identity/klass=Cheese,handle=m1'
+                                 ).should eq @cheese
+
+        Garner.config.cache.read(
+                                   strategy: subject,
+                                   proxied_binding: "Cheese/id=#{@cheese.id}"
+                                 ).should eq key1
+
+        Garner.config.cache.read(
+                                   strategy: subject,
+                                   proxied_binding: "Food/id=#{@cheese.id}"
+                                 ).should be_nil
+      end
+    end
+  end
+end