HornsAndHooves-moribus 0.4.4 → 0.7.2

data/spec/moribus/extensions/delegate_associated_spec.rb

@@ -0,0 +1,140 @@
+require "spec_helper"
+
+describe Moribus::Extensions::DelegateAssociated do
+  before do
+    class SpecStatus < MoribusSpecModel(name: :string, description: :string)
+      acts_as_enumerated
+
+      self.enumeration_model_updates_permitted = true
+      create!(name: "inactive", description: "Inactive")
+      create!(name: "active"  , description: "Active")
+    end
+
+    class SpecType < MoribusSpecModel(name: :string, description: :string)
+      acts_as_enumerated
+
+      self.enumeration_model_updates_permitted = true
+      create!(name: "important"  , description: "Important")
+      create!(name: "unimportant", description: "Unimportant")
+    end
+
+    class SpecSuffix < MoribusSpecModel(name: :string, description: :string)
+      acts_as_enumerated
+
+      self.enumeration_model_updates_permitted = true
+      create!(name: "none", description: "")
+      create!(name: "jr"  , description: "Junior")
+    end
+
+    class SpecPersonName < MoribusSpecModel(first_name:     :string,
+                                            middle_name:    :string,
+                                            last_name:      :string,
+                                            spec_suffix_id: :integer
+                                          )
+      acts_as_aggregated non_content_columns: :middle_name
+      has_enumerated :spec_suffix, default: ""
+
+      validates_presence_of :first_name, :last_name
+
+      # custom writer that additionally strips first name
+      def first_name=(value)
+        self[:first_name] = value.strip
+      end
+    end
+
+    class SpecCustomerInfo < MoribusSpecModel(
+                                        spec_customer_id:    :integer!,
+                                        spec_person_name_id: :integer,
+                                        spec_status_id:      :integer,
+                                        spec_type_id:        :integer,
+                                        is_current:          :boolean,
+                                        lock_version:        :integer,
+                                        created_at:          :datetime,
+                                        updated_at:          :datetime,
+                                        previous_id:         :integer
+                              )
+      attr :custom_field
+
+      belongs_to :spec_customer, inverse_of: :spec_customer_info, touch: true
+      has_aggregated :spec_person_name
+      has_enumerated :spec_status
+      has_enumerated :spec_type
+
+      acts_as_tracked by: :spec_customer, preceding_key: :previous_id
+    end
+
+    class SpecCustomer < MoribusSpecModel(spec_status_id: :integer)
+      has_one_current :spec_customer_info, inverse_of: :spec_customer
+      has_one_current :spec_customer_info_with_type, inverse_of: :spec_customer
+      has_enumerated :spec_status, default: "inactive"
+
+      delegate_associated :spec_person_name, :custom_field, :spec_type, to: :spec_customer_info
+    end
+  end
+
+  after do
+    MoribusSpecModel.cleanup!
+  end
+
+  let!(:customer) do
+    SpecCustomer.create(
+      spec_customer_info_attributes: {
+        spec_person_name_attributes: { first_name: " John ", last_name: "Smith" }
+      }
+    )
+  end
+
+  let(:info) { customer.spec_customer_info }
+
+  describe "Delegations" do
+    it "has delegated column information" do
+      expect(customer.column_for_attribute(:first_name)).not_to be_nil
+    end
+
+    it "does not delegate special methods" do
+      expect(customer).not_to respond_to(:reset_first_name)
+      expect(customer).not_to respond_to(:first_name_was)
+      expect(customer).not_to respond_to(:first_name_before_type_cast)
+      expect(customer).not_to respond_to(:first_name_will_change!)
+      expect(customer).not_to respond_to(:first_name_changed?)
+      expect(customer).not_to respond_to(:lock_version)
+    end
+
+    it "delegates methods to aggregated parts" do
+      expect(info).to respond_to(:first_name)
+      expect(info).to respond_to(:first_name=)
+      expect(info).to respond_to(:spec_suffix)
+      expect(info.last_name).to eq "Smith"
+    end
+
+    it "delegates methods to representation" do
+      expect(customer).to respond_to(:first_name)
+      expect(customer).to respond_to(:first_name=)
+      expect(customer).to respond_to(:spec_suffix)
+      expect(customer.last_name).to eq "Smith"
+      expect(customer).to respond_to(:custom_field)
+      expect(customer).to respond_to(:custom_field=)
+    end
+
+    it "properly delegates enumerated attributes" do
+      expect(customer).to respond_to(:spec_type)
+      expect(customer).to respond_to(:spec_type=)
+      customer.spec_type = :important
+      expect(customer.spec_type === :important).to eq true
+    end
+
+    it "raises NoMethodError if unknown method is received" do
+      expect{ customer.impossibru }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "#column_for_attribute" do
+    it "returns class db column if it exists" do
+      expect(customer.column_for_attribute(:id)).not_to be_nil
+    end
+
+    it "returns class db column if it doesn't exist" do
+      expect(customer.column_for_attribute(:foobar)).to be_nil
+    end
+  end
+end

