active_data 1.0.0 → 1.1.0

data/spec/lib/active_data/model/associations/embeds_one_spec.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Associations::EmbedsOne do
@@ -19,26 +18,161 @@ describe ActiveData::Model::Associations::EmbedsOne do
     end
   end
 
-  let(:book) { Book.new }
+  let(:book) { Book.new(title: 'Book') }
   let(:association) { book.association(:author) }
 
   let(:existing_book) { Book.instantiate title: 'My Life', author: {'name' => 'Johny'} }
   let(:existing_association) { existing_book.association(:author) }
 
+  context 'callbacks' do
+    before do
+      Book.class_eval do
+        embeds_one :author, before_add: :before_add, after_add: :after_add
+
+        def before_add(object)
+          callbacks.push([:before_add, object])
+        end
+
+        def after_add(object)
+          callbacks.push([:after_add, object])
+        end
+
+        collection :callbacks, Array
+      end
+    end
+    let(:author1) { Author.new(name: 'Author1') }
+    let(:author2) { Author.new(name: 'Author2') }
+
+    specify do
+      expect { association.build(name: 'Author1') }
+        .to change { book.callbacks }
+        .to([[:before_add, author1], [:after_add, author1]])
+    end
+
+    specify do
+      expect do
+        association.build(name: 'Author1')
+        association.build(name: 'Author2')
+      end
+        .to change { book.callbacks }
+        .to([
+          [:before_add, author1], [:after_add, author1],
+          [:before_add, author2], [:after_add, author2]
+        ])
+    end
+
+    specify do
+      expect { association.create(name: 'Author1') }
+        .to change { book.callbacks }
+        .to([[:before_add, author1], [:after_add, author1]])
+    end
+
+    specify do
+      expect { association.writer(author1) }
+        .to change { book.callbacks }
+        .to([[:before_add, author1], [:after_add, author1]])
+    end
+
+    specify do
+      expect do
+        association.writer(author1)
+        association.writer(nil)
+        association.writer(author1)
+      end
+        .to change { book.callbacks }
+        .to([
+          [:before_add, author1], [:after_add, author1],
+          [:before_add, author1], [:after_add, author1]
+        ])
+    end
+
+    context 'default' do
+      before do
+        Book.class_eval do
+          embeds_one :author,
+            before_add: ->(object) { callbacks.push([:before_add, object]) },
+            after_add: ->(object) { callbacks.push([:after_add, object]) },
+            default: -> { {name: 'Author1'} }
+
+          collection :callbacks, Array
+        end
+      end
+
+      specify do
+        expect { association.writer(author2) }
+          .to change { book.callbacks }
+          .to([
+            [:before_add, author1], [:after_add, author1],
+            [:before_add, author2], [:after_add, author2]
+          ])
+      end
+    end
+  end
+
   describe 'book#association' do
     specify { expect(association).to be_a described_class }
     specify { expect(association).to eq(book.association(:author)) }
   end
 
+  describe 'author#embedder' do
+    let(:author) { Author.new(name: 'Author') }
+
+    specify { expect(association.build.embedder).to eq(book) }
+    specify { expect(association.create.embedder).to eq(book) }
+    specify do
+      expect { association.writer(author) }
+        .to change { author.embedder }.from(nil).to(book)
+    end
+    specify do
+      expect { association.target = author }
+        .to change { author.embedder }.from(nil).to(book)
+    end
+
+    context 'default' do
+      before do
+        Book.class_eval do
+          embeds_one :author, default: -> { {name: 'Author1'} }
+        end
+      end
+
+      specify { expect(association.target.embedder).to eq(book) }
+
+      context do
+        before do
+          Book.class_eval do
+            embeds_one :author, default: -> { Author.new(name: 'Author1') }
+          end
+        end
+
+        specify { expect(association.target.embedder).to eq(book) }
+      end
+    end
+
+    context 'embedding goes before attributes' do
+      before do
+        Author.class_eval do
+          attribute :name, String, normalize: ->(value) { "#{value}#{embedder.title}" }
+        end
+      end
+
+      specify { expect(association.build(name: 'Author').name).to eq('AuthorBook') }
+      specify { expect(association.create(name: 'Author').name).to eq('AuthorBook') }
+    end
+  end
+
   describe '#build' do
     specify { expect(association.build).to be_a Author }
     specify { expect(association.build).not_to be_persisted }
 
