active_data 0.3.0 → 1.0.0

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

@@ -1,57 +1,276 @@
 # encoding: UTF-8
 require 'spec_helper'
 
-describe ActiveData::Model::Associations::EmbedsMany do
+describe ActiveData::Model::Associations::EmbedsOne do
+  before do
+    stub_model(:author) do
+      include ActiveData::Model::Lifecycle
 
-  class OneAssoc
-    include ActiveData::Model
+      attribute :name, String
+      validates :name, presence: true
+    end
+
+    stub_model(:book) do
+      include ActiveData::Model::Persistence
+      include ActiveData::Model::Associations
 
-    attribute :name
+      attribute :title, String
+      embeds_one :author
+    end
   end
 
-  let(:klass) do
-    Class.new do
-      include ActiveData::Model
+  let(:book) { Book.new }
+  let(:association) { book.association(:author) }
 
-      attribute :name
-      embeds_one :one_assoc
-    end
+  let(:existing_book) { Book.instantiate title: 'My Life', author: {'name' => 'Johny'} }
+  let(:existing_association) { existing_book.association(:author) }
+
+  describe 'book#association' do
+    specify { expect(association).to be_a described_class }
+    specify { expect(association).to eq(book.association(:author)) }
   end
 
-  subject { klass.new(name: 'world') }
+  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 { expect { existing_association.build(name: 'Fred') }
+      .not_to change { existing_book.read_attribute(:author) } }
+  end
+
+  describe '#create' do
+    specify { expect(association.create).to be_a Author }
+    specify { expect(association.create).not_to be_persisted }
+
+    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 { 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') }
+  end
+
+  describe '#create!' do
+    specify { expect { association.create! }.to raise_error ActiveData::ValidationError }
+
+    specify { expect(association.create!(name: 'Fred')).to be_a Author }
+    specify { expect(association.create!(name: 'Fred')).to be_persisted }
 
-  its(:one_assoc) { should be_nil }
+    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') }
 
-  context 'accessor with objects' do
-    before { subject.one_assoc = OneAssoc.new(name: 'foo') }
-    specify { subject.one_assoc.should be_instance_of OneAssoc }
-    specify { subject.one_assoc.name.should == 'foo' }
+    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') }
   end
 
-  context 'accessor with attributes' do
-    before { subject.one_assoc = { name: 'foo' } }
-    specify { subject.one_assoc.should be_instance_of OneAssoc }
-    specify { subject.one_assoc.name.should == 'foo' }
+  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') }
   end
 
-  context 'accessor with nothing' do
-    before { subject.one_assoc = nil }
-    specify { subject.one_assoc.should be_nil }
+  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) }
   end
 
-  describe '#==' do
-    let(:instance) { klass.new(name: 'world') }
-    before { subject.one_assoc = { name: 'foo' } }
-    specify { subject.should_not == instance }
+  describe '#target' do
+    specify { expect(association.target).to be_nil }
+    specify { expect(existing_association.target).to eq(existing_book.author) }
+    specify { expect { association.build }.to change { association.target }.to(an_instance_of(Author)) }
+  end
+
+  describe '#default' do
+    before { Book.embeds_one :author, default: -> { { name: 'Default' } } }
+    before do
+      Author.class_eval do
+        include ActiveData::Model::Primary
+        primary :name
+      end
+    end
+    let(:new_author) { Author.new.tap { |a| a.name = 'Morty' } }
+    let(:existing_book) { Book.instantiate title: 'My Life' }
+
+    specify { expect(association.target.name).to eq('Default') }
+    specify { expect(association.target.new_record?).to eq(true) }
+    specify { expect { association.replace(new_author) }.to change { association.target.name }.to eq('Morty') }
+    specify { expect { association.replace(nil) }.to change { association.target }.to be_nil }
+
+    specify { expect(existing_association.target).to be_nil }
+    specify { expect { existing_association.replace(new_author) }.to change { existing_association.target }.to(an_instance_of(Author)) }
+    specify { expect { existing_association.replace(nil) }.not_to change { existing_association.target } }
+
+    context do
+      before { Author.send(:include, ActiveData::Model::Dirty) }
+      specify { expect(association.target).not_to be_changed }
+    end
+  end
+
+  describe '#loaded?' do
+    let(:new_author) { Author.new(name: 'Morty') }
+
+    specify { expect(association.loaded?).to eq(false) }
+    specify { expect { association.target }.to change { association.loaded? }.to(true) }
+    specify { expect { association.build }.to change { association.loaded? }.to(true) }
+    specify { expect { association.replace(new_author) }.to change { association.loaded? }.to(true) }
+    specify { expect { association.replace(nil) }.to change { association.loaded? }.to(true) }
+    specify { expect { existing_association.replace(new_author) }.to change { existing_association.loaded? }.to(true) }
+    specify { expect { existing_association.replace(nil) }.to change { existing_association.loaded? }.to(true) }
+  end
+
+  describe '#reload' do
+    specify { expect(association.reload).to be_nil }
+
+    specify { expect(existing_association.reload).to be_a Author }
+    specify { expect(existing_association.reload).to be_persisted }
 
     context do
