friendly-attributes 0.7.1.1 → 0.7.2

data/spec/friendly_attributes/details_delegator_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe FriendlyAttributes::DetailsDelegator do
+  DetailsDelegator = FriendlyAttributes::DetailsDelegator
+  
+  let(:details_delegator) { FriendlyAttributes::DetailsDelegator.new(friendly_model, ar_model, attributes, options, &initializer) }
+  let(:initializer)       { proc {} }
+  let(:attributes)        { {} }
+  let(:options)           { {} }
+  
+  let(:friendly_model)    { mock_friendly_model }
+  let(:ar_model)          { Class.new { include ActiveRecordFake } }
+  
+  let(:ar_instance)       { ar_model.new(:id => 42) }
+  let(:friendly_instance) { mock(friendly_model) }
+  
+  describe "class methods" do
+    describe ".friendly_model_name" do
+      it { DetailsDelegator.friendly_model_name(UserDetails).should == :user_details }
+    end
+    
+    describe ".friendly_model_ivar" do
+      it { DetailsDelegator.friendly_model_ivar(:user_details).should == :@user_details_ivar }
+    end
+    
+    describe ".friendly_model_reader" do
+      it { DetailsDelegator.friendly_model_reader(:user_details).should == :load_user_details }
+      it { DetailsDelegator.friendly_model_reader(UserDetails).should == :load_user_details }
+    end
+  end
+  
+  describe "initialization" do
+    shared_examples_for "DetailsDelegator initialization" do
+      context "DetailsDelegator attr_readers" do
+        subject { details_delegator }
+        
+        before(:each) do
+          details_delegator
+        end
+        
+        its(:active_record_model) { should == ar_model }
+        its(:friendly_model)      { should == friendly_model }
+        its(:attributes)          { should == attributes }        
+      end
+      
+      context "#setup_delegated_attributes" do
+        let(:attributes) do
+          {
+            String  => :foo,
+            Integer => [:bar, :baz]
+          }
+        end
+        
+        it "delegates the attributes passed in the options" do
+          details_delegator.should_receive(:delegated_attribute).with(:foo, String)
+          details_delegator.should_receive(:delegated_attribute).with(:bar, Integer)
+          details_delegator.should_receive(:delegated_attribute).with(:baz, Integer)
+          details_delegator.setup_delegated_attributes
+        end
+      end
+      
+      context "the Friendly model" do
+        before(:each) do
+          details_delegator
+        end
+
+        it "includes Friendly::Document" do
+          friendly_model.ancestors.should include(Friendly::Document)
+        end
+        
+        context "with defaults" do
+          it "adds the active_record_id attribute" do
+            friendly_model.attributes.should include(:active_record_id)
+          end
+
+          it "adds an index to active_record_id" do
+            friendly_model.storage_proxy.index_for_fields([:active_record_id]).should be_an_instance_of(Friendly::Index)
+          end
+          
+          it "sets the active_record_key" do
+            friendly_model.active_record_key.should == :active_record_id
+          end
+        end
+        
+        context "with options" do
+          let(:options) { { :active_record_key => :user_id } }
+          
+          it "adds the active_record_id attribute" do
+            friendly_model.attributes.should include(:user_id)
+          end
+
+          it "adds an index to active_record_id" do
+            friendly_model.storage_proxy.index_for_fields([:user_id]).should be_an_instance_of(Friendly::Index)
+          end
+          
+          it "sets the active_record_key" do
+            friendly_model.active_record_key.should == :user_id
+          end
+        end
+      end
+
+      context "the ActiveRecord model" do
+        it "installs the update_friendly_models callback after_save" do
+          ar_model.should_receive(:after_save).with(:update_friendly_models)
+          details_delegator
+        end
+
+        it "installs the destroy_friendly_models callback after_destroy" do
+          ar_model.should_receive(:after_destroy).with(:destroy_friendly_models)
+          details_delegator
+        end
+
+        describe "friendly model reader method" do
+          before(:each) do
+            details_delegator
+          end
+
+          it "is defined" do
+            ar_instance.should respond_to(DetailsDelegator.friendly_model_reader(friendly_model))
+          end
+
+          it "finds or builds and memoizes the associated Friendly model" do
+            ar_instance.should_receive(:find_or_build_and_memoize_details).with(friendly_model)
+            ar_instance.send(DetailsDelegator.friendly_model_reader(friendly_model))
+          end
+        end
+      
+        describe "cattr_accessor friendly_attributes_configuration" do
+          context "when no Configuration exists" do
+            it "creates and assigns a new Configuration with the delegator added" do
+              details_delegator
+              
+              ar_model.friendly_attributes_configuration.should be_an_instance_of(FriendlyAttributes::Configuration)
+              ar_model.friendly_attributes_configuration.friendly_models.should == [friendly_model]
+            end
+          end
+          
+          context "when Configuration already exists" do
+            let(:existing_details_delegator) { FriendlyAttributes::DetailsDelegator.new(other_friendly_model, ar_model, attributes, options, &initializer) }
+            let(:other_friendly_model) { mock_friendly_model }
+            
+            before(:each) do
+              existing_details_delegator
+            end
+            
+            it "adds to the existing configuration" do
+              existing_configuration = ar_model.friendly_attributes_configuration
+              
+              expect do
+                details_delegator
+              end.to change { ar_model.friendly_attributes_configuration.friendly_models }.
+                     from([other_friendly_model]).
+                     to([other_friendly_model, friendly_model])
+              
+              ar_model.friendly_attributes_configuration.should == existing_configuration
+            end
+          end
+        end
+      end
+    end
+    
+    context "missing initialization block" do
+      let(:details_delegator) { FriendlyAttributes::DetailsDelegator.new(friendly_model, ar_model, attributes, options) }
+      it_should_behave_like "DetailsDelegator initialization"
+    end
+  end
+  
+  describe "#delegated_method" do
+    before(:each) do
+      details_delegator
+      details_delegator.delegated_method(:some_method)
+      ar_instance.stub(DetailsDelegator.friendly_model_reader(friendly_model) => friendly_instance)
+    end
+    
+    it "delegates the method to Friendly model" do
+      bar = mock
+      friendly_instance.should_receive(:some_method).with(:foo).and_return(bar)
+      ar_instance.some_method(:foo).should == bar
+    end
+  end
+  
+  describe "#delegated_attribute" do
+    before(:each) do
+      details_delegator
+      details_delegator.delegated_attribute(:some_attribute, String)
+      ar_instance.stub(DetailsDelegator.friendly_model_reader(friendly_model) => friendly_instance)
+    end
+    
+    it "adds an attribute to the Friendly model" do
+      friendly_model.attributes.should include(:some_attribute)
+      friendly_model.attributes[:some_attribute].type.should == String
+    end
+    
+    it "delegates the reader to Friendly model" do
+      bar = mock
+      friendly_instance.should_receive(:some_attribute).and_return(bar)
+      ar_instance.some_attribute.should == bar
+    end
+    
+    it "delegates the writer to Friendly model" do
+      bar = mock
+      friendly_instance.should_receive(:some_attribute=).with(:value)
+      ar_instance.some_attribute = :value
+    end
+  
+    it "adds the attribute to the configuration" do
+      ar_instance.friendly_attributes_configuration.attributes.should == { :some_attribute => friendly_model }
+    end
+  end
+end