-    specify { expect { association.build(name: 'Fred') }
-      .not_to change { book.read_attribute(:author) } }
+    specify do
+      expect { association.build(name: 'Fred') }
+        .not_to change { book.read_attribute(:author) }
+    end
 
-    specify { expect { existing_association.build(name: 'Fred') }
-      .not_to change { existing_book.read_attribute(:author) } }
+    specify do
+      expect { existing_association.build(name: 'Fred') }
+        .not_to change { existing_book.read_attribute(:author) }
+    end
   end
 
   describe '#create' do
@@ -48,52 +182,123 @@ describe ActiveData::Model::Associations::EmbedsOne do
     specify { expect(association.create(name: 'Fred')).to be_a Author }
     specify { expect(association.create(name: 'Fred')).to be_persisted }
 
-    specify { expect { association.create }
-      .not_to change { book.read_attribute(:author) } }
-    specify { expect { association.create(name: 'Fred') }
-      .to change { book.read_attribute(:author) }.from(nil).to('name' => 'Fred') }
+    specify do
+      expect { association.create }
+        .not_to change { book.read_attribute(:author) }
+    end
+    specify do
+      expect { association.create(name: 'Fred') }
+        .to change { book.read_attribute(:author) }
+        .from(nil).to('name' => 'Fred')
+    end
 
-    specify { expect { existing_association.create }
-      .not_to change { existing_book.read_attribute(:author) } }
-    specify { expect { existing_association.create(name: 'Fred') }
-      .to change { existing_book.read_attribute(:author) }.from('name' => 'Johny').to('name' => 'Fred') }
+    specify do
+      expect { existing_association.create }
+        .not_to change { existing_book.read_attribute(:author) }
+    end
+    specify do
+      expect { existing_association.create(name: 'Fred') }
+        .to change { existing_book.read_attribute(:author) }
+        .from('name' => 'Johny').to('name' => 'Fred')
+    end
   end
 
   describe '#create!' do
     specify { expect { association.create! }.to raise_error ActiveData::ValidationError }
+    specify do
+      expect { muffle(ActiveData::ValidationError) { association.create! } }
+        .to change { association.target }
+        .from(nil).to(an_instance_of(Author))
+    end
 
     specify { expect(association.create!(name: 'Fred')).to be_a Author }
     specify { expect(association.create!(name: 'Fred')).to be_persisted }
 
-    specify { expect { association.create! rescue nil }
-      .not_to change { book.read_attribute(:author) } }
-    specify { expect { association.create! rescue nil }
-      .to change { association.reader.try(:attributes) }.from(nil).to('name' => nil) }
-    specify { expect { association.create(name: 'Fred') }
-      .to change { book.read_attribute(:author) }.from(nil).to('name' => 'Fred') }
-
-    specify { expect { existing_association.create! rescue nil }
-      .not_to change { existing_book.read_attribute(:author) } }
-    specify { expect { existing_association.create! rescue nil }
-      .to change { existing_association.reader.try(:attributes) }.from('name' => 'Johny').to('name' => nil) }
-    specify { expect { existing_association.create!(name: 'Fred') }
-      .to change { existing_book.read_attribute(:author) }.from('name' => 'Johny').to('name' => 'Fred') }
+    specify do
+      expect { muffle(ActiveData::ValidationError) { association.create! } }
+        .not_to change { book.read_attribute(:author) }
+    end
+    specify do
+      expect { muffle(ActiveData::ValidationError) { association.create! } }
+        .to change { association.reader.try(:attributes) }
+        .from(nil).to('name' => nil)
+    end
+    specify do
+      expect { association.create(name: 'Fred') }
+        .to change { book.read_attribute(:author) }
+        .from(nil).to('name' => 'Fred')
+    end
+
+    specify do
+      expect { muffle(ActiveData::ValidationError) { existing_association.create! } }
+        .not_to change { existing_book.read_attribute(:author) }
+    end
+    specify do
+      expect { muffle(ActiveData::ValidationError) { existing_association.create! } }
+        .to change { existing_association.reader.try(:attributes) }
+        .from('name' => 'Johny').to('name' => nil)
+    end
+    specify do
+      expect { existing_association.create!(name: 'Fred') }
+        .to change { existing_book.read_attribute(:author) }
+        .from('name' => 'Johny').to('name' => 'Fred')
+    end
   end
 
   describe '#apply_changes' do
