granite-form 0.1.0

data/spec/lib/granite/form/model/associations/embeds_one_spec.rb

@@ -0,0 +1,533 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Associations::EmbedsOne do
+  before do
+    stub_model(:author) do
+      include Granite::Form::Model::Lifecycle
+
+      attribute :name, String
+      validates :name, presence: true
+    end
+
+    stub_model(:book) do
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Associations
+
+      attribute :title, String
+      embeds_one :author
+    end
+  end
+
+  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 do
+      expect { association.build(name: 'Fred') }
+        .not_to change { book.read_attribute(:author) }
+    end
+
+    specify do
+      expect { existing_association.build(name: 'Fred') }
+        .not_to change { existing_book.read_attribute(:author) }
+    end
+  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 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 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 Granite::Form::ValidationError }
+    specify do
+      expect { muffle(Granite::Form::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 do
+      expect { muffle(Granite::Form::ValidationError) { association.create! } }
+        .not_to change { book.read_attribute(:author) }
+    end
+    specify do
+      expect { muffle(Granite::Form::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(Granite::Form::ValidationError) { existing_association.create! } }
+        .not_to change { existing_book.read_attribute(:author) }
+    end
+    specify do
+      expect { muffle(Granite::Form::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 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 do
+      association.build
+      expect { association.apply_changes! }
+        .to raise_error Granite::Form::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
+    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 Granite::Form::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, Granite::Form::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 { association.build(name: 'Fred') }
+      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 do
+        expect { existing_association.reload }
+          .to change { existing_association.reader.try(:attributes) }
+          .from('name' => 'Fred').to('name' => 'Johny')
+      end
+    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 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, Granite::Form::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 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
+
+  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 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 do
+        expect { association.writer(invalid_author) }
+          .to raise_error Granite::Form::AssociationChangesNotApplied
+      end
+      specify do
+        expect { muffle(Granite::Form::AssociationChangesNotApplied) { association.writer(invalid_author) } }
+          .not_to change { association.reader }
+      end
+      specify do
+        expect { muffle(Granite::Form::AssociationChangesNotApplied) { association.writer(invalid_author) } }
+          .not_to change { book.read_attribute(:author) }
+      end
+    end
+
+    context 'persisted owner' do
+      specify do
+        expect { association.writer(stub_model(:dummy).new) }
+          .to raise_error Granite::Form::AssociationTypeMismatch
+      end
+
+      specify { expect(association.writer(nil)).to be_nil }
+      specify { expect(association.writer(new_author)).to eq(new_author) }
+      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(Granite::Form::AssociationTypeMismatch) { existing_association.writer(stub_model(:dummy).new) } }
+          .not_to change { existing_book.read_attribute(:author) }
+      end
+      specify do
+        expect { muffle(Granite::Form::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 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 Granite::Form::AssociationChangesNotApplied
+      end
+      specify do
+        expect { muffle(Granite::Form::AssociationChangesNotApplied) { existing_association.writer(invalid_author) } }
+          .not_to change { existing_association.reader }
+      end
+      specify do
+        expect { muffle(Granite::Form::AssociationChangesNotApplied) { existing_association.writer(invalid_author) } }
+          .not_to change { existing_book.read_attribute(:author) }
+      end
+    end
+  end
+end

data/spec/lib/granite/form/model/associations/nested_attributes_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'shared/nested_attribute_examples'
+
+describe Granite::Form::Model::Associations::NestedAttributes do
+  context '' do
+    before do
+      stub_model :user do
+        include Granite::Form::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
+
+  xcontext 'references_one' do
+    before do
+      stub_class(:author, ActiveRecord::Base)
+      stub_class(:user, ActiveRecord::Base)
+
+      stub_model :book do
+        include Granite::Form::Model::Associations
+
+        references_one :author
+        references_many :users
+
+        accepts_nested_attributes_for :author, :users
+      end
+    end
+
+    context 'references_one' do
+      let(:book) { Book.new }
+
+      specify { expect { book.author_attributes = {} }.to change { book.author }.to(an_instance_of(Author)) }
+      specify { expect { book.author_attributes = {name: 'Author'} }.to change { book.author.try(:name) }.to('Author') }
+      specify { expect { book.author_attributes = {id: 42, name: 'Author'} }.to raise_error Granite::Form::ObjectNotFound }
+
+      context ':reject_if' do
+        context do
+          before { Book.accepts_nested_attributes_for :author, reject_if: :all_blank }
+          specify { expect { book.author_attributes = {name: ''} }.not_to change { book.author } }
+        end
+
+        context do
+          before { Book.accepts_nested_attributes_for :author, reject_if: ->(attributes) { attributes['name'].blank? } }
+          specify { expect { book.author_attributes = {name: ''} }.not_to change { book.author } }
+        end
+      end
+
+      context 'existing' do
+        let(:author) { Author.new(name: 'Author') }
+        let(:book) { Book.new author: author }
+
+        specify { expect { book.author_attributes = {id: 42, name: 'Author'} }.to raise_error Granite::Form::ObjectNotFound }
+        specify { expect { book.author_attributes = {id: author.id.to_s, name: 'Author 1'} }.to change { book.author.name }.to('Author 1') }
+        specify { expect { book.author_attributes = {name: 'Author 1'} }.to change { book.author.name }.to('Author 1') }
+        specify { expect { book.author_attributes = {name: 'Author 1', _destroy: '1'} }.not_to change { book.author.name } }
+        specify do
+          expect do
+            book.author_attributes = {name: 'Author 1', _destroy: '1'}
+            book.save { true }
+          end.not_to change { book.author.name }
+        end
+        specify { expect { book.author_attributes = {id: author.id.to_s, name: 'Author 1', _destroy: '1'} }.to change { book.author.name }.to('Author 1') }
+        specify do
+          expect do
+            book.author_attributes = {id: author.id.to_s, name: 'Author 1', _destroy: '1'}
+            book.save { true }
+          end.to change { book.author.name }.to('Author 1')
+        end
+
+        context ':allow_destroy' do
+          before { Book.accepts_nested_attributes_for :author, allow_destroy: true }
+
+          specify { expect { book.author_attributes = {name: 'Author 1', _destroy: '1'} }.not_to change { book.author.name } }
+          specify do
+            expect do
+              book.author_attributes = {name: 'Author 1', _destroy: '1'}
+              book.save { true }
+            end.not_to change { book.author.name }
+          end
+          specify { expect { book.author_attributes = {id: author.id.to_s, name: 'Author 1', _destroy: '1'} }.to change { book.author.name }.to('Author 1') }
+          specify do
+            expect do
+              book.author_attributes = {id: author.id.to_s, name: 'Author 1', _destroy: '1'}
+              book.save { true }
+            end.to change { book.author }.to(nil)
+          end
+        end
+
+        context ':update_only' do
+          before { Book.accepts_nested_attributes_for :author, update_only: true }
+
+          specify do
+            expect { book.author_attributes = {id: 42, name: 'Author 1'} }
+              .to change { book.author.name }.to('Author 1')
+          end
+        end
+      end
+    end
+
+    context 'references_many' do
+      let(:book) { Book.new }
+    end
+  end
+
+  describe '#assign_attributes' do
+    specify 'invent a good example'
+  end
+end

data/spec/lib/granite/form/model/associations/persistence_adapters/active_record_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Associations::PersistenceAdapters::ActiveRecord do
+  before do
+    stub_class(:author, ActiveRecord::Base)
+  end
+
+  subject(:adapter) { described_class.new(Author, primary_key, scope_proc) }
+  let(:primary_key) { :id }
+  let(:scope_proc) { nil }
+
+  describe '#build' do
+    subject { adapter.build(name: name) }
+    let(:name) { 'John Doe' }
+
+    its(:name) { should == name }
+    it { is_expected.to be_a Author }
+  end
+
+  describe '#find_one' do
+    subject { adapter.find_one(nil, author.id) }
+    let(:author) { Author.create }
+
+    it { should == author }
+  end
+
+  describe '#find_all' do
+    subject { adapter.find_all(nil, authors.map(&:id)) }
+    let(:authors) { Array.new(2) { Author.create } }
+
+    it { should == authors }
+  end
+
+  describe '#scope' do
+    subject { adapter.scope(owner, source) }
+    let(:authors) { ['John Doe', 'Sam Smith', 'John Smith'].map { |name| Author.create(name: name) } }
+    let(:source) { authors[0..1].map(&:id) }
+    let(:owner) { nil }
+
+    it { is_expected.to be_a ActiveRecord::Relation }
+
+    context 'without scope_proc' do
+      it { should == Author.where(primary_key => source) }
+    end
+
+    context 'with scope_proc' do
+      let(:scope_proc) { -> { where("name LIKE 'John%'") } }
+
+      its(:to_a) { should == [Author.first] }
+    end
+  end
+
+  describe '#primary_key_type' do
+    subject { adapter.primary_key_type }
+
+    it { should == Integer }
+  end
+end