active_data 1.0.0 → 1.1.0

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

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 require 'spec_helper'
 
 describe ActiveData::Model::Associations::EmbedsMany do
@@ -22,17 +21,12 @@ describe ActiveData::Model::Associations::EmbedsMany do
     end
   end
 
-  let(:user) { User.new }
+  let(:user) { User.new(name: 'User') }
   let(:association) { user.association(:projects) }
 
   let(:existing_user) { User.instantiate name: 'Rick', projects: [{title: 'Genesis'}] }
   let(:existing_association) { existing_user.association(:projects) }
 
-  describe 'user#association' do
-    specify { expect(association).to be_a described_class }
-    specify { expect(association).to eq(user.association(:projects)) }
-  end
-
   context 'performers' do
     let(:user) { User.new(projects: [Project.new(title: 'Project 1')]) }
 
@@ -56,7 +50,8 @@ describe ActiveData::Model::Associations::EmbedsMany do
       user.projects.map(&:save!)
       expect(user.read_attribute(:projects)).to eq([
         {'title' => 'Project 1'}, {'title' => 'Project 2'}, {'title' => 'Project 3'},
-        {'title' => 'Project 4'}, {'title' => 'Project 5'}])
+        {'title' => 'Project 4'}, {'title' => 'Project 5'}
+      ])
       user.projects.map(&:destroy!)
       expect(user.read_attribute(:projects)).to eq([])
       user.projects.first(2).map(&:save!)
@@ -64,12 +59,184 @@ describe ActiveData::Model::Associations::EmbedsMany do
       expect(user.projects.reload.count).to eq(2)
       p3 = user.projects.create!(title: 'Project 3')
       expect(user.read_attribute(:projects)).to eq([
-        {'title' => 'Project 1'}, {'title' => 'Project 2'}, {'title' => 'Project 3'}])
+        {'title' => 'Project 1'}, {'title' => 'Project 2'}, {'title' => 'Project 3'}
+      ])
       p3.destroy!
       expect(user.read_attribute(:projects)).to eq([{'title' => 'Project 1'}, {'title' => 'Project 2'}])