data/spec/moribus/extensions/has_current_extension_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Moribus::Extensions::HasCurrentExtension do
+  before do
+    class SpecCustomerInfo < MoribusSpecModel(
+                                              spec_customer_id: :integer!,
+                                              is_current:       :boolean,
+                                              lock_version:     :integer,
+                                              created_at:       :datetime,
+                                              updated_at:       :datetime,
+                                              previous_id:      :integer
+                                             )
+
+      belongs_to :spec_customer, inverse_of: :spec_customer_info, touch: true
+    end
+
+    class SpecCustomer < MoribusSpecModel(spec_status_id: :integer)
+      has_one_current :spec_customer_info, inverse_of: :spec_customer, dependent: :destroy
+    end
+  end
+
+  after do
+    MoribusSpecModel.cleanup!
+  end
+
+  let(:customer) { SpecCustomer.create }
+  let!(:info)    { SpecCustomerInfo.create(spec_customer: customer, is_current: true) }
+
+  describe ".remove_target!" do
+    before do
+      allow(customer.spec_customer_info).to receive(:new_record?).and_return(true)
+    end
+
+    it "sets 'is_current' flag of overridden record to false for new record" do
+      old_info = customer.spec_customer_info
+      customer.spec_customer_info = SpecCustomerInfo.new
+      expect(old_info.is_current).to be_falsey
+    end
+  end
+end

data/spec/moribus/macros_spec.rb

@@ -1,7 +1,101 @@
-require 'spec_helper'
+require "spec_helper"
 
 # Some of the Moribus::Macros methods are tested in
 # spec/lib/moribus_spec.rb.
 describe Moribus::Macros do
+  before do
+    class SpecCustomer < MoribusSpecModel(spec_status_id: :integer)
+      has_one_current :spec_customer_info,
+        -> { where(spec_customer_id: 3) }, inverse_of: :spec_customer
+    end
 
+    class SpecCustomerInfo < MoribusSpecModel(
+                                                spec_customer_id: :integer!,
+                                                is_current:       :boolean,
+                                                lock_version:     :integer,
+                                                created_at:       :datetime,
+                                                updated_at:       :datetime,
+                                                previous_id:      :integer
+                                              )
+
+      belongs_to :spec_customer, inverse_of: :spec_customer_info, touch: true
+    end
+
+    class SpecCustomerOrder < MoribusSpecModel(:spec_status_id => :integer)
+      has_one_current :spec_customer_info_order,
+        -> { order(:created_at) }, :inverse_of => :spec_customer_order
+    end
+
+    class SpecCustomerInfoOrder < MoribusSpecModel(
+                                                spec_customer_order_id: :integer!,
+                                                is_current:             :boolean,
+                                                lock_version:           :integer,
+                                                created_at:             :datetime,
+                                                updated_at:             :datetime,
+                                                previous_id:            :integer
+                                              )
+
+      belongs_to :spec_customer_order, inverse_of: :spec_customer_info_order, touch: true
+    end
+  end
+
+  after do
+    MoribusSpecModel.cleanup!
+  end
+
+  describe ".has_one_current" do
+    let!(:customer)       { SpecCustomer.create(id: 3, spec_status_id: 2) }
+    let!(:customer_order) { SpecCustomerOrder.create(id: 9, spec_status_id: 1) }
+
+    let!(:info1) do
+      SpecCustomerInfo.create(
+        spec_customer_id: 1,
+        is_current:       true,
+        created_at:       5.days.ago,
+        updated_at:       5.days.ago
+      )
+    end
+
+    let!(:info2) do
+      SpecCustomerInfo.create(
+        spec_customer_id: 3,
+        is_current:       true,
+        created_at:       5.days.ago,
+        updated_at:       5.days.ago
+      )
+    end
+
+    let!(:info_order1) do
+      SpecCustomerInfoOrder.create(
+        spec_customer_order_id: 9,
+        is_current:             true,
+        created_at:             5.days.ago,
+        updated_at:             5.days.ago
+      )
+    end
+
+    let!(:info_order2) do
+      SpecCustomerInfoOrder.create(
+        spec_customer_order_id: 11,
+        is_current:             true,
+        created_at:             5.days.ago,
+        updated_at:             5.days.ago
+      )
+    end
+
+    it "merges has_one_current scope with has_one if given" do
+      expect(customer.spec_customer_info            ).to eq(info2)
+      expect(customer_order.spec_customer_info_order).to eq(info_order1)
+    end
+  end
+
+  describe ".normalize_reflection" do
+    subject do
+      SpecCustomer.send(:normalize_reflection, { spec_customer_info: :key_value }, :spec_customer_info)
+    end
+
+    it "returns reflection with symbol key for rails 4.1" do
+      is_expected.to eq(:key_value)
+    end
+  end
 end