-    specify { expect { association.build; association.apply_changes }.to change { association.target.try(:persisted?) }.to(false) }
-    specify { expect { association.build(name: 'Fred'); association.apply_changes }.to change { association.target.try(:persisted?) }.to(true) }
-    specify { expect { existing_association.target.mark_for_destruction; existing_association.apply_changes }.to change { existing_association.target }.to(nil) }
-    specify { expect { existing_association.target.destroy!; existing_association.apply_changes }.to change { existing_association.target }.to(nil) }
-    specify { expect { existing_association.target.mark_for_destruction; existing_association.apply_changes }.to change { existing_association.destroyed.try(:name) }.from(nil).to('Johny') }
-    specify { expect { existing_association.target.destroy!; existing_association.apply_changes }.to change { existing_association.destroyed.try(:name) }.from(nil).to('Johny') }
+    specify do
+      association.build
+      expect { association.apply_changes }
+        .not_to change { association.target.persisted? }.from(false)
+    end
+    specify do
+      association.build(name: 'Fred')
+      expect { association.apply_changes }
+        .to change { association.target.persisted? }.to(true)
+    end
+    specify do
+      existing_association.target.mark_for_destruction
+      expect { existing_association.apply_changes }
+        .to change { existing_association.target }.to(nil)
+    end
+    specify do
+      existing_association.target.destroy!
+      expect { existing_association.apply_changes }
+        .to change { existing_association.target }.to(nil)
+    end
+    specify do
+      existing_association.target.mark_for_destruction
+      expect { existing_association.apply_changes }
+        .to change { existing_association.destroyed.try(:name) }.from(nil).to('Johny')
+    end
+    specify do
+      existing_association.target.destroy!
+      expect { existing_association.apply_changes }
+        .to change { existing_association.destroyed.try(:name) }.from(nil).to('Johny')
+    end
   end
 
   describe '#apply_changes!' do
-    specify { expect { association.build; association.apply_changes! }.to raise_error ActiveData::AssociationChangesNotApplied }
-    specify { expect { association.build(name: 'Fred'); association.apply_changes! }.to change { association.target.try(:persisted?) }.to(true) }
-    specify { expect { existing_association.target.mark_for_destruction; existing_association.apply_changes! }.to change { existing_association.target }.to(nil) }
-    specify { expect { existing_association.target.destroy!; existing_association.apply_changes! }.to change { existing_association.target }.to(nil) }
+    specify do
+      association.build
+      expect { association.apply_changes! }
+        .to raise_error ActiveData::AssociationChangesNotApplied
+    end
+    specify do
+      association.build(name: 'Fred')
+      expect { association.apply_changes! }
+        .to change { association.target.persisted? }.to(true)
+    end
+    specify do
+      existing_association.target.mark_for_destruction
+      expect { existing_association.apply_changes! }
+        .to change { existing_association.target }.to(nil)
+    end
+    specify do
+      existing_association.target.destroy!
+      expect { existing_association.apply_changes! }
+        .to change { existing_association.target }.to(nil)
+    end
   end
 
   describe '#target' do
@@ -103,7 +308,7 @@ describe ActiveData::Model::Associations::EmbedsOne do
   end
 
   describe '#default' do
-    before { Book.embeds_one :author, default: -> { { name: 'Default' } } }
+    before { Book.embeds_one :author, default: -> { {name: 'Default'} } }
     before do
       Author.class_eval do
         include ActiveData::Model::Primary
@@ -148,15 +353,19 @@ describe ActiveData::Model::Associations::EmbedsOne do
 
     context do
       before { association.build(name: 'Fred') }
-      specify { expect { association.reload }
-        .to change { association.reader.try(:attributes) }.from('name' => 'Fred').to(nil) }
+      specify do
+        expect { association.reload }
+          .to change { association.reader.try(:attributes) }.from('name' => 'Fred').to(nil)
+      end
     end
 
     context do
       before { existing_association.build(name: 'Fred') }