-      p4 = user.projects.create(title: 'Project 4')
+      user.projects.create!(title: 'Project 4')
       expect(user.read_attribute(:projects)).to eq([
-        {'title' => 'Project 1'}, {'title' => 'Project 2'}, {'title' => 'Project 4'}])
+        {'title' => 'Project 1'}, {'title' => 'Project 2'}, {'title' => 'Project 4'}
+      ])
+    end
+  end
+
+  context 'callbacks' do
+    before do
+      User.class_eval do
+        embeds_many :projects,
+          before_add: ->(object) { callbacks.push([:before_add, object]) },
+          after_add: ->(object) { callbacks.push([:after_add, object]) }
+
+        collection :callbacks, Array
+      end
+    end
+    let(:project1) { Project.new(title: 'Project1') }
+    let(:project2) { Project.new(title: 'Project2') }
+
+    specify do
+      expect { association.build(title: 'Project1') }
+        .to change { user.callbacks }
+        .to([[:before_add, project1], [:after_add, project1]])
+    end
+
+    specify do
+      expect do
+        association.build(title: 'Project1')
+        association.build(title: 'Project2')
+      end
+        .to change { user.callbacks }
+        .to([
+          [:before_add, project1], [:after_add, project1],
+          [:before_add, project2], [:after_add, project2]
+        ])
+    end
+
+    specify do
+      expect { association.create(title: 'Project1') }
+        .to change { user.callbacks }
+        .to([[:before_add, project1], [:after_add, project1]])
+    end
+
+    specify do
+      expect do
+        association.create(title: 'Project1')
+        association.create(title: 'Project2')
+      end
+        .to change { user.callbacks }
+        .to([
+          [:before_add, project1], [:after_add, project1],
+          [:before_add, project2], [:after_add, project2]
+        ])
+    end
+
+    specify do
+      expect { association.concat(project1, project2) }
+        .to change { user.callbacks }
+        .to([
+          [:before_add, project1], [:after_add, project1],
+          [:before_add, project2], [:after_add, project2]
+        ])
+    end
+
+    specify do
+      expect do
+        association.concat(project1)
+        association.concat(project2)
+      end
+        .to change { user.callbacks }
+        .to([
+          [:before_add, project1], [:after_add, project1],
+          [:before_add, project2], [:after_add, project2]
+        ])
+    end
+
+    specify do
+      expect { association.writer([project2, project1]) }
+        .to change { user.callbacks }
+        .to([
+          [:before_add, project2], [:after_add, project2],
+          [:before_add, project1], [:after_add, project1]
+        ])
+    end
+
+    specify do
+      expect do
+        association.writer([project1])
+        association.writer([])
+        association.writer([project2])
+      end
+        .to change { user.callbacks }
+        .to([
+          [:before_add, project1], [:after_add, project1],
+          [:before_add, project2], [:after_add, project2]
+        ])
+    end
+
+    context 'default' do
+      before do
+        User.class_eval do
+          embeds_many :projects,
+            before_add: ->(owner, object) { owner.callbacks.push([:before_add, object]) },
+            after_add: ->(owner, object) { owner.callbacks.push([:after_add, object]) },
+            default: -> { {title: 'Project1'} }
+
+          collection :callbacks, Array
+        end
+      end
+
+      specify do
+        expect { association.concat(project2) }
+          .to change { user.callbacks }
+          .to([
+            [:before_add, project2], [:after_add, project2],
+            [:before_add, project1], [:after_add, project1]
+          ])
+      end
+    end
+  end
+
+  describe 'user#association' do
+    specify { expect(association).to be_a described_class }
+    specify { expect(association).to eq(user.association(:projects)) }
+  end
+
+  describe 'project#embedder' do
+    let(:project) { Project.new(title: 'Project') }
+
+    specify { expect(association.build.embedder).to eq(user) }
+    specify { expect(association.create.embedder).to eq(user) }
+    specify do
+      expect { association.writer([project]) }
+        .to change { project.embedder }.from(nil).to(user)
+    end
+    specify do
+      expect { association.concat(project) }
+        .to change { project.embedder }.from(nil).to(user)
+    end
+    specify do
+      expect { association.target = [project] }
+        .to change { project.embedder }.from(nil).to(user)
+    end
+
+    context 'default' do
+      before do
+        User.class_eval do
+          embeds_many :projects, default: -> { {title: 'Project1'} }
+        end
+      end
+
+      specify { expect(association.target.first.embedder).to eq(user) }
+
+      context do
+        before do
+          User.class_eval do
+            embeds_many :projects, default: -> { Project.new(title: 'Project1') }
+          end
+        end
+
+        specify { expect(association.target.first.embedder).to eq(user) }
+      end
+    end
+
+    context 'embedding goes before attributes' do
+      before do
+        Project.class_eval do
+          attribute :title, String, normalize: ->(value) { "#{value}#{embedder.name}" }
+        end
+      end
+
+      specify { expect(association.build(title: 'Project').title).to eq('ProjectUser') }
+      specify { expect(association.create(title: 'Project').title).to eq('ProjectUser') }
     end
   end
 
@@ -77,17 +244,25 @@ describe ActiveData::Model::Associations::EmbedsMany do
     specify { expect(association.build).to be_a Project }
     specify { expect(association.build).not_to be_persisted }
 