data/spec/moribus_spec.rb

@@ -2,36 +2,37 @@ require "spec_helper"
 
 describe Moribus do
   before do
-    class SpecStatus < MoribusSpecModel(:name => :string, :description => :string)
+    class SpecStatus < MoribusSpecModel(name: :string, description: :string)
       acts_as_enumerated
 
       self.enumeration_model_updates_permitted = true
-      create!(:name => "inactive", :description => "Inactive")
-      create!(:name => "active"  , :description => "Active")
+      create!(name: "inactive", description: "Inactive")
+      create!(name: "active"  , description: "Active")
     end
 
-    class SpecType < MoribusSpecModel(:name => :string, :description => :string)
+    class SpecType < MoribusSpecModel(name: :string, description: :string)
       acts_as_enumerated
 
       self.enumeration_model_updates_permitted = true
-      create!(:name => "important"  , :description => "Important")
-      create!(:name => "unimportant", :description => "Unimportant")
+      create!(name: "important"  , description: "Important")
+      create!(name: "unimportant", description: "Unimportant")
     end
 
-    class SpecSuffix < MoribusSpecModel(:name => :string, :description => :string)
+    class SpecSuffix < MoribusSpecModel(name: :string, description: :string)
       acts_as_enumerated
 
       self.enumeration_model_updates_permitted = true
-      create!(:name => "none", :description => "")
-      create!(:name => "jr"  , :description => "Junior")
+      create!(name: "none", description: "")
+      create!(name: "jr"  , description: "Junior")
     end
 
