granite-form 0.1.0

data/spec/lib/granite/form/model/associations/reflections/references_one_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Associations::Reflections::ReferencesOne do
+  before do
+    stub_class(:author, ActiveRecord::Base) do
+      scope :name_starts_with_a, -> { name_starts_with('a') }
+      scope :name_starts_with, ->(letter) { where("name LIKE '#{letter}%'") }
+    end
+
+    stub_model(:book) do
+      include Granite::Form::Model::Associations
+
+      attribute :title, String
+      references_one :author
+    end
+  end
+  let(:book) { Book.new }
+
+  specify { expect(book.author).to be_nil }
+
+  context ':class_name' do
+    before do
+      stub_model(:book) do
+        include Granite::Form::Model::Associations
+
+        attribute :title, String
+        references_one :creator, class_name: 'Author'
+      end
+    end
+    let(:author) { Author.create!(name: 'Rick') }
+
+    specify do
+      expect { book.creator = author }
+        .to change { book.creator }.from(nil).to(author)
+    end
+    specify do
+      expect { book.creator = author }
+        .to change { book.creator_id }.from(nil).to(author.id)
+    end
+  end
+
+  describe ':primary_key' do
+    before do
+      stub_model(:book) do
+        include Granite::Form::Model::Associations
+        attribute :author_name, String
+        references_one :author, primary_key: 'name'
+      end
+    end
+
+    let(:author) { Author.create!(name: 'Rick') }
+
+    specify do
+      expect { book.author_name = author.name }
+        .to change { book.author }.from(nil).to(author)
+    end
+    specify do
+      expect { book.author = author }
+        .to change { book.author_name }.from(nil).to(author.name)
+    end
+  end
+
+  describe ':reference_key' do
+    before do
+      stub_model(:book) do
+        include Granite::Form::Model::Associations
+        references_one :author, reference_key: 'identify'
+      end
+    end
+
+    let(:author) { Author.create!(name: 'Rick') }
+
+    specify do
+      expect { book.identify = author.id }
+        .to change { book.author }.from(nil).to(author)
+    end
+    specify do
+      expect { book.author = author }
+        .to change { book.identify }.from(nil).to(author.id)
+    end
+  end
+
+  describe ':default' do
+    shared_examples_for :persisted_default do |default|
+      before do
+        stub_model(:book) do
+          include Granite::Form::Model::Associations
+          references_one :author
+          references_one :owner, class_name: 'Author', default: default
+        end
+      end
+
+      let(:author) { Author.create! }
+      let(:other) { Author.create! }
+      let(:book) { Book.new(author: author) }
+
+      specify { expect(book.owner_id).to eq(author.id) }
+      specify { expect(book.owner).to eq(author) }
+      specify { expect { book.owner = other }.to change { book.owner_id }.from(author.id).to(other.id) }
+      specify { expect { book.owner = other }.to change { book.owner }.from(author).to(other) }
+      specify { expect { book.owner_id = other.id }.to change { book.owner_id }.from(author.id).to(other.id) }
+      specify { expect { book.owner_id = other.id }.to change { book.owner }.from(author).to(other) }
+      specify { expect { book.owner = nil }.to change { book.owner_id }.from(author.id).to(nil) }
+      specify { expect { book.owner = nil }.to change { book.owner }.from(author).to(nil) }
+      specify { expect { book.owner_id = nil }.not_to change { book.owner_id }.from(author.id) }
+      specify { expect { book.owner_id = nil }.not_to change { book.owner }.from(author) }
+      specify { expect { book.owner_id = '' }.to change { book.owner_id }.from(author.id).to(nil) }
+      specify { expect { book.owner_id = '' }.to change { book.owner }.from(author).to(nil) }
+    end
+
+    it_behaves_like :persisted_default, -> { author.id }
+    it_behaves_like :persisted_default, -> { author }
+
+    shared_examples_for :new_record_default do |default|
+      before do
+        stub_model(:book) do
+          include Granite::Form::Model::Associations
+          references_one :author
+          references_one :owner, class_name: 'Author', default: default
+        end
+      end
+
+      let(:other) { Author.create! }
+      let(:book) { Book.new }
+
+      specify { expect(book.owner_id).to be_nil }
+      specify { expect(book.owner).to be_a(Author).and have_attributes(name: 'Author') }
+      specify { expect { book.owner = other }.to change { book.owner_id }.from(nil).to(other.id) }
+      specify { expect { book.owner = other }.to change { book.owner }.from(instance_of(Author)).to(other) }
+      specify { expect { book.owner_id = other.id }.to change { book.owner_id }.from(nil).to(other.id) }
+      specify { expect { book.owner_id = other.id }.to change { book.owner }.from(instance_of(Author)).to(other) }
+      specify { expect { book.owner = nil }.not_to change { book.owner_id }.from(nil) }
+      specify { expect { book.owner = nil }.to change { book.owner }.from(instance_of(Author)).to(nil) }
+      specify { expect { book.owner_id = nil }.not_to change { book.owner_id }.from(nil) }
+      specify { expect { book.owner_id = nil }.not_to change { book.owner }.from(instance_of(Author)) }
+      specify { expect { book.owner_id = '' }.not_to change { book.owner_id }.from(nil) }
+      specify { expect { book.owner_id = '' }.to change { book.owner }.from(instance_of(Author)).to(nil) }
+    end
+
+    it_behaves_like :new_record_default, name: 'Author'
+    it_behaves_like :new_record_default, -> { Author.new(name: 'Author') }
+  end
+
+  describe 'Book.inspect' do
+    specify { expect(Book.inspect).to eq('Book(author: ReferencesOne(Author), title: String, author_id: (reference))') }
+  end
+
+  describe '#scope' do
+    before do
+      stub_model(:book) do
+        include Granite::Form::Model::Associations
+        references_one :author, ->(owner) { name_starts_with(owner.letter) }
+        attribute :letter, String
+      end
+    end
+
+    let(:book) { Book.new(letter: 'a') }
+    let!(:author1) { Author.create!(name: 'Rick') }
+    let!(:author2) { Author.create!(name: 'Aaron') }
+
+    specify do
+      expect { book.author_id = author1.id }
+        .not_to change { book.author }
+    end
+    specify do
+      expect { book.author_id = author2.id }
+        .to change { book.author }.from(nil).to(author2)
+    end
+
+    specify do
+      expect { book.author = author1 }
+        .to change { book.author_id }.from(nil).to(author1.id)
+    end
+    specify do
+      expect { book.author = author2 }
+        .to change { book.author_id }.from(nil).to(author2.id)
+    end
+
+    specify do
+      expect { book.author = author1 }
+        .to change {
+          book.association(:author).reload
+          book.author_id
+        }.from(nil).to(author1.id)
+    end
+    specify do
+      expect { book.author = author2 }
+        .to change {
+          book.association(:author).reload
+          book.author_id
+        }.from(nil).to(author2.id)
+    end
+
+    specify do
+      expect { book.author = author1 }
+        .not_to change {
+          book.association(:author).reload
+          book.author
+        }
+    end
+    specify do
+      expect { book.author = author2 }
+        .to change {
+          book.association(:author).reload
+          book.author
+        }.from(nil).to(author2)
+    end
+
+    context do
+      let(:book2) { Book.new(letter: 'r') }
+
+      specify 'scope is not cached too much' do
+        expect { book.author_id = author2.id }
+          .to change { book.author }.from(nil).to(author2)
+        expect { book2.author_id = author1.id }
+          .to change { book2.author }.from(nil).to(author1)
+      end
+    end
+  end
+
+  describe '#author=' do
+    let(:author) { Author.create! name: 'Author' }
+    specify { expect { book.author = author }.to change { book.author }.from(nil).to(author) }
+    specify { expect { book.author = 'string' }.to raise_error Granite::Form::AssociationTypeMismatch }
+
+    context do
+      let(:other) { Author.create! name: 'Other' }
+      before { book.author = other }
+      specify { expect { book.author = author }.to change { book.author }.from(other).to(author) }
+      specify { expect { book.author = author }.to change { book.author_id }.from(other.id).to(author.id) }
+      specify { expect { book.author = nil }.to change { book.author }.from(other).to(nil) }
+      specify { expect { book.author = nil }.to change { book.author_id }.from(other.id).to(nil) }
+    end
+
+    context 'model not persisted' do
+      let(:author) { Author.new }
+      specify { expect { book.author = author }.to change { book.author }.from(nil).to(author) }
+      specify { expect { book.author = author }.not_to change { book.author_id }.from(nil) }
+
+      context do
+        before { book.author = author }
+        specify { expect { author.save! }.to change { book.author_id }.from(nil).to(be_a(Integer)) }
+        specify { expect { author.save! }.not_to change { book.author } }
+      end
+    end
+  end
+
+  describe '#author_id=' do
+    let(:author) { Author.create!(name: 'Author') }
+    specify { expect { book.author_id = author.id }.to change { book.author_id }.from(nil).to(author.id) }
+    specify { expect { book.author_id = author.id }.to change { book.author }.from(nil).to(author) }
+    specify { expect { book.author_id = author }.to change { book.author }.from(nil).to(author) }
+
+    specify { expect { book.author_id = author.id.next.to_s }.to change { book.author_id }.from(nil).to(author.id.next) }
+    specify { expect { book.author_id = author.id.next.to_s }.not_to change { book.author }.from(nil) }
+
+    context do
+      let(:other) { Author.create!(name: 'Other') }
+      before { book.author = other }
+      specify { expect { book.author_id = author.id }.to change { book.author_id }.from(other.id).to(author.id) }
+      specify { expect { book.author_id = author.id }.to change { book.author }.from(other).to(author) }
+      specify { expect { book.author_id = nil }.to change { book.author_id }.from(other.id).to(nil) }
+      specify { expect { book.author_id = nil }.to change { book.author }.from(other).to(nil) }
+    end
+  end
+
+  describe '#build_author' do
+    specify { expect(book.build_author(name: 'Author')).to be_a(Author) }
+    specify { expect(book.build_author(name: 'Author')).not_to be_persisted }
+    specify { expect { book.build_author(name: 'Author') }.to change { book.author }.from(nil).to(an_instance_of(Author)) }
+    specify { expect { book.build_author(name: 'Author') }.not_to change { book.author_id }.from(nil) }
+  end
+
+  describe '#create_author' do
+    specify { expect(book.create_author(name: 'Author')).to be_a(Author) }
+    specify { expect(book.create_author(name: 'Author')).to be_persisted }
+    specify { expect { book.create_author(name: 'Author') }.to change { book.author }.from(nil).to(an_instance_of(Author)) }
+    specify { expect { book.create_author(name: 'Author') }.to change { book.author_id }.from(nil).to(be_a(Integer)) }
+  end
+
+  describe '#create_author!' do
+    specify { expect(book.create_author!(name: 'Author')).to be_a(Author) }
+    specify { expect(book.create_author!(name: 'Author')).to be_persisted }
+    specify { expect { book.create_author!(name: 'Author') }.to change { book.author }.from(nil).to(an_instance_of(Author)) }
+    specify { expect { book.create_author!(name: 'Author') }.to change { book.author_id }.from(nil).to(be_a(Integer)) }
+  end
+end

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

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Associations::Validations do
+  before do
+    stub_model(:project) do
+      include Granite::Form::Model::Lifecycle
+      include Granite::Form::Model::Associations
+      include Granite::Form::Model::Associations::Validations
+
+      attribute :title, String
+      validates :title, presence: true
+
+      embeds_one :author do
+        attribute :name, String
+        validates :name, presence: true
+      end
+    end
+
+    stub_model(:profile) do
+      include Granite::Form::Model::Lifecycle
+
+      attribute :first_name, String
+      attribute :last_name, String
+      validates :first_name, presence: true
+    end
+
+    stub_model(:user) do
+      include Granite::Form::Model::Associations
+      include Granite::Form::Model::Associations::Validations
+
+      attribute :login, String
+      validates :login, presence: true
+
+      embeds_one :profile, validate: false
+      embeds_many :projects
+    end
+  end
+
+  describe '#validate' do
+    let(:profile) { Profile.new first_name: 'Name' }
+    let(:project) { Project.new title: 'Project' }
+    let(:projects) { [project] }
+    let(:user) { User.new(login: 'Login', profile: profile, projects: projects) }
+    let(:author_attributes) { {name: 'Author'} }
+    before { project.build_author(author_attributes) }
+
+    specify { expect(user.validate).to eq(true) }
+    specify { expect { user.validate }.not_to change { user.errors.messages } }
+
+    context do
+      let(:author_attributes) { {} }
+
+      specify { expect(user.validate).to eq(false) }
+      specify do
+        expect { user.validate }.to change { user.errors.messages }
+          .to('projects.0.author.name': ["can't be blank"])
+      end
+    end
+
+    context do
+      let(:profile) { Profile.new }
+
+      specify { expect(user.validate).to eq(true) }
+      specify { expect { user.validate }.not_to change { user.errors.messages } }
+    end
+
+    context do
+      let(:projects) { [project, Project.new] }
+
+      specify { expect(user.validate).to eq(false) }
+      specify do
+        expect { user.validate }.to change { user.errors.messages }
+          .to('projects.1.title': ["can't be blank"])
+      end
+    end
+  end
+
+  describe '#validate_ancestry, #valid_ancestry?, #invalid_ancestry?' do
+    let(:profile) { Profile.new first_name: 'Name' }
+    let(:project) { Project.new title: 'Project' }
+    let(:projects) { [project] }
+    let(:user) { User.new(login: 'Login', profile: profile, projects: projects) }
+    let(:author_attributes) { {name: 'Author'} }
+    before { project.build_author(author_attributes) }
+
+    specify { expect(user.validate_ancestry).to eq(true) }
+    specify { expect(user.validate_ancestry!).to eq(true) }
+    specify { expect { user.validate_ancestry! }.not_to raise_error }
+    specify { expect(user.valid_ancestry?).to eq(true) }
+    specify { expect(user.invalid_ancestry?).to eq(false) }
+    specify { expect { user.validate_ancestry }.not_to change { user.errors.messages } }
+
+    context do
+      let(:author_attributes) { {} }
+      specify { expect(user.validate_ancestry).to eq(false) }
+      specify { expect { user.validate_ancestry! }.to raise_error Granite::Form::ValidationError }
+      specify { expect(user.valid_ancestry?).to eq(false) }
+      specify { expect(user.invalid_ancestry?).to eq(true) }
+      specify do
+        expect { user.validate_ancestry }.to change { user.errors.messages }
+          .to('projects.0.author.name': ["can't be blank"])
+      end
+    end
+
+    context do
+      let(:profile) { Profile.new }
+      specify { expect(user.validate_ancestry).to eq(false) }
+      specify { expect { user.validate_ancestry! }.to raise_error Granite::Form::ValidationError }
+      specify { expect(user.valid_ancestry?).to eq(false) }
+      specify { expect(user.invalid_ancestry?).to eq(true) }
+      specify do
+        expect { user.validate_ancestry }.to change { user.errors.messages }
+          .to('profile.first_name': ["can't be blank"])
+      end
+    end
+
+    context do
+      let(:projects) { [project, Project.new] }
+      specify { expect(user.validate_ancestry).to eq(false) }
+      specify { expect { user.validate_ancestry! }.to raise_error Granite::Form::ValidationError }
+      specify { expect(user.valid_ancestry?).to eq(false) }
+      specify { expect(user.invalid_ancestry?).to eq(true) }
+      specify do
+        expect { user.validate_ancestry }.to change { user.errors.messages }
+          .to('projects.1.title': ["can't be blank"])
+      end
+
+      context do
+        before { user.update(login: '') }
+        specify do
+          expect { user.validate_ancestry }.to change { user.errors.messages }
+            .to('projects.1.title': ["can't be blank"], login: ["can't be blank"])
+        end
+      end
+    end
+  end
+end