-    specify { expect { association.build(title: 'Swordfish') }
-      .not_to change { user.read_attribute(:projects) } }
-    specify { expect { association.build(title: 'Swordfish') }
-      .to change { association.reader.map(&:attributes) }
-      .from([]).to([{'title' => 'Swordfish'}]) }
-
-    specify { expect { existing_association.build(title: 'Swordfish') }
-      .not_to change { existing_user.read_attribute(:projects) } }
-    specify { expect { existing_association.build(title: 'Swordfish') }
-      .to change { existing_association.reader.map(&:attributes) }
-      .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Swordfish'}]) }
+    specify do
+      expect { association.build(title: 'Swordfish') }
+        .not_to change { user.read_attribute(:projects) }
+    end
+    specify do
+      expect { association.build(title: 'Swordfish') }
+        .to change { association.reader.map(&:attributes) }
+        .from([]).to([{'title' => 'Swordfish'}])
+    end
+
+    specify do
+      expect { existing_association.build(title: 'Swordfish') }
+        .not_to change { existing_user.read_attribute(:projects) }
+    end
+    specify do
+      expect { existing_association.build(title: 'Swordfish') }
+        .to change { existing_association.reader.map(&:attributes) }
+        .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Swordfish'}])
+    end
   end
 
   describe '#create' do
@@ -97,22 +272,35 @@ describe ActiveData::Model::Associations::EmbedsMany do
     specify { expect(association.create(title: 'Swordfish')).to be_a Project }
     specify { expect(association.create(title: 'Swordfish')).to be_persisted }
 
-    specify { expect { association.create }
-      .not_to change { user.read_attribute(:projects) } }
-    specify { expect { association.create(title: 'Swordfish') }
-      .to change { user.read_attribute(:projects) }.from(nil).to([{'title' => 'Swordfish'}]) }
-    specify { expect { association.create(title: 'Swordfish') }
-      .to change { association.reader.map(&:attributes) }
-      .from([]).to([{'title' => 'Swordfish'}]) }
-
-    specify { expect { existing_association.create }
-      .not_to change { existing_user.read_attribute(:projects) } }
-    specify { expect { existing_association.create(title: 'Swordfish') }
-      .to change { existing_user.read_attribute(:projects) }
-      .from([{title: 'Genesis'}]).to([{title: 'Genesis'}, {'title' => 'Swordfish'}]) }
-    specify { expect { existing_association.create(title: 'Swordfish') }
-      .to change { existing_association.reader.map(&:attributes) }
-      .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Swordfish'}]) }
+    specify do
+      expect { association.create }
+        .not_to change { user.read_attribute(:projects) }
+    end
+    specify do
+      expect { association.create(title: 'Swordfish') }
+        .to change { user.read_attribute(:projects) }
+        .from(nil).to([{'title' => 'Swordfish'}])
+    end
+    specify do
+      expect { association.create(title: 'Swordfish') }
+        .to change { association.reader.map(&:attributes) }
+        .from([]).to([{'title' => 'Swordfish'}])
+    end
+
+    specify do
+      expect { existing_association.create }
+        .not_to change { existing_user.read_attribute(:projects) }
+    end
+    specify do
+      expect { existing_association.create(title: 'Swordfish') }
+        .to change { existing_user.read_attribute(:projects) }
+        .from([{title: 'Genesis'}]).to([{title: 'Genesis'}, {'title' => 'Swordfish'}])
+    end
+    specify do
+      expect { existing_association.create(title: 'Swordfish') }
+        .to change { existing_association.reader.map(&:attributes) }
+        .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Swordfish'}])
+    end
   end
 
   describe '#create!' do
@@ -121,77 +309,128 @@ describe ActiveData::Model::Associations::EmbedsMany do
     specify { expect(association.create!(title: 'Swordfish')).to be_a Project }
     specify { expect(association.create!(title: 'Swordfish')).to be_persisted }
 
-    specify { expect { association.create! rescue nil }
-      .not_to change { user.read_attribute(:projects) } }
-    specify { expect { association.create! rescue nil }
-      .to change { association.reader.map(&:attributes) }.from([]).to([{'title' => nil}]) }
-    specify { expect { association.create!(title: 'Swordfish') }
-      .to change { user.read_attribute(:projects) }.from(nil).to([{'title' => 'Swordfish'}]) }
-    specify { expect { association.create!(title: 'Swordfish') }
-      .to change { association.reader.map(&:attributes) }
-      .from([]).to([{'title' => 'Swordfish'}]) }
-
-    specify { expect { existing_association.create! rescue nil }
-      .not_to change { existing_user.read_attribute(:projects) } }
-    specify { expect { existing_association.create! rescue nil }
-      .to change { existing_association.reader.map(&:attributes) }
-      .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => nil}]) }
-    specify { expect { existing_association.create!(title: 'Swordfish') }
-      .to change { existing_user.read_attribute(:projects) }
-      .from([{title: 'Genesis'}]).to([{title: 'Genesis'}, {'title' => 'Swordfish'}]) }
-    specify { expect { existing_association.create!(title: 'Swordfish') }
-      .to change { existing_association.reader.map(&:attributes) }
-      .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Swordfish'}]) }
+    specify do
+      expect { muffle(ActiveData::ValidationError) { association.create! } }
+        .not_to change { user.read_attribute(:projects) }
+    end
+    specify do
+      expect { muffle(ActiveData::ValidationError) { association.create! } }
+        .to change { association.reader.map(&:attributes) }.from([]).to([{'title' => nil}])
+    end
+    specify do
+      expect { association.create!(title: 'Swordfish') }
+        .to change { user.read_attribute(:projects) }.from(nil).to([{'title' => 'Swordfish'}])
+    end
+    specify do
+      expect { association.create!(title: 'Swordfish') }
+        .to change { association.reader.map(&:attributes) }
+        .from([]).to([{'title' => 'Swordfish'}])
+    end
+
+    specify do
+      expect { muffle(ActiveData::ValidationError) { existing_association.create! } }
+        .not_to change { existing_user.read_attribute(:projects) }
+    end
+    specify do
+      expect { muffle(ActiveData::ValidationError) { existing_association.create! } }
+        .to change { existing_association.reader.map(&:attributes) }
+        .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => nil}])
+    end
+    specify do
+      expect { existing_association.create!(title: 'Swordfish') }
+        .to change { existing_user.read_attribute(:projects) }
+        .from([{title: 'Genesis'}]).to([{title: 'Genesis'}, {'title' => 'Swordfish'}])
+    end
+    specify do
+      expect { existing_association.create!(title: 'Swordfish') }
+        .to change { existing_association.reader.map(&:attributes) }
+        .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Swordfish'}])
+    end
   end
 
   describe '#apply_changes' do