-      before { instance.one_assoc = { name: 'foo1' } }
-      specify { subject.should_not == instance }
+      before { association.build(name: 'Fred') }
+      specify { expect { association.reload }
+        .to change { association.reader.try(:attributes) }.from('name' => 'Fred').to(nil) }
     end
 
     context do
-      before { instance.one_assoc = { name: 'foo' } }
-      specify { subject.should == instance }
+      before { existing_association.build(name: 'Fred') }
+      specify { expect { existing_association.reload }
+        .to change { existing_association.reader.try(:attributes) }
+        .from('name' => 'Fred').to('name' => 'Johny') }
+    end
+  end
+
+  describe '#clear' do
+    specify { expect(association.clear).to eq(true) }
+    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) }
+
+    context do
+      before { Author.send(:include, ActiveData::Model::Callbacks) }
+      if ActiveModel.version >= Gem::Version.new('5.0.0')
+        before { Author.before_destroy { throw :abort } }
+      else
+        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 } }
+    end
+  end
+
+  describe '#reader' do
+    specify { expect(association.reader).to be_nil }
+
+    specify { expect(existing_association.reader).to be_a Author }
+    specify { expect(existing_association.reader).to be_persisted }
+
+    context do
+      before { association.build }
+      specify { expect(association.reader).to be_a Author }
+      specify { expect(association.reader).not_to be_persisted }
+      specify { expect(association.reader(true)).to be_nil }
+    end
+
+    context do
+      before { existing_association.build(name: 'Fred') }
+      specify { expect(existing_association.reader.name).to eq('Fred') }
+      specify { expect(existing_association.reader(true).name).to eq('Johny') }
+    end
+  end
+
+  describe '#writer' do
+    let(:new_author) { Author.new(name: 'Morty') }
+    let(:invalid_author) { Author.new }
+
+    context 'new owner' do
+      let(:book) do
+        Book.new.tap do |book|
+          book.send(:mark_persisted!)
+        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 { 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) } }
+    end
+
+    context 'persisted owner' do
+      specify { expect { association.writer(stub_model(:dummy).new) }
+        .to raise_error ActiveData::AssociationTypeMismatch }
+
+      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 { 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) } }
     end
   end
 end

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

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+require 'spec_helper'
+require 'lib/active_data/model/nested_attributes'
+
+describe ActiveData::Model::Associations::NestedAttributes do
+  before do
+    stub_model :user do
+      include ActiveData::Model::Associations
+
+      attribute :email, String
+      embeds_one :profile
+      embeds_many :projects
+
+      accepts_nested_attributes_for :profile, :projects
+
+      def save
+        apply_association_changes!
+      end
+    end
+  end
+
+  include_examples 'nested attributes'
+end

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