-      specify { expect { existing_association.reload }
-        .to change { existing_association.reader.try(:attributes) }
-        .from('name' => 'Fred').to('name' => 'Johny') }
+      specify do
+        expect { existing_association.reload }
+          .to change { existing_association.reader.try(:attributes) }
+          .from('name' => 'Fred').to('name' => 'Johny')
+      end
     end
   end
 
@@ -165,10 +374,14 @@ describe ActiveData::Model::Associations::EmbedsOne do
     specify { expect { association.clear }.not_to change { association.reader } }
 
     specify { expect(existing_association.clear).to eq(true) }
-    specify { expect { existing_association.clear }
-      .to change { existing_association.reader.try(:attributes) }.from('name' => 'Johny').to(nil) }
-    specify { expect { existing_association.clear }
-      .to change { existing_book.read_attribute(:author) }.from('name' => 'Johny').to(nil) }
+    specify do
+      expect { existing_association.clear }
+        .to change { existing_association.reader.try(:attributes) }.from('name' => 'Johny').to(nil)
+    end
+    specify do
+      expect { existing_association.clear }
+        .to change { existing_book.read_attribute(:author) }.from('name' => 'Johny').to(nil)
+    end
 
     context do
       before { Author.send(:include, ActiveData::Model::Callbacks) }
@@ -178,10 +391,14 @@ describe ActiveData::Model::Associations::EmbedsOne do
         before { Author.before_destroy { false } }
       end
       specify { expect(existing_association.clear).to eq(false) }
-      specify { expect { existing_association.clear }
-        .not_to change { existing_association.reader } }
-      specify { expect { existing_association.clear }
-        .not_to change { existing_book.read_attribute(:author).symbolize_keys } }
+      specify do
+        expect { existing_association.clear }
+          .not_to change { existing_association.reader }
+      end
+      specify do
+        expect { existing_association.clear }
+          .not_to change { existing_book.read_attribute(:author).symbolize_keys }
+      end
     end
   end
 
@@ -216,61 +433,101 @@ describe ActiveData::Model::Associations::EmbedsOne do
         end
       end
 
-      specify { expect { association.writer(nil) }
-        .not_to change { book.read_attribute(:author) } }
-      specify { expect { association.writer(new_author) }
-        .to change { association.reader.try(:attributes) }.from(nil).to('name' => 'Morty') }
-      specify { expect { association.writer(new_author) }
-        .to change { book.read_attribute(:author) }.from(nil).to('name' => 'Morty') }
+      specify do
+        expect { association.writer(nil) }
+          .not_to change { book.read_attribute(:author) }
+      end
+      specify do
+        expect { association.writer(new_author) }
+          .to change { association.reader.try(:attributes) }.from(nil).to('name' => 'Morty')
+      end
+      specify do
+        expect { association.writer(new_author) }
+          .to change { book.read_attribute(:author) }.from(nil).to('name' => 'Morty')
+      end
 
-      specify { expect { association.writer(invalid_author) }
-        .to raise_error ActiveData::AssociationChangesNotApplied }
-      specify { expect { association.writer(invalid_author) rescue nil }
-        .not_to change { association.reader } }
-      specify { expect { association.writer(invalid_author) rescue nil }
-        .not_to change { book.read_attribute(:author) } }
+      specify do
+        expect { association.writer(invalid_author) }
+          .to raise_error ActiveData::AssociationChangesNotApplied
+      end
+      specify do
+        expect { muffle(ActiveData::AssociationChangesNotApplied) { association.writer(invalid_author) } }
+          .not_to change { association.reader }
+      end
+      specify do
+        expect { muffle(ActiveData::AssociationChangesNotApplied) { association.writer(invalid_author) } }
+          .not_to change { book.read_attribute(:author) }
+      end
     end
 
     context 'persisted owner' do
-      specify { expect { association.writer(stub_model(:dummy).new) }
-        .to raise_error ActiveData::AssociationTypeMismatch }
+      specify do
+        expect { association.writer(stub_model(:dummy).new) }
+          .to raise_error ActiveData::AssociationTypeMismatch
+      end
 
       specify { expect(association.writer(nil)).to be_nil }
       specify { expect(association.writer(new_author)).to eq(new_author) }