-    specify { expect { association.build; association.apply_changes }.to change { association.target.map(&:persisted?) }.to([false]) }
-    specify { expect { association.build(title: 'Genesis'); association.apply_changes }.to change { association.target.map(&:persisted?) }.to([true]) }
-    specify { expect {
+    specify do
+      association.build
+      expect { association.apply_changes }
+        .not_to change { association.target.map(&:persisted?) }
+        .from([false])
+    end
+    specify do
+      association.build(title: 'Genesis')
+      expect { association.apply_changes }
+        .to change { association.target.map(&:persisted?) }
+        .from([false]).to([true])
+    end
+    specify do
       existing_association.target.first.mark_for_destruction
-      existing_association.build(title: 'Swordfish');
-      existing_association.apply_changes
-    }.to change { existing_association.target.map(&:title) }.to(['Swordfish']) }
-    specify { expect {
+      existing_association.build(title: 'Swordfish')
+      expect { existing_association.apply_changes }
+        .to change { existing_association.target.map(&:title) }
+        .to(['Swordfish'])
+    end
+    specify do
       existing_association.target.first.mark_for_destruction
-      existing_association.build(title: 'Swordfish');
-      existing_association.apply_changes
-    }.not_to change { existing_association.target.map(&:persisted?) } }
-    specify { expect {
+      existing_association.build(title: 'Swordfish')
+      expect { existing_association.apply_changes }
+        .to change { existing_association.target.map(&:persisted?) }
+        .from([true, false]).to([true])
+    end
+    specify do
       existing_association.target.first.mark_for_destruction
-      existing_association.build(title: 'Swordfish');
-      existing_association.apply_changes
-    }.to change { existing_association.destroyed.map(&:title) }.from([]).to(['Genesis']) }
-    specify { expect {
+      existing_association.build(title: 'Swordfish')
+      expect { existing_association.apply_changes }
+        .to change { existing_association.destroyed.map(&:title) }
+        .from([]).to(['Genesis'])
+    end
+    specify do
       existing_association.target.first.destroy!
-      existing_association.build(title: 'Swordfish');
-      existing_association.apply_changes
-    }.to change { existing_association.target.map(&:title) }.to(['Swordfish']) }
-    specify { expect {
+      existing_association.build(title: 'Swordfish')
+      expect { existing_association.apply_changes }
+        .to change { existing_association.target.map(&:title) }
+        .to(['Swordfish'])
+    end
+    specify do
       existing_association.target.first.destroy!
-      existing_association.build(title: 'Swordfish');
-      existing_association.apply_changes
-    }.to change { existing_association.destroyed.map(&:title) }.from([]).to(['Genesis']) }
+      existing_association.build(title: 'Swordfish')
+      expect { existing_association.apply_changes }
+        .to change { existing_association.destroyed.map(&:title) }
+        .from([]).to(['Genesis'])
+    end
   end
 
   describe '#apply_changes!' do