@@ -0,0 +1,196 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe ActiveData::Model::Associations::ReferencesMany do
+  before do
+    stub_model(:dummy)
+    stub_class(:author, ActiveRecord::Base) do
+      scope :name_starts_with_a, -> { where('name LIKE "a%"') }
+    end
+
+    stub_model(:book) do
+      include ActiveData::Model::Persistence
+      include ActiveData::Model::Associations
+
+      attribute :title
+      references_many :authors
+    end
+  end
+
+  let(:author) { Author.create!(name: 'Rick') }
+  let(:other) { Author.create!(name: 'Ben') }
+
+  let(:book) { Book.new }
+  let(:association) { book.association(:authors) }
+
+  let(:existing_book) { Book.instantiate title: 'Genesis', author_ids: [author.id] }
+  let(:existing_association) { existing_book.association(:authors) }
+
+  describe 'book#association' do
+    specify { expect(association).to be_a described_class }
+    specify { expect(association).to eq(book.association(:authors)) }
+  end
+
+  describe '#scope' do
+    specify { expect(association.scope).to be_a ActiveRecord::Relation }
+    specify { expect(association.scope).to respond_to(:where) }
+    specify { expect(association.scope).to respond_to(:name_starts_with_a) }
+  end
+
+  describe '#target' do
+    specify { expect(association.target).to eq([]) }
+    specify { expect(existing_association.target).to eq(existing_book.authors) }
+    specify { expect { association.concat author }.to change { association.target.count }.to(1) }
+  end
+
+  describe '#default' do
+    before { Book.references_many :authors, default: ->(book) { author.id } }
+    let(:existing_book) { Book.instantiate title: 'Genesis' }
+
+    specify { expect(association.target).to eq([author]) }
+    specify { expect { association.replace([other]) }.to change { association.target }.to([other]) }
+    specify { expect { association.replace([]) }.to change { association.target }.to eq([]) }
+
+    specify { expect(existing_association.target).to eq([]) }
+    specify { expect { existing_association.replace([other]) }.to change { existing_association.target }.to([other]) }
+    specify { expect { existing_association.replace([]) }.not_to change { existing_association.target } }
+  end
+
+  describe '#loaded?' do
+    specify { expect(association.loaded?).to eq(false) }
+    specify { expect { association.target }.to change { association.loaded? }.to(true) }
+    specify { expect { association.replace([]) }.to change { association.loaded? }.to(true) }
+    specify { expect { existing_association.replace([]) }.to change { existing_association.loaded? }.to(true) }
+  end
+
+  describe '#reload' do
+    specify { expect(association.reload).to eq([]) }
+
+    specify { expect(existing_association.reload).to eq(existing_book.authors) }
+
+    context do
+      before { existing_association.reader.last.name = 'Conan' }
+      specify { expect { existing_association.reload }
+        .to change { existing_association.reader.map(&:name) }
+        .from(['Conan']).to(['Rick']) }
+    end
+  end
+
+  describe '#reader' do
+    specify { expect(association.reader).to eq([]) }
+    specify { expect(association.reader).to be_a ActiveData::Model::Associations::Collection::Referenced }
+
+    specify { expect(existing_association.reader.first).to be_a Author }
+    specify { expect(existing_association.reader.first).to be_persisted }
+
+    context do
+      before { association.concat author }
+      specify { expect(association.reader.last).to be_a Author }
+      specify { expect(association.reader.size).to eq(1) }
+      specify { expect(association.reader(true)).to eq([author]) }
+    end
+
+    context do
+      before { existing_association.concat other }
+      specify { expect(existing_association.reader.size).to eq(2) }
+      specify { expect(existing_association.reader.last.name).to eq('Ben') }
+      specify { expect(existing_association.reader(true).size).to eq(2) }
+      specify { expect(existing_association.reader(true).last.name).to eq('Ben') }
+    end
+
+    context 'proxy missing method delection' do
+      specify { expect(existing_association.reader).to respond_to(:where) }
+      specify { expect(existing_association.reader).to respond_to(:name_starts_with_a) }
+    end
+  end
+
+  describe '#writer' do
+    let(:new_author1) { Author.create!(name: 'John') }
+    let(:new_author2) { Author.create!(name: 'Adam') }
+    let(:new_author3) { Author.new(name: 'Jane') }
+
+    specify { expect { association.writer([Dummy.new]) }
+      .to raise_error ActiveData::AssociationTypeMismatch }
+
+    specify { expect { association.writer(nil) }.to raise_error NoMethodError }
+    specify { expect { association.writer(new_author1) }.to raise_error NoMethodError }
+    specify { expect(association.writer([])).to eq([]) }
+
+    specify { expect(association.writer([new_author1])).to eq([new_author1]) }
+    specify { expect { association.writer([new_author1]) }
+      .to change { association.reader.map(&:name) }.from([]).to(['John']) }
+    specify { expect { association.writer([new_author1]) }
+      .to change { book.read_attribute(:author_ids) }
+      .from([]).to([new_author1.id]) }
+
+    specify { expect { existing_association.writer([new_author1, Dummy.new, new_author2]) }
+      .to raise_error ActiveData::AssociationTypeMismatch }
+    specify { expect { existing_association.writer([new_author1, Dummy.new, new_author2]) rescue nil }
+      .not_to change { existing_book.read_attribute(:author_ids) } }
+    specify { expect { existing_association.writer([new_author1, Dummy.new, new_author2]) rescue nil }
+      .not_to change { existing_association.reader } }
+
+    specify { expect { existing_association.writer(nil) }.to raise_error NoMethodError }
+    specify { expect { existing_association.writer(nil) rescue nil }
+      .not_to change { existing_book.read_attribute(:author_ids) } }
+    specify { expect { existing_association.writer(nil) rescue nil }
+      .not_to change { existing_association.reader } }
+
+    specify { expect(existing_association.writer([])).to eq([]) }
+    specify { expect { existing_association.writer([]) }
+      .to change { existing_book.read_attribute(:author_ids) }.to([]) }
+    specify { expect { existing_association.writer([]) }
+      .to change { existing_association.reader }.from([author]).to([]) }
+
+    specify { expect(existing_association.writer([new_author1, new_author2])).to eq([new_author1, new_author2]) }
+    specify { expect { existing_association.writer([new_author1, new_author2]) }
+      .to change { existing_association.reader.map(&:name) }
+      .from(['Rick']).to(['John', 'Adam']) }
+    specify { expect { existing_association.writer([new_author1, new_author2]) }
+      .to change { existing_book.read_attribute(:author_ids) }
+      .from([author.id]).to([new_author1.id, new_author2.id]) }
+
+    specify { expect { existing_association.writer([new_author3]) }
+      .to change { existing_association.target }.from([author]).to([new_author3]) }
+    specify { expect { existing_association.writer([new_author3]) }
+      .to change { existing_book.read_attribute(:author_ids) }
+      .from([author.id]).to([nil]) }
+  end
+
+  describe '#concat' do
+    let(:new_author1) { Author.create!(name: 'John') }
+    let(:new_author2) { Author.create!(name: 'Adam') }
+
+    specify { expect { association.concat(Dummy.new) }
+      .to raise_error ActiveData::AssociationTypeMismatch }
+
+    specify { expect { association.concat(nil) }.to raise_error ActiveData::AssociationTypeMismatch }
+    specify { expect(association.concat([])).to eq([]) }
+    specify { expect(existing_association.concat([])).to eq(existing_book.authors) }
+    specify { expect(existing_association.concat).to eq(existing_book.authors) }
+
+    specify { expect(association.concat(new_author1)).to eq([new_author1]) }
+    specify { expect { association.concat(new_author1) }
+      .to change { association.reader.map(&:name) }.from([]).to(['John']) }
+    specify { expect { association.concat(new_author1) }
+      .to change { book.read_attribute(:author_ids) }.from([]).to([1]) }
+
+    specify { expect { existing_association.concat(new_author1, Dummy.new, new_author2) }
+      .to raise_error ActiveData::AssociationTypeMismatch }
+    specify { expect { existing_association.concat(new_author1, Dummy.new, new_author2) rescue nil }
+      .to change { existing_book.read_attribute(:author_ids) }
+      .from([author.id]).to([author.id, new_author1.id]) }
+    specify { expect { existing_association.concat(new_author1, Dummy.new, new_author2) rescue nil }
+      .to change { existing_association.reader.map(&:name) }
+      .from(['Rick']).to(['Rick', 'John']) }
+
+    specify { expect(existing_association.concat(new_author1, new_author2))
+      .to eq([author, new_author1, new_author2]) }
+    specify { expect { existing_association.concat([new_author1, new_author2]) }
+      .to change { existing_association.reader.map(&:name) }
+      .from(['Rick']).to(['Rick', 'John', 'Adam']) }
+    specify { expect { existing_association.concat([new_author1, new_author2]) }
+      .to change { existing_book.read_attribute(:author_ids) }
+      .from([author.id]).to([author.id, new_author1.id, new_author2.id]) }
+  end
+end