data/spec/lib/granite/form/model/associations_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+describe Granite::Form::Model::Associations do
+  context do
+    before do
+      stub_model(:nobody) do
+        include Granite::Form::Model::Associations
+      end
+      stub_model(:project) do
+        include Granite::Form::Model::Lifecycle
+      end
+      stub_model(:user, Nobody) do
+        include Granite::Form::Model::Associations
+        embeds_many :projects
+      end
+      stub_model(:manager, Nobody) do
+        include Granite::Form::Model::Associations
+        embeds_one :managed_project, class_name: 'Project'
+      end
+      stub_model(:admin, User) do
+        include Granite::Form::Model::Associations
+        embeds_many :admin_projects, class_name: 'Project'
+
+        alias_association :own_projects, :admin_projects
+      end
+    end
+
+    describe '#reflections' do
+      specify { expect(Nobody.reflections.keys).to eq([]) }
+      specify { expect(User.reflections.keys).to eq([:projects]) }
+      specify { expect(Manager.reflections.keys).to eq([:managed_project]) }
+      specify { expect(Admin.reflections.keys).to eq(%i[projects admin_projects]) }
+    end
+
+    describe '#reflect_on_association' do
+      specify { expect(Nobody.reflect_on_association(:blabla)).to be_nil }
+      specify { expect(Admin.reflect_on_association('projects')).to be_a Granite::Form::Model::Associations::Reflections::EmbedsMany }
+      specify { expect(Admin.reflect_on_association('own_projects').name).to eq(:admin_projects) }
+      specify { expect(Manager.reflect_on_association(:managed_project)).to be_a Granite::Form::Model::Associations::Reflections::EmbedsOne }
+    end
+  end
+
+  context 'class determine errors' do
+    specify do
+      expect do
+        stub_model do
+          include Granite::Form::Model::Associations
+
+          embeds_one :author, class_name: 'Borogoves'
+        end.reflect_on_association(:author).data_source end.to raise_error NameError
+    end
+
+    specify do
+      expect do
+        stub_model(:user) do
+          include Granite::Form::Model::Associations
+
+          embeds_many :projects, class_name: 'Borogoves' do
+            attribute :title
+          end
+        end.reflect_on_association(:projects).data_source end.to raise_error NameError
+    end
+  end
+
+  context do
+    before do
+      stub_model(:project) do
+        include Granite::Form::Model::Lifecycle
+        include Granite::Form::Model::Associations
+
+        attribute :title, String
+
+        validates :title, presence: true
+
+        embeds_one :author do
+          attribute :name, String
+
+          validates :name, presence: true
+        end
+      end
+
+      stub_model(:profile) do
+        include Granite::Form::Model::Lifecycle
+
+        attribute :first_name, String
+        attribute :last_name, String
+
+        validates :first_name, presence: true
+      end
+
+      stub_model(:user) do
+        include Granite::Form::Model::Associations
+
+        attribute :login, Object
+
+        validates :login, presence: true
+
+        embeds_one :profile
+        embeds_many :projects
+
+        alias_association :my_profile, :profile
+      end
+    end
+
+    let(:user) { User.new }
+
+    specify { expect(user.projects).to eq([]) }
+    specify { expect(user.profile).to be_nil }
+
+    describe '.inspect' do
+      specify { expect(User.inspect).to eq('User(profile: EmbedsOne(Profile), projects: EmbedsMany(Project), login: Object)') }
+    end
+
+    describe '.association_names' do
+      specify { expect(User.association_names).to eq(%i[profile projects]) }
+    end
+
+    describe '#inspect' do
+      let(:profile) { Profile.new first_name: 'Name' }
+      let(:project) { Project.new title: 'Project' }
+      specify do
+        expect(User.new(login: 'Login', profile: profile, projects: [project]).inspect)
+          .to eq('#<User profile: #<EmbedsOne #<Profile first_name: "Name", last_name: nil>>, projects: #<EmbedsMany [#<Project author: #<EmbedsOne nil>, title: "P...]>, login: "Login">')
+      end
+    end
+
+    describe '#==' do
+      let(:project) { Project.new title: 'Project' }
+      let(:other) { Project.new title: 'Other' }
+
+      specify { expect(User.new(projects: [project])).to eq(User.new(projects: [project])) }
+      specify { expect(User.new(projects: [project])).not_to eq(User.new(projects: [other])) }
+      specify { expect(User.new(projects: [project])).not_to eq(User.new) }
+
+      specify { expect(User.new(projects: [project])).to eql(User.new(projects: [project])) }
+      specify { expect(User.new(projects: [project])).not_to eql(User.new(projects: [other])) }
+      specify { expect(User.new(projects: [project])).not_to eql(User.new) }
+
+      context do
+        before { User.send(:include, Granite::Form::Model::Primary) }
+        let(:user) { User.new(projects: [project]) }
+
+        specify { expect(user).to eq(user.clone.tap { |b| b.projects(author: project) }) }
+        specify { expect(user).to eq(user.clone.tap { |b| b.projects(author: other) }) }
+
+        specify { expect(user).to eql(user.clone.tap { |b| b.projects(author: project) }) }
+        specify { expect(user).to eql(user.clone.tap { |b| b.projects(author: other) }) }
+      end
+    end
+
+    describe '#association' do
+      specify { expect(user.association(:projects)).to be_a(Granite::Form::Model::Associations::EmbedsMany) }
+      specify { expect(user.association(:profile)).to be_a(Granite::Form::Model::Associations::EmbedsOne) }
+      specify { expect(user.association(:blabla)).to be_nil }
+      specify { expect(user.association('my_profile').reflection.name).to eq(:profile) }
+      specify { expect(user.association('my_profile')).to equal(user.association(:profile)) }
+    end
+
+    describe '#association_names' do
+      specify { expect(user.association_names).to eq(%i[profile projects]) }
+    end
+
+    describe '#apply_association_changes!' do
+      let(:profile) { Profile.new first_name: 'Name' }
+      let(:project) { Project.new title: 'Project' }
+      let(:user) { User.new(profile: profile, projects: [project]) }
+      before { project.build_author(name: 'Author') }
+
+      specify do
+        expect { user.apply_association_changes! }.to change { user.attributes['profile'] }
+          .from(nil).to('first_name' => 'Name', 'last_name' => nil)
+      end
+      specify do
+        expect { user.apply_association_changes! }.to change { user.attributes['projects'] }
+          .from(nil).to([{'title' => 'Project', 'author' => {'name' => 'Author'}}])
+      end
+
+      context do
+        let(:project) { Project.new }
+        specify { expect { user.apply_association_changes! }.to raise_error Granite::Form::AssociationChangesNotApplied }
+      end
+    end
+
+    describe '#instantiate' do
+      before { User.send(:include, Granite::Form::Model::Persistence) }
+      let(:profile) { Profile.new first_name: 'Name' }
+      let(:project) { Project.new title: 'Project' }
+      let(:user) { User.new(profile: profile, projects: [project]) }
+      before { project.build_author(name: 'Author') }
+
+      specify { expect(User.instantiate(JSON.parse(user.to_json))).to eq(user) }
+      specify do
+        expect(User.instantiate(JSON.parse(user.to_json))
+        .tap { |u| u.projects.first.author.name = 'Other' }).not_to eq(user)
+      end
+    end
+  end
+end