-    specify { expect { association.build; association.apply_changes! }.to raise_error ActiveData::AssociationChangesNotApplied }
-    specify { expect { association.build(title: 'Genesis'); association.apply_changes! }.to change { association.target.map(&:persisted?) }.to([true]) }
-    specify { expect {
+    specify do
+      association.build
+      expect { association.apply_changes! }
+        .to raise_error ActiveData::AssociationChangesNotApplied
+    end
+    specify do
+      association.build(title: 'Genesis')
+      expect { association.apply_changes! }
+        .to change { association.target.map(&:persisted?) }
+        .to([true])
+    end
+    specify do
       existing_association.target.first.mark_for_destruction
-      existing_association.build(title: 'Swordfish');
-      existing_association.apply_changes!
-    }.to change { existing_association.target.map(&:title) }.to(['Swordfish']) }
-    specify { expect {
+      existing_association.build(title: 'Swordfish')
+      expect { existing_association.apply_changes! }
+        .to change { existing_association.target.map(&:title) }
+        .to(['Swordfish'])
+    end
+    specify do
       existing_association.target.first.mark_for_destruction
-      existing_association.build(title: 'Swordfish');
-      existing_association.apply_changes!
-    }.not_to change { existing_association.target.map(&:persisted?) } }
-    specify { expect {
+      existing_association.build(title: 'Swordfish')
+      expect { existing_association.apply_changes! }
+        .to change { existing_association.target.map(&:persisted?) }
+        .from([true, false]).to([true])
+    end
+    specify do
       existing_association.target.first.destroy!
-      existing_association.build(title: 'Swordfish');
-      existing_association.apply_changes!
-    }.to change { existing_association.target.map(&:title) }.to(['Swordfish']) }
+      existing_association.build(title: 'Swordfish')
+      expect { existing_association.apply_changes! }
+        .to change { existing_association.target.map(&:title) }
+        .to(['Swordfish'])
+    end
   end
 
   describe '#target' do
@@ -201,7 +440,7 @@ describe ActiveData::Model::Associations::EmbedsMany do
   end
 
   describe '#default' do
-    before { User.embeds_many :projects, default: -> { { title: 'Default' } } }
+    before { User.embeds_many :projects, default: -> { {title: 'Default'} } }
     before do
       Project.class_eval do
         include ActiveData::Model::Primary
@@ -241,15 +480,19 @@ describe ActiveData::Model::Associations::EmbedsMany do
 
     context do
       before { association.build(title: 'Swordfish') }
-      specify { expect { association.reload }
-        .to change { association.reader.map(&:attributes) }.from([{'title' => 'Swordfish'}]).to([]) }
+      specify do
+        expect { association.reload }
+          .to change { association.reader.map(&:attributes) }.from([{'title' => 'Swordfish'}]).to([])
+      end
     end
 
     context do
       before { existing_association.build(title: 'Swordfish') }