data/spec/friendly_attributes/instance_methods_spec.rb

@@ -0,0 +1,240 @@
+require 'spec_helper'
+
+describe FriendlyAttributes::InstanceMethods do
+  DetailsDelegator = FriendlyAttributes::DetailsDelegator unless defined?(DetailsDelegator)
+  
+  let(:object)  { klass.new.tap { |o| o.stub(:friendly_attributes_configuration => configuration) } }
+  let(:configuration) { mock(FriendlyAttributes::Configuration) }
+  let(:klass)   {
+    Class.new {
+      include ActiveRecordFake
+      include FriendlyAttributes::InstanceMethods
+    }
+  }
+  let(:user_details) { double(UserDetails).as_null_object }
+  let(:user_second_details) { double(UserSecondDetails).as_null_object }
+  let(:friendly_model_instances) { [user_details, user_second_details] }
+  
+  describe "reading and writing Friendly attributes" do
+    let(:object_details) { double(FriendlyAttributes::Base, :foo => foo, :foo= => foo) }
+    let(:foo) { mock("object_details.foo") }
+
+    before(:each) do
+      object.stub(:friendly_instance_for_attribute => object_details)
+    end
+    
+    describe "#read_friendly_attribute" do
+      it "finds the FriendlyAttributes instance for the specified attribute" do
+        object.
+          should_receive(:friendly_instance_for_attribute).
+          with(:foo).
+          and_return(object_details)
+
+        object.read_friendly_attribute(:foo)
+      end
+
+      it "reads the attribute from the FriendlyAttributes instance" do
+        object_details.should_receive(:foo).and_return(foo)
+        object.read_friendly_attribute(:foo).should == foo
+      end
+    end
+
+    describe "#write_friendly_attribute" do
+      it "finds the FriendlyAttributes instance for the specified attribute" do
+        object.
+          should_receive(:friendly_instance_for_attribute).
+          with(:foo).
+          and_return(object_details)
+
+        object.write_friendly_attribute(:foo, "bar")
+      end
+      
+      it "writes the attribute on the FriendlyAttributes instance" do
+        object_details.should_receive(:foo=).with("bar").and_return(foo)
+        object.write_friendly_attribute(:foo, "bar").should == foo
+      end
+      
+    end
+    
+  end
+  
+  describe "#friendly_instance_for_attribute" do
+    it "reads the value for the friendly model from the instance" do
+      configuration.should_receive(:model_for_attribute).with(:foo).and_return(UserDetails)
+      object.should_receive(DetailsDelegator.friendly_model_reader(UserDetails)).and_return(user_details)
+      object.friendly_instance_for_attribute(:foo).should == user_details
+    end
+  end
+  
+  describe "#update_friendly_models" do
+    it "updates each loaded friendly model instance if needed" do
+      object.should_receive(:present_friendly_instances).and_return(friendly_model_instances)
+      friendly_model_instances.each do |instance|
+        instance.should_receive(:update_if_changed_with_model).with(object.id)
+      end
+      object.update_friendly_models
+    end
+  end
+
+  describe "#destroy_friendly_details" do
+    it "loads and destroys all associated friendly models" do
+      object.should_receive(:all_friendly_instances).and_return(friendly_model_instances)
+      friendly_model_instances.each do |instance|
+        instance.should_receive(:destroy).and_return(true)
+      end
+      object.destroy_friendly_models.should be_true
+    end
+  end
+  
+  describe "#friendly_instance_present?" do
+    subject { object.friendly_instance_present?(friendly_model) }
+    let(:friendly_model) { UserDetails }
+    
+    context "when friendly_details ivar is present" do
+      before(:each) do
+        object.instance_variable_set(DetailsDelegator.friendly_model_ivar(friendly_model), mock)
+      end
+      
+      it { should be_true }
+    end
+    
+    context "when friendly_details ivar is not present" do
+      it { should be_false }
+    end
+  end
+  
+  describe "#friendly_instance_presence" do
+    subject { object.friendly_instance_presence(friendly_model) }
+    let(:friendly_model) { UserDetails }
+    
+    context "when present" do
+      before(:each) do
+        object.instance_variable_set(DetailsDelegator.friendly_model_ivar(friendly_model), mock)
+      end
+      
+      it "returns the instance using the model reader" do
+        object.should_receive(DetailsDelegator.friendly_model_reader(friendly_model)).and_return(user_details)
+        subject.should == user_details
+      end
+    end
+    
+    context "when not present" do
+      it "returns nil" do
+        subject.should be_nil
+      end
+    end
+  end
+  
+  describe "#all_friendly_instances" do
+    let(:friendly_models) { [UserDetails, UserSecondDetails] }
+    
+    it "loads and returns all the Friendly model instances associated with the record" do
+      configuration.should_receive(:friendly_models).and_return(friendly_models)
+      object.should_receive(DetailsDelegator.friendly_model_reader(UserDetails)).and_return(user_details)
+      object.should_receive(DetailsDelegator.friendly_model_reader(UserSecondDetails)).and_return(user_second_details)
+      object.all_friendly_instances.should == [user_details, user_second_details]
+    end
+  end
+  
+  describe "#present_friendly_instances" do
+    let(:friendly_models) { [UserDetails, UserSecondDetails] }
+    
+    it "returns all the loaded Friendly model instances associated with the record" do
+      configuration.should_receive(:friendly_models).and_return(friendly_models)
+      object.should_receive(:friendly_instance_presence).with(UserDetails).and_return(user_details)
+      object.should_receive(:friendly_instance_presence).with(UserSecondDetails).and_return(nil)
+      object.present_friendly_instances.should == [user_details]
+    end
+  end
+  
+  describe "#friendly_details_build_options" do
+    context "when friendly_details_build_options is not defined" do
+      it "returns and empty Hash" do
+        object.friendly_details_build_options.should == { }
+        object.friendly_details_build_options(UserDetails).should == { }
+      end
+    end
+    
+    context "when friendly_details_build_options is defined" do
+      let(:foo) { mock("default friendly details build option") }
+      
+      before(:each) do
+        _foo = foo
+        
+        klass.class_eval do
+          define_method(:friendly_details_build_options) do |klass|
+            { :foo => _foo }
+          end
+        end
+      end
+      
+      it "returns the options specified by friendly_details_build_options" do
+        object.friendly_details_build_options(UserSecondDetails).should == { :foo => foo }
+      end
+    end
+  end
+
+  describe "#changed?" do
+    subject { active_record.changed? }
+    let(:active_record) { User.create(:name => "Stan", :email => "stan@example.com") }
+    
+    context "when the ActiveRecord model has changed," do
+      before(:each) do
+        active_record.email = "eric@example.com"
+      end
+      
+      context "and the Friendly model has changed," do
+        before(:each) do
+          active_record.name = "Eric"
+        end
+        
+        it { should be_true }
+      end
+      
+      context "and the Friendly model has not changed" do
+        it { should be_true }
+      end
+    end
+    
+    context "when the ActiveRecord model has not changed," do
+      context "and the Friendly model has changed" do
+        before(:each) do
+          active_record.name = "Eric"
+        end
+        
+        it { should be_true }
+      end
+      
+      context "and the Friendly model has not changed" do
+        it { should be_false }
+      end
+    end
+  end
+
+  describe "#find_or_build_and_memoize_details" do
+    let(:user) { @user }
+    let(:build_options) { mock(Hash) }
+    let(:user_details) { double(UserDetails) }
+    
+    before(:each) do
+      @user = User.find(User.create(:name => "Stan", :email => "stan@example.com").id)
+    end
+    
+    it "finds (or builds a new instance with build options) and memoizes the associated Friendly instance" do
+      user.
+        should_receive(:friendly_details_build_options).
+        with(UserDetails).
+        once.
+        and_return(build_options)
+      
+      UserDetails.
+        should_receive(:find_or_build_by_active_record_id).
+        with(user.id, build_options).
+        once.
+        and_return(user_details)
+      
+      user.find_or_build_and_memoize_details(UserDetails).should == user_details
+      user.find_or_build_and_memoize_details(UserDetails).should == user_details
+    end
+  end
+end