-      specify { expect { association.writer(nil) }
-        .not_to change { book.read_attribute(:author) } }
-      specify { expect { association.writer(new_author) }
-        .to change { association.reader.try(:attributes) }.from(nil).to('name' => 'Morty') }
-      specify { expect { association.writer(new_author) }
-        .not_to change { book.read_attribute(:author) } }
-
-      specify { expect { association.writer(invalid_author) }
-        .to change { association.reader.try(:attributes) }.from(nil).to('name' => nil) }
-      specify { expect { association.writer(invalid_author) }
-        .not_to change { book.read_attribute(:author) } }
-
-      specify { expect { existing_association.writer(stub_model(:dummy).new) rescue nil }
-        .not_to change { existing_book.read_attribute(:author) } }
-      specify { expect { existing_association.writer(stub_model(:dummy).new) rescue nil }
-        .not_to change { existing_association.reader } }
+      specify do
+        expect { association.writer(nil) }
+          .not_to change { book.read_attribute(:author) }
+      end
+      specify do
+        expect { association.writer(new_author) }
+          .to change { association.reader.try(:attributes) }.from(nil).to('name' => 'Morty')
+      end
+      specify do
+        expect { association.writer(new_author) }
+          .not_to change { book.read_attribute(:author) }
+      end
+
+      specify do
+        expect { association.writer(invalid_author) }
+          .to change { association.reader.try(:attributes) }.from(nil).to('name' => nil)
+      end
+      specify do
+        expect { association.writer(invalid_author) }
+          .not_to change { book.read_attribute(:author) }
+      end
+
+      specify do
+        expect { muffle(ActiveData::AssociationTypeMismatch) { existing_association.writer(stub_model(:dummy).new) } }
+          .not_to change { existing_book.read_attribute(:author) }
+      end
+      specify do
+        expect { muffle(ActiveData::AssociationTypeMismatch) { existing_association.writer(stub_model(:dummy).new) } }
+          .not_to change { existing_association.reader }
+      end
 
       specify { expect(existing_association.writer(nil)).to be_nil }
       specify { expect(existing_association.writer(new_author)).to eq(new_author) }
-      specify { expect { existing_association.writer(nil) }
-        .to change { existing_book.read_attribute(:author) }.from('name' => 'Johny').to(nil) }
-      specify { expect { existing_association.writer(new_author) }
-        .to change { existing_association.reader.try(:attributes) }
-        .from('name' => 'Johny').to('name' => 'Morty') }
-      specify { expect { existing_association.writer(new_author) }
-        .to change { existing_book.read_attribute(:author) }
-        .from('name' => 'Johny').to('name' => 'Morty') }
-
-      specify { expect { existing_association.writer(invalid_author) }
-        .to raise_error ActiveData::AssociationChangesNotApplied }
-      specify { expect { existing_association.writer(invalid_author) rescue nil }
-        .not_to change { existing_association.reader } }
-      specify { expect { existing_association.writer(invalid_author) rescue nil }
-        .not_to change { existing_book.read_attribute(:author) } }
+      specify do
+        expect { existing_association.writer(nil) }
+          .to change { existing_book.read_attribute(:author) }.from('name' => 'Johny').to(nil)
+      end
+      specify do
+        expect { existing_association.writer(new_author) }
+          .to change { existing_association.reader.try(:attributes) }
+          .from('name' => 'Johny').to('name' => 'Morty')
+      end
+      specify do
+        expect { existing_association.writer(new_author) }
+          .to change { existing_book.read_attribute(:author) }
+          .from('name' => 'Johny').to('name' => 'Morty')
+      end
+
+      specify do
+        expect { existing_association.writer(invalid_author) }
+          .to raise_error ActiveData::AssociationChangesNotApplied
+      end
+      specify do
+        expect { muffle(ActiveData::AssociationChangesNotApplied) { existing_association.writer(invalid_author) } }
+          .not_to change { existing_association.reader }
+      end
+      specify do
+        expect { muffle(ActiveData::AssociationChangesNotApplied) { existing_association.writer(invalid_author) } }
+          .not_to change { existing_book.read_attribute(:author) }
+      end
     end
   end
 end