-      specify { expect { existing_association.reload }
-        .to change { existing_association.reader.map(&:attributes) }
-        .from([{'title' => 'Genesis'}, {'title' => 'Swordfish'}]).to([{'title' => 'Genesis'}]) }
+      specify do
+        expect { existing_association.reload }
+          .to change { existing_association.reader.map(&:attributes) }
+          .from([{'title' => 'Genesis'}, {'title' => 'Swordfish'}]).to([{'title' => 'Genesis'}])
+      end
     end
   end
 
@@ -258,10 +501,14 @@ describe ActiveData::Model::Associations::EmbedsMany 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.map(&:attributes) }.from([{'title' => 'Genesis'}]).to([]) }
-    specify { expect { existing_association.clear }
-      .to change { existing_user.read_attribute(:projects) }.from([{title: 'Genesis'}]).to([]) }
+    specify do
+      expect { existing_association.clear }
+        .to change { existing_association.reader.map(&:attributes) }.from([{'title' => 'Genesis'}]).to([])
+    end
+    specify do
+      expect { existing_association.clear }
+        .to change { existing_user.read_attribute(:projects) }.from([{title: 'Genesis'}]).to([])
+    end
 
     context do
       let(:existing_user) { User.instantiate name: 'Rick', projects: [{title: 'Genesis'}, {title: 'Swordfish'}] }
@@ -273,10 +520,14 @@ describe ActiveData::Model::Associations::EmbedsMany do
       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_user.read_attribute(:projects) } }
+      specify do
+        expect { existing_association.clear }
+          .not_to change { existing_association.reader }
+      end
+      specify do
+        expect { existing_association.clear }
+          .not_to change { existing_user.read_attribute(:projects) }
+      end
     end
   end
 
@@ -308,52 +559,82 @@ describe ActiveData::Model::Associations::EmbedsMany do
     let(:new_project2) { Project.new(title: 'Project 2') }
     let(:invalid_project) { Project.new }
 
-    specify { expect { association.writer([Dummy.new]) }
-      .to raise_error ActiveData::AssociationTypeMismatch }
+    specify do
+      expect { association.writer([Dummy.new]) }
+        .to raise_error ActiveData::AssociationTypeMismatch
+    end
 
     specify { expect { association.writer(nil) }.to raise_error NoMethodError }
     specify { expect { association.writer(new_project1) }.to raise_error NoMethodError }
     specify { expect(association.writer([])).to eq([]) }
 
     specify { expect(association.writer([new_project1])).to eq([new_project1]) }
-    specify { expect { association.writer([new_project1]) }
-      .to change { association.reader.map(&:attributes) }.from([]).to([{'title' => 'Project 1'}]) }
-    specify { expect { association.writer([new_project1]) }
-      .not_to change { user.read_attribute(:projects) } }
-
-    specify { expect { existing_association.writer([new_project1, invalid_project]) }
-      .to raise_error ActiveData::AssociationChangesNotApplied }
-    specify { expect { existing_association.writer([new_project1, invalid_project]) rescue nil }
-      .not_to change { existing_user.read_attribute(:projects) } }
-    specify { expect { existing_association.writer([new_project1, invalid_project]) rescue nil }
-      .not_to change { existing_association.reader } }
-
-    specify { expect { existing_association.writer([new_project1, Dummy.new, new_project2]) }
-      .to raise_error ActiveData::AssociationTypeMismatch }
-    specify { expect { existing_association.writer([new_project1, Dummy.new, new_project2]) rescue nil }
-      .not_to change { existing_user.read_attribute(:projects) } }
-    specify { expect { existing_association.writer([new_project1, Dummy.new, new_project2]) rescue nil }
-      .not_to change { existing_association.reader } }
+    specify do
+      expect { association.writer([new_project1]) }
+        .to change { association.reader.map(&:attributes) }.from([]).to([{'title' => 'Project 1'}])
+    end
+    specify do
+      expect { association.writer([new_project1]) }
+        .not_to change { user.read_attribute(:projects) }
+    end
+
+    specify do
+      expect { existing_association.writer([new_project1, invalid_project]) }
+        .to raise_error ActiveData::AssociationChangesNotApplied
+    end
+    specify do
+      expect { muffle(ActiveData::AssociationChangesNotApplied) { existing_association.writer([new_project1, invalid_project]) } }
+        .not_to change { existing_user.read_attribute(:projects) }
+    end
+    specify do
+      expect { muffle(ActiveData::AssociationChangesNotApplied) { existing_association.writer([new_project1, invalid_project]) } }
+        .not_to change { existing_association.reader }
+    end
+
+    specify do
+      expect { existing_association.writer([new_project1, Dummy.new, new_project2]) }
+        .to raise_error ActiveData::AssociationTypeMismatch
+    end
+    specify do
+      expect { muffle(ActiveData::AssociationTypeMismatch) { existing_association.writer([new_project1, Dummy.new, new_project2]) } }
+        .not_to change { existing_user.read_attribute(:projects) }
+    end
+    specify do
+      expect { muffle(ActiveData::AssociationTypeMismatch) { existing_association.writer([new_project1, Dummy.new, new_project2]) } }
+        .not_to change { existing_association.reader }
+    end
 
     specify { expect { existing_association.writer(nil) }.to raise_error NoMethodError }