-    class SpecPersonName < MoribusSpecModel(:first_name     => :string,
-                                            :last_name      => :string,
-                                            :spec_suffix_id => :integer
+    class SpecPersonName < MoribusSpecModel(first_name:     :string,
+                                            middle_name:    :string,
+                                            last_name:      :string,
+                                            spec_suffix_id: :integer
                                           )
-      acts_as_aggregated
-      has_enumerated :spec_suffix, :default => ""
+      acts_as_aggregated non_content_columns: :middle_name
+      has_enumerated :spec_suffix, default: ""
 
       validates_presence_of :first_name, :last_name
 
@@ -41,63 +42,63 @@ describe Moribus do
       end
     end
 
-    class SpecCustomerFeature < MoribusSpecModel(:feature_name => :string)
-      acts_as_aggregated :cache_by => :feature_name
+    class SpecCustomerFeature < MoribusSpecModel(feature_name: :string)
+      acts_as_aggregated cache_by: :feature_name
     end
 
     class SpecCustomerInfo < MoribusSpecModel(
-                                        :spec_customer_id    => :integer!,
-                                        :spec_person_name_id => :integer,
-                                        :spec_status_id      => :integer,
-                                        :spec_type_id        => :integer,
-                                        :is_current          => :boolean,
-                                        :lock_version        => :integer,
-                                        :created_at          => :datetime,
-                                        :updated_at          => :datetime,
-                                        :previous_id         => :integer
+                                        spec_customer_id:    :integer!,
+                                        spec_person_name_id: :integer,
+                                        spec_status_id:      :integer,
+                                        spec_type_id:        :integer,
+                                        is_current:          :boolean,
+                                        lock_version:        :integer,
+                                        created_at:          :datetime,
+                                        updated_at:          :datetime,
+                                        previous_id:         :integer
                               )
       attr :custom_field
 
-      belongs_to :spec_customer, :inverse_of => :spec_customer_info, :touch => true
+      belongs_to :spec_customer, inverse_of: :spec_customer_info, touch: true
       has_aggregated :spec_person_name
       has_enumerated :spec_status
       has_enumerated :spec_type
 
-      acts_as_tracked :by => :spec_customer, :preceding_key => :previous_id
+      acts_as_tracked by: :spec_customer, preceding_key: :previous_id
     end
 
     class SpecCustomerInfoWithType < MoribusSpecModel(
-                                        :spec_customer_id    => :integer!,
-                                        :spec_status_id      => :integer,
-                                        :spec_type_id        => :integer,
-                                        :is_current          => :boolean,
-                                        :lock_version        => :integer,
-                                        :created_at          => :datetime,
-                                        :updated_at          => :datetime
+                                        spec_customer_id: :integer!,
+                                        spec_status_id:   :integer,
+                                        spec_type_id:     :integer,
+                                        is_current:       :boolean,
+                                        lock_version:     :integer,
+                                        created_at:       :datetime,
+                                        updated_at:       :datetime
                                       )
       attr :custom_field
 
-      belongs_to :spec_customer, :inverse_of => :spec_customer_info_with_type, :touch => true
+      belongs_to :spec_customer, inverse_of: :spec_customer_info_with_type, touch: true
       has_enumerated :spec_status
       has_enumerated :spec_type
 
       acts_as_tracked :by => [:spec_customer, :spec_type]
     end
 
-    class SpecCustomer < MoribusSpecModel(:spec_status_id => :integer)
-      has_one_current :spec_customer_info, :inverse_of => :spec_customer
-      has_one_current :spec_customer_info_with_type, :inverse_of => :spec_customer
-      has_enumerated :spec_status, :default => "inactive"
+    class SpecCustomer < MoribusSpecModel(spec_status_id: :integer)
+      has_one_current :spec_customer_info, inverse_of: :spec_customer
+      has_one_current :spec_customer_info_with_type, inverse_of: :spec_customer
+      has_enumerated :spec_status, default: "inactive"
 
-      delegate_associated :spec_person_name, :custom_field, :spec_type, :to => :spec_customer_info
+      delegate_associated :spec_person_name, :custom_field, :spec_type, to: :spec_customer_info
     end
 
-    class SpecCustomerEmail < MoribusSpecModel(:spec_customer_id => :integer,
-                                               :email            => :string,
-                                               :is_current       => :boolean,
-                                               :status           => :string
+    class SpecCustomerEmail < MoribusSpecModel(spec_customer_id: :integer,
+                                               email:            :string,
+                                               is_current:       :boolean,
+                                               status:           :string
                                               )
-      connection.add_index table_name, [:email, :is_current], :unique => true
+      connection.add_index table_name, [:email, :is_current], unique: true
 
       belongs_to :spec_customer
 
@@ -112,22 +113,22 @@ describe Moribus do
   describe "common behavior" do
     before do
       @info = SpecCustomerInfo.create(
-        :spec_customer_id    => 1,
-        :spec_person_name_id => 1,
-        :is_current          => true,
-        :created_at          => 5.days.ago,
-        :updated_at          => 5.days.ago
+        spec_customer_id:    1,
+        spec_person_name_id: 1,
+        is_current:          true,
+        created_at:          5.days.ago,
+        updated_at:          5.days.ago
       )
     end
 
-    it "should revert changes if exception is raised" do
+    it "reverts changes if exception is raised" do
       old_id         = @info.id
       old_updated_at = @info.updated_at
       old_created_at = @info.created_at
 
       suppress(Exception) do
         expect {
-          @info.update_attributes :spec_customer_id => nil, :spec_person_name_id => 2
+          @info.update_attributes spec_customer_id: nil, spec_person_name_id: 2
         }.not_to change(SpecCustomerInfo, :count)
       end
 
@@ -138,130 +139,46 @@ describe Moribus do
 
       expect(@info.changed_attributes[:updated_at]).to eq(nil)
       expect(@info.changed_attributes[:created_at]).to eq(nil)
-
-    end
-  end
-
-  describe "Aggregated" do
-    context "definition" do
-      it "should raise an error on an unknown option" do
-        expect{
-          Class.new(ActiveRecord::Base).class_eval do
-            acts_as_aggregated :invalid_key => :error
-          end
-        }.to raise_error(ArgumentError)
-      end
-
-      it "should raise an error when including AggregatedCacheBehavior without AggregatedBehavior" do
-        expect{
-          Class.new(ActiveRecord::Base).class_eval do
-            include Moribus::AggregatedCacheBehavior
-          end
-        }.to raise_error(Moribus::AggregatedCacheBehavior::NotAggregatedError)
-      end
-    end
-
-    before do
-      @existing = SpecPersonName.create! :first_name => "John", :last_name => "Smith"
-    end
-
-    it "doesn't duplicate records" do
-      expect {
-        SpecPersonName.create :first_name => " John ", :last_name => "Smith"
-      }.not_to change(SpecPersonName, :count)
-    end
-
-    it "looks up self and replaces id with existing on create" do
-      name = SpecPersonName.new :first_name => "John", :last_name => "Smith"
-      name.save
-      expect(name.id).to eq @existing.id
     end
 
-    it "creates a new record if lookup fails" do
-      expect {
-        SpecPersonName.create :first_name => "Alice", :last_name => "Smith"
-      }.to change(SpecPersonName, :count).by(1)
-    end
-
-    it "looks up self and replaces id with existing on update" do
-      name = SpecPersonName.create :first_name => "Alice", :last_name => "Smith"
-      name.update_attributes :first_name => "John"
-      expect(name.id).to eq @existing.id
-    end
-
-    it "raises the expected error when 'save!' fails" do
-      name = SpecPersonName.create :first_name => "Alice", :last_name => "Smith"
-      name.last_name = nil
-      expect {
-        name.save!
-      }.to raise_error(ActiveRecord::RecordNotSaved)
-    end
-
-    context "with caching" do
-      before do
-        @existing = SpecCustomerFeature.create(:feature_name => "Pays")
-        SpecCustomerFeature.clear_cache
-      end
-
-      it "looks up the existing value and adds it to the cache" do
-        feature = SpecCustomerFeature.new :feature_name => @existing.feature_name
-
-        expect{ feature.save }.
-          to change(SpecCustomerFeature.aggregated_records_cache, :length).by(1)
-
-        expect(feature.id).to eq @existing.id
-      end
-
-      it "adds the freshly-created record to the cache" do
-        expect{ SpecCustomerFeature.create(:feature_name => "Fraud") }.
-          to change(SpecCustomerFeature.aggregated_records_cache, :length).by(1)
-      end
-
-      it "freezes the cached object" do
-        feature = SpecCustomerFeature.create(:feature_name => "Cancelled")
-        expect(SpecCustomerFeature.aggregated_records_cache[feature.feature_name]).to be_frozen
-      end
-
-      it "caches the clone of the record, not the record itself" do
-        feature = SpecCustomerFeature.create(:feature_name => "Returned")
-        expect(SpecCustomerFeature.aggregated_records_cache[feature.feature_name].object_id).
-          not_to eq feature.object_id
-      end
+    it "has module included class check methods" do
+      expect(SpecCustomerFeature.acts_as_aggregated?).to be_truthy
+      expect(SpecCustomerEmail.acts_as_tracked?).to be_truthy
     end
   end
 
   describe "Tracked" do
     before do
       @customer = SpecCustomer.create
-      @info = @customer.create_spec_customer_info :spec_person_name_id => 1
+      @info = @customer.create_spec_customer_info spec_person_name_id: 1
     end
 
     it "creates a new current record if updated" do
       expect {
-        @info.update_attributes(:spec_person_name_id => 2)
+        @info.update_attributes(spec_person_name_id: 2)
       }.to change(SpecCustomerInfo, :count).by(1)
     end
 
     it "replaces itself with new id" do
       old_id = @info.id
-      @info.update_attributes(:spec_person_name_id => 2)
+      @info.update_attributes(spec_person_name_id: 2)
       expect(@info.id).not_to eq old_id
     end
 
     it "sets is_current record to false for superseded record" do
       old_id = @info.id
-      @info.update_attributes(:spec_person_name_id => 2)
+      @info.update_attributes(spec_person_name_id: 2)
       expect(SpecCustomerInfo.find(old_id).is_current).to eq false
     end
 
     it "sets previous_id to the id of the previous record" do
       old_id = @info.id
-      @info.update_attributes(:spec_person_name_id => 2)
+      @info.update_attributes(spec_person_name_id: 2)
       expect(@info.previous_id).to eq old_id
     end
 
     it "changes is_current to false for previous one when assigning a new current record" do
-      new_info = SpecCustomerInfo.new :spec_person_name_id => 2, :is_current => true
+      new_info = SpecCustomerInfo.new spec_person_name_id: 2, is_current: true
       @customer.spec_customer_info = new_info
       expect(new_info.spec_customer_id).to eq @customer.id
       @info.reload
@@ -269,12 +186,12 @@ describe Moribus do
     end
 
     it "does not crash on superseding with 'is_current' conditional constraint" do
-      email = SpecCustomerEmail.create( :spec_customer => @customer,
-                                        :email         => "foo@bar.com",
-                                        :status        => "unverified",
-                                        :is_current    => true
+      email = SpecCustomerEmail.create( spec_customer: @customer,
+                                        email:         "foo@bar.com",
+                                        status:        "unverified",
+                                        is_current:    true
                                       )
-      expect{ email.update_attributes(:status => "verified") }.not_to raise_error
+      expect{ email.update_attributes(status: "verified") }.not_to raise_error
     end
 
     describe "updated_at and created_at" do
@@ -285,7 +202,7 @@ describe Moribus do
       after  { Timecop.return             }
 
       it "is updated on change" do
-        info = @customer.create_spec_customer_info :spec_person_name_id => 1
+        info = @customer.create_spec_customer_info spec_person_name_id: 1
         expect(info.updated_at).to eq first_time
         expect(info.created_at).to eq first_time
 
@@ -304,28 +221,41 @@ describe Moribus do
       end
 
       it "raises a stale object error" do
-        @info1.update_attributes(:spec_person_name_id => 3)
+        @info1.update_attributes(spec_person_name_id: 3)
 
-        expect{ @info2.update_attributes(:spec_person_name_id => 4) }.
+        expect{ @info2.update_attributes(spec_person_name_id: 4) }.
           to raise_error(ActiveRecord::StaleObjectError,
-                         "Attempted to update_current (version #{@info2.lock_version}) a stale object: SpecCustomerInfo")
+                         /Attempted to update_current \(version #{@info2.lock_version}\) a stale object: SpecCustomerInfo\./)
       end
 
       it "updates lock_version incrementally for each new record" do
         spec_customer_info = @customer.spec_customer_info
 
         expect {
-          spec_customer_info.update_attributes(:spec_person_name_id => 3)
+          spec_customer_info.update_attributes(spec_person_name_id: 3)
         }.to change { spec_customer_info.lock_version }.from(0).to(1)
 
         expect {
-          spec_customer_info.update_attributes(:spec_person_name_id => 4)
+          spec_customer_info.update_attributes(spec_person_name_id: 4)
         }.to change { spec_customer_info.lock_version }.from(1).to(2)
       end
 
+      it "does not fail to update if a lock version growth is for any reason not monotonic" do
+        spec_customer_info = @customer.spec_customer_info
+
+        spec_customer_info.update_attributes(spec_person_name_id: 3)
+        spec_customer_info.update_attributes(spec_person_name_id: 4)
+
+        SpecCustomerInfo.where(spec_customer_id: @customer.id, lock_version: 1).delete_all
+
+        expect {
+          spec_customer_info.update_attributes(spec_person_name_id: 5)
+        }.to change { spec_customer_info.lock_version }.from(2).to(3)
+      end
+
       it "does not fail if no locking_column is present" do
-        email = SpecCustomerEmail.create(:spec_customer_id => 1, :email => "foo@bar.com")
-        expect{ email.update_attributes(:email => "foo2@bar.com") }.not_to raise_error
+        email = SpecCustomerEmail.create(spec_customer_id: 1, email: "foo@bar.com")
+        expect{ email.update_attributes(email: "foo2@bar.com") }.not_to raise_error
       end
 
       it "updates lock_version column based on parent relation" do
@@ -333,29 +263,29 @@ describe Moribus do
         spec_customer_info = @customer.spec_customer_info
 
         expect {
-          spec_customer_info.update_attributes(:spec_person_name_id => 3)
+          spec_customer_info.update_attributes(spec_person_name_id: 3)
         }.to change { spec_customer_info.lock_version }.from(0).to(1)
 
         expect {
-          spec_customer_info.update_attributes(:spec_customer => @other_customer)
+          spec_customer_info.update_attributes(spec_customer: @other_customer)
         }.to change { spec_customer_info.lock_version }.from(1).to(0)
       end
 
       it "updates lock_version column base on relation list from 'by' option" do
         info_with_type =
-          @customer.reload.create_spec_customer_info_with_type(:spec_type => :important)
+          @customer.reload.create_spec_customer_info_with_type(spec_type: :important)
 
         expect( info_with_type.lock_version ).to eq 0
 
         other_info_with_type =
-          @customer.reload.create_spec_customer_info_with_type(:spec_type => :unimportant)
+          @customer.reload.create_spec_customer_info_with_type(spec_type: :unimportant)
 
         expect( other_info_with_type.lock_version ).to eq 0
 
-        info_with_type.update_attributes(:spec_status => :active)
+        info_with_type.update_attributes(spec_status: :active)
         expect( info_with_type.lock_version ).to eq 1
 
-        info_with_type.update_attributes(:spec_status => :inactive)
+        info_with_type.update_attributes(spec_status: :inactive)
         expect( info_with_type.lock_version ).to eq 2
 
         expect( other_info_with_type.lock_version ).to eq 0
@@ -365,7 +295,7 @@ describe Moribus do
     describe "with Aggregated" do
       before do
         @info.spec_person_name =
-          SpecPersonName.create(:first_name => "John", :last_name => "Smith")
+          SpecPersonName.create(first_name: "John", last_name: "Smith")
         @info.save
         @info.reload
       end
@@ -374,59 +304,12 @@ describe Moribus do
         old_id = @info.id
         @customer.spec_customer_info.spec_person_name.first_name = "Alice"
         expect{ @customer.save }.to change(@info, :spec_person_name_id)
-        expect(@info.id).not_to eq old_id
-        expect(@info.is_current).to eq true
-        expect(SpecCustomerInfo.find(old_id).is_current).to eq false
-      end
-    end
-  end
-
-  describe "Delegations" do
-    before do
-      @customer = SpecCustomer.create(
-        :spec_customer_info_attributes => {
-          :spec_person_name_attributes => {:first_name => " John ", :last_name => "Smith"} } )
-      @info = @customer.spec_customer_info
-    end
 
-    it "has delegated column information" do
-      expect(@customer.column_for_attribute(:first_name)).not_to be_nil
-    end
-
-    it "does not delegate special methods" do
-      expect(@customer).not_to respond_to(:reset_first_name)
-      expect(@customer).not_to respond_to(:first_name_was)
-      expect(@customer).not_to respond_to(:first_name_before_type_cast)
-      expect(@customer).not_to respond_to(:first_name_will_change!)
-      expect(@customer).not_to respond_to(:first_name_changed?)
-      expect(@customer).not_to respond_to(:lock_version)
-    end
+        expect(@info.id        ).not_to eq old_id
+        expect(@info.is_current).to     eq true
 
-    it "delegates methods to aggregated parts" do
-      expect(@info).to respond_to(:first_name)
-      expect(@info).to respond_to(:first_name=)
-      expect(@info).to respond_to(:spec_suffix)
-      expect(@info.last_name).to eq "Smith"
-    end
-
-    it "delegates methods to representation" do
-      expect(@customer).to respond_to(:first_name)
-      expect(@customer).to respond_to(:first_name=)
-      expect(@customer).to respond_to(:spec_suffix)
-      expect(@customer.last_name).to eq "Smith"
-      expect(@customer).to respond_to(:custom_field)
-      expect(@customer).to respond_to(:custom_field=)
-    end
-
-    it "properly delegates enumerated attributes" do
-      expect(@customer).to respond_to(:spec_type)
-      expect(@customer).to respond_to(:spec_type=)
-      @customer.spec_type = :important
-      expect(@customer.spec_type === :important).to eq true
-    end
-
-    it "raises NoMethodError if unknown method is received" do
-      expect{ @customer.impossibru }.to raise_error(NoMethodError)
+        expect(SpecCustomerInfo.find(old_id).is_current).to eq false
+      end
     end
   end
 end