data/spec/friendly_attributes_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe FriendlyAttributes do
+  use_database_cleanup
+  
+  describe "definition" do
+    it { User.should have_friendly_attributes(String, :name, :through => UserDetails) }
+    it { User.should have_friendly_attributes(Integer, :second_int, :through => UserSecondDetails) }
+    it { User.new.should have_friendly_attributes(Integer, :shoe_size, :birth_year, :through => UserDetails) }
+    it { User.new.should have_friendly_attributes(Friendly::Boolean, :subscribed, :through => UserDetails) }
+    it { User.should_not have_friendly_attributes(String, :foo, :through => UserDetails) }
+  end
+    
+  describe "creating" do
+    context "with Friendly attributes" do
+      context "when using just one Friendly model" do
+        let(:user) { User.create!(:name => "Stan", :email => "stan@example.com", :birth_year => 1984, :subscribed => true) }
+        
+        it "creates only the required Friendly model" do
+          expect do
+            expect do
+              user
+            end.to change { UserDetails.count({}) }
+          end.to_not change { UserSecondDetails.count({}) }
+        end
+        
+        it "sets the appropriate attributes on the ActiveRecord model and associated Friendly model" do
+          user_detail = user.load_user_details
+          user_detail.name.should == "Stan"
+          user_detail.birth_year.should == 1984
+          user_detail.shoe_size.should == 42
+          user_detail.subscribed.should be_true
+        end
+      end
+      
+      context "when using multiple associated Friendly models" do
+        let(:user) { User.create!(:name => "Stan", :email => "stan@example.com", :birth_year => 1984, :second_int => 120, :subscribed => true) }
+        
+        it "creates all the required Friendly models" do
+          expect do
+            expect do
+              user
+            end.to change { UserDetails.count({}) }
+          end.to change { UserSecondDetails.count({}) }
+        end
+        
+        it "sets the appropriate attributes on the ActiveRecord model and associated Friendly model" do
+          user_detail = user.load_user_details
+          user_detail.name.should == "Stan"
+          user_detail.birth_year.should == 1984
+          user_detail.shoe_size.should == 42
+          user_detail.subscribed.should be_true
+          
+          user_second_detail = user.load_user_second_details
+          user_second_detail.second_int.should == 120
+        end
+      end
+    end
+    
+    context "without Friendly attributes" do
+      let(:user) { User.create(:email => "stan@example.com") }
+      
+      it "does not create an associated Friendly model" do
+        expect do
+          user
+        end.to_not change { UserDetails.count({}) }
+      end
+    end
+  end
+  
+  describe "reading" do
+    let(:user) { User.create!(:name => "Stan", :email => "stan@example.com", :birth_year => 1984, :subscribed => true) }
+    
+    it "through the attr_reader" do
+      user.name.should == "Stan"
+    end
+    
+    it "through read_friendly_attribute" do
+      user.read_friendly_attribute(:name).should == "Stan"
+      user.read_friendly_attribute(:birth_year).should == 1984
+    end
+  end
+  
+  describe "updating" do
+    context "with Friendly attributes" do
+      let(:user) { User.create(:name => "Stan", :email => "stan@example.com", :second_int => 200) }
+      
+      it "updates the attributes" do
+        user.update_attributes(:name => "Eric", :second_int => 123)
+        UserDetails.first({}).name.should == "Eric"
+        UserSecondDetails.first({}).second_int.should == 123
+      end
+    end
+    
+    context "without Friendly attributes" do
+      let(:user) { User.create(:email => "stan@example.com") }
+      
+      it "does not create an associated Details model, if no delegated attributes are updated" do
+        expect do
+          user.update_attributes(:email => "eric@example.com")
+        end.to_not change { UserDetails.count({}) }
+      end
+      
+      it "creates an associated Details model, if delegated attributes are updated" do
+        expect do
+          user.update_attributes(:name => "Eric")
+        end.to change { UserDetails.count({}) }
+        user.name.should == "Eric"
+      end
+    end
+    
+    context "with nested attributes" do
+      let(:user) { User.create(:name => "Stan Marsh", :email => "smarsh@example.com") }
+      let(:parent) { Parent.create(:users => [user]) }
+      
+      before(:each) do
+        parent
+        parent.update_attributes(:users_attributes => users_attributes)
+        user.reload
+      end
+      
+      context "when only changing Friendly attributes" do
+        let(:users_attributes) { { "0" => { "id" => user.id, "name" => "Eric Cartman" } } }
+        
+        it "updates Friendly attributes through nested association" do
+          user.name.should == "Eric Cartman"
+        end
+      end
+      
+      context "when changing both Friendly attributes and ActiveRecord attributes" do
+        let(:users_attributes) { { "0" => { "id" => user.id, "name" => "Eric Cartman", "email" => "eric@example.com" } } }
+        
+        it "updates Friendly attributes through nested association" do
+          user.email.should == "eric@example.com"
+          user.name.should == "Eric Cartman"
+        end
+      end
+    end
+  end
+  
+  describe "destroying" do
+    let(:user) { User.create(:name => "Stan", :email => "stan@example.com") }
+    
+    it "destroys the associated Details model" do
+      user # create it first
+      
+      expect do
+        user.destroy
+      end.to change { UserDetails.count({}) }.by(-1)
+    end
+  end
+end