-    specify { expect { existing_association.writer(nil) rescue nil }
-      .not_to change { existing_user.read_attribute(:projects) } }
-    specify { expect { existing_association.writer(nil) rescue nil }
-      .not_to change { existing_association.reader } }
+    specify do
+      expect { muffle(NoMethodError) { existing_association.writer(nil) } }
+        .not_to change { existing_user.read_attribute(:projects) }
+    end
+    specify do
+      expect { muffle(NoMethodError) { existing_association.writer(nil) } }
+        .not_to change { existing_association.reader }
+    end
 
     specify { expect(existing_association.writer([])).to eq([]) }
-    specify { expect { existing_association.writer([]) }
-      .to change { existing_user.read_attribute(:projects) }.to([]) }
-    specify { expect { existing_association.writer([]) }
-      .to change { existing_association.reader }.to([]) }
+    specify do
+      expect { existing_association.writer([]) }
+        .to change { existing_user.read_attribute(:projects) }.to([])
+    end
+    specify do
+      expect { existing_association.writer([]) }
+        .to change { existing_association.reader }.to([])
+    end
 
     specify { expect(existing_association.writer([new_project1, new_project2])).to eq([new_project1, new_project2]) }
-    specify { expect { existing_association.writer([new_project1, new_project2]) }
-      .to change { existing_association.reader.map(&:attributes) }
-      .from([{'title' => 'Genesis'}]).to([{'title' => 'Project 1'}, {'title' => 'Project 2'}]) }
-    specify { expect { existing_association.writer([new_project1, new_project2]) }
-      .to change { existing_user.read_attribute(:projects) }
-      .from([{title: 'Genesis'}]).to([{'title' => 'Project 1'}, {'title' => 'Project 2'}]) }
+    specify do
+      expect { existing_association.writer([new_project1, new_project2]) }
+        .to change { existing_association.reader.map(&:attributes) }
+        .from([{'title' => 'Genesis'}]).to([{'title' => 'Project 1'}, {'title' => 'Project 2'}])
+    end
+    specify do
+      expect { existing_association.writer([new_project1, new_project2]) }
+        .to change { existing_user.read_attribute(:projects) }
+        .from([{title: 'Genesis'}]).to([{'title' => 'Project 1'}, {'title' => 'Project 2'}])
+    end
   end
 
   describe '#concat' do
@@ -361,8 +642,10 @@ describe ActiveData::Model::Associations::EmbedsMany do
     let(:new_project2) { Project.new(title: 'Project 2') }
     let(:invalid_project) { Project.new }
 
-    specify { expect { association.concat(Dummy.new) }
-      .to raise_error ActiveData::AssociationTypeMismatch }
+    specify do
+      expect { association.concat(Dummy.new) }
+        .to raise_error ActiveData::AssociationTypeMismatch
+    end
 
     specify { expect { association.concat(nil) }.to raise_error ActiveData::AssociationTypeMismatch }
     specify { expect(association.concat([])).to eq([]) }
@@ -370,34 +653,54 @@ describe ActiveData::Model::Associations::EmbedsMany do
     specify { expect(existing_association.concat).to eq(existing_user.projects) }
 
     specify { expect(association.concat(new_project1)).to eq([new_project1]) }
-    specify { expect { association.concat(new_project1) }
-      .to change { association.reader.map(&:attributes) }.from([]).to([{'title' => 'Project 1'}]) }
-    specify { expect { association.concat(new_project1) }
-      .not_to change { user.read_attribute(:projects) } }
+    specify do
+      expect { association.concat(new_project1) }
+        .to change { association.reader.map(&:attributes) }.from([]).to([{'title' => 'Project 1'}])
+    end
+    specify do
+      expect { association.concat(new_project1) }
+        .not_to change { user.read_attribute(:projects) }
+    end
 
     specify { expect(existing_association.concat(new_project1, invalid_project)).to eq(false) }
-    specify { expect { existing_association.concat(new_project1, invalid_project) }
-      .to change { existing_user.read_attribute(:projects) }
-      .from([{title: 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}]) }
-    specify { expect { existing_association.concat(new_project1, invalid_project) }
-      .to change { existing_association.reader.map(&:attributes) }
-      .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}, {'title' => nil}]) }
-
-    specify { expect { existing_association.concat(new_project1, Dummy.new, new_project2) }
-      .to raise_error ActiveData::AssociationTypeMismatch }
-    specify { expect { existing_association.concat(new_project1, Dummy.new, new_project2) rescue nil }
-      .not_to change { existing_user.read_attribute(:projects) } }
-    specify { expect { existing_association.concat(new_project1, Dummy.new, new_project2) rescue nil }
-      .to change { existing_association.reader.map(&:attributes) }
-      .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}]) }
-
-    specify { expect(existing_association.concat(new_project1, new_project2))
-      .to eq([existing_user.projects.first, new_project1, new_project2]) }
-    specify { expect { existing_association.concat([new_project1, new_project2]) }
-      .to change { existing_association.reader.map(&:attributes) }
-      .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}, {'title' => 'Project 2'}]) }
-    specify { expect { existing_association.concat([new_project1, new_project2]) }
-      .to change { existing_user.read_attribute(:projects) }
-      .from([{title: 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}, {'title' => 'Project 2'}]) }
+    specify do
+      expect { existing_association.concat(new_project1, invalid_project) }
+        .to change { existing_user.read_attribute(:projects) }
+        .from([{title: 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}])
+    end
+    specify do
+      expect { existing_association.concat(new_project1, invalid_project) }
+        .to change { existing_association.reader.map(&:attributes) }
+        .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}, {'title' => nil}])
+    end
+
+    specify do
+      expect { existing_association.concat(new_project1, Dummy.new, new_project2) }
+        .to raise_error ActiveData::AssociationTypeMismatch
+    end
+    specify do
+      expect { muffle(ActiveData::AssociationTypeMismatch) { existing_association.concat(new_project1, Dummy.new, new_project2) } }
+        .not_to change { existing_user.read_attribute(:projects) }
+    end
+    specify do
+      expect { muffle(ActiveData::AssociationTypeMismatch) { existing_association.concat(new_project1, Dummy.new, new_project2) } }
+        .to change { existing_association.reader.map(&:attributes) }
+        .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}])
+    end
+
+    specify do
+      expect(existing_association.concat(new_project1, new_project2))
+        .to eq([existing_user.projects.first, new_project1, new_project2])
+    end
+    specify do
+      expect { existing_association.concat([new_project1, new_project2]) }
+        .to change { existing_association.reader.map(&:attributes) }
+        .from([{'title' => 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}, {'title' => 'Project 2'}])
+    end
+    specify do
+      expect { existing_association.concat([new_project1, new_project2]) }
+        .to change { existing_user.read_attribute(:projects) }
+        .from([{title: 'Genesis'}]).to([{'title' => 'Genesis'}, {'title' => 'Project 1'}, {'title' => 'Project 2'}])
+    end
   end
 end