granite-form 0.2.0 → 0.4.0

data/spec/granite/form/model/associations/reflections/embeds_many_spec.rb

@@ -3,7 +3,8 @@ require 'spec_helper'
 describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
   before do
     stub_model(:project) do
-      include Granite::Form::Model::Lifecycle
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Associations
       attribute :title, String
     end
     stub_model(:user) do
@@ -24,24 +25,28 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
         attribute :name
         embeds_many :projects,
           read: lambda { |reflection, object|
-            value = object.read_attribute(reflection.name)
+            value = object.instance_variable_get("@_value_#{reflection.name}")
             JSON.parse(value) if value.present?
           },
           write: lambda { |reflection, object, value|
-            object.write_attribute(reflection.name, value.to_json)
+            value = value.to_json if value
+            object.instance_variable_set("@_value_#{reflection.name}", value)
           }
       end
     end
 
-    let(:user) { User.instantiate name: 'Rick', projects: [{title: 'Genesis'}].to_json }
+    let(:user) { User.new }
     let(:new_project1) { Project.new(title: 'Project 1') }
     let(:new_project2) { Project.new(title: 'Project 2') }
 
     specify do
-      expect { user.projects.concat([new_project1, new_project2]) }
-        .to change { user.read_attribute(:projects) }
-        .from([{title: 'Genesis'}].to_json)
-        .to([{title: 'Genesis'}, {title: 'Project 1'}, {title: 'Project 2'}].to_json)
+      expect do
+        user.projects = [new_project1, new_project2]
+        user.association(:projects).sync
+      end
+        .to change { user.projects(true) }
+        .from([])
+        .to([have_attributes(title: 'Project 1'), have_attributes(title: 'Project 2')])
     end
   end
 
@@ -54,23 +59,10 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
       specify { expect { user.projects.build(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
     end
 
-    describe '#create' do
-      let(:project) { Project.new title: 'Project' }
-      specify { expect(user.projects.create(title: 'Project')).to eq(project) }
-      specify { expect { user.projects.create(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
-    end
-
-    describe '#create!' do
-      let(:project) { Project.new title: 'Project' }
-      specify { expect(user.projects.create!(title: 'Project')).to eq(project) }
-      specify { expect { user.projects.create!(title: 'Project') }.to change { user.projects }.from([]).to([project]) }
-    end
-
     describe '#reload' do
       let(:project) { Project.new title: 'Project' }
       before do
-        user.update(projects: [project])
-        user.apply_association_changes!
+        user.write_attribute(:projects, [{title: 'Project'}])
       end
       before { user.projects.build }
 
@@ -120,8 +112,8 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
       specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
       specify { expect(User.new.projects).to eq([]) }
-      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
-      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.read_attribute(:projects)).to eq([{'title' => 'Project'}]) }
+      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
+      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to match([have_attributes(title: 'Project')]) }
     end
 
     context do
@@ -138,8 +130,8 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsMany do
 
       specify { expect(User.reflect_on_association(:projects).klass).to eq(User::Project) }
       specify { expect(User.new.projects).to eq([]) }
-      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
-      specify { expect(User.new.tap { |u| u.projects.create(title: 'Project') }.read_attribute(:projects)).to eq([{'title' => 'Project', 'value' => nil}]) }
+      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to be_a(Granite::Form::Model::Associations::Collection::Embedded) }
+      specify { expect(User.new.tap { |u| u.projects.build(title: 'Project') }.projects).to match([have_attributes(title: 'Project', value: nil)]) }
     end
   end
 end

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

@@ -3,7 +3,8 @@ require 'spec_helper'
 describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
   before do
     stub_model(:author) do
-      include Granite::Form::Model::Lifecycle
+      include Granite::Form::Model::Persistence
+      include Granite::Form::Model::Associations
       attribute :name, String
     end
 
@@ -27,22 +28,26 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
         attribute :title
         embeds_one :author,
           read: lambda { |reflection, object|
-            value = object.read_attribute(reflection.name)
+            value = object.instance_variable_get("@_value_#{reflection.name}")
             JSON.parse(value) if value.present?
           },
           write: lambda { |reflection, object, value|
-            object.write_attribute(reflection.name, value ? value.to_json : nil)
+            value = value.to_json if value
+            object.instance_variable_set("@_value_#{reflection.name}", value)
           }
       end
     end
 
-    let(:book) { Book.instantiate author: {name: 'Duke'}.to_json }
+    let(:book) { Book.new }
     let(:author) { Author.new(name: 'Rick') }
 
     specify do
-      expect { book.author = author }
-        .to change { book.read_attribute(:author) }
-        .from({name: 'Duke'}.to_json).to({name: 'Rick'}.to_json)
+      expect do
+        book.author = author
+        book.association(:author).sync
+      end
+        .to change { book.author(true) }
+        .from(nil).to(have_attributes(name: 'Rick'))
     end
   end
 
@@ -65,18 +70,6 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
     specify { expect { book.build_author(name: 'Author') }.to change { book.author }.from(nil).to(author) }
   end
 
-  describe '#create_author' do
-    let(:author) { Author.new name: 'Author' }
-    specify { expect(book.create_author(name: 'Author')).to eq(author) }
-    specify { expect { book.create_author(name: 'Author') }.to change { book.author }.from(nil).to(author) }
-  end
-
-  describe '#create_author!' do
-    let(:author) { Author.new name: 'Author' }
-    specify { expect(book.create_author!(name: 'Author')).to eq(author) }
-    specify { expect { book.create_author!(name: 'Author') }.to change { book.author }.from(nil).to(author) }
-  end
-
   context 'on the fly' do
     context do
       before do
@@ -92,8 +85,8 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
 
       specify { expect(Book.reflect_on_association(:author).klass).to eq(Book::Author) }
       specify { expect(Book.new.author).to be_nil }
-      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.author).to be_a(Book::Author) }
-      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.read_attribute(:author)).to eq('name' => 'Author') }
+      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to be_a(Book::Author) }
+      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to have_attributes(name: 'Author') }
     end
 
     context do
@@ -110,8 +103,8 @@ describe Granite::Form::Model::Associations::Reflections::EmbedsOne do
 
       specify { expect(Book.reflect_on_association(:author).klass).to eq(Book::Author) }
       specify { expect(Book.new.author).to be_nil }
-      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.author).to be_a(Book::Author) }
-      specify { expect(Book.new.tap { |b| b.create_author(name: 'Author') }.read_attribute(:author)).to eq('name' => 'Author', 'age' => nil) }
+      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to be_a(Book::Author) }
+      specify { expect(Book.new.tap { |b| b.build_author(name: 'Author') }.author).to have_attributes(name: 'Author', age: nil) }
     end
   end
 end

data/spec/granite/form/model/associations/reflections/references_many_spec.rb

@@ -4,7 +4,7 @@ describe Granite::Form::Model::Associations::Reflections::ReferencesMany 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}%'") }
+      scope :name_starts_with, ->(letter) { where("name ILIKE '#{letter}%'") }
     end
 
     stub_model(:book) do

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

@@ -4,7 +4,7 @@ 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}%'") }
+      scope :name_starts_with, ->(letter) { where("name ILIKE '#{letter}%'") }
     end
 
     stub_model(:book) do
@@ -263,25 +263,4 @@ describe Granite::Form::Model::Associations::Reflections::ReferencesOne do
       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/granite/form/model/associations/validations_spec.rb

@@ -3,7 +3,6 @@ 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
 
@@ -17,8 +16,6 @@ describe Granite::Form::Model::Associations::Validations do
     end
 
     stub_model(:profile) do
-      include Granite::Form::Model::Lifecycle
-
       attribute :first_name, String
       attribute :last_name, String
       validates :first_name, presence: true

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

@@ -7,7 +7,7 @@ describe Granite::Form::Model::Associations do
         include Granite::Form::Model::Associations
       end
       stub_model(:project) do
-        include Granite::Form::Model::Lifecycle
+        include Granite::Form::Model::Persistence
       end
       stub_model(:user, Nobody) do
         include Granite::Form::Model::Associations
@@ -65,7 +65,7 @@ describe Granite::Form::Model::Associations do
   context do
     before do
       stub_model(:project) do
-        include Granite::Form::Model::Lifecycle
+        include Granite::Form::Model::Persistence
         include Granite::Form::Model::Associations
 
         attribute :title, String
@@ -80,7 +80,7 @@ describe Granite::Form::Model::Associations do
       end
 
       stub_model(:profile) do
-        include Granite::Form::Model::Lifecycle
+        include Granite::Form::Model::Persistence
 
         attribute :first_name, String
         attribute :last_name, String
@@ -160,27 +160,6 @@ describe Granite::Form::Model::Associations 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' }

data/spec/granite/form/model/attributes/attribute_spec.rb

@@ -46,8 +46,6 @@ describe Granite::Form::Model::Attributes::Attribute do
     specify { expect(attribute.default).to eq(nil) }
     specify { expect(attribute(default: 'hello').default).to eq('hello') }
     specify { expect(attribute(default: -> { value }).default).to eq(42) }
-    specify { expect(attribute(default: ->(object) { object.value }).default).to eq(42) }
-    specify { expect(attribute(default: ->(*args) { args.first.value }).default).to eq(42) }
   end
 
   describe '#defaultize' do
@@ -57,31 +55,6 @@ describe Granite::Form::Model::Attributes::Attribute do
     specify { expect(attribute(default: false, type: Boolean).defaultize(nil)).to eq(false) }
   end
 
-  describe '#enum' do
-    before { allow_any_instance_of(Dummy).to receive_messages(value: 1..5) }
-
-    specify { expect(attribute.enum).to eq([].to_set) }
-    specify { expect(attribute(enum: []).enum).to eq([].to_set) }
-    specify { expect(attribute(enum: 'hello').enum).to eq(['hello'].to_set) }
-    specify { expect(attribute(enum: %w[hello world]).enum).to eq(%w[hello world].to_set) }
-    specify { expect(attribute(enum: [1..5]).enum).to eq([1..5].to_set) }
-    specify { expect(attribute(enum: 1..5).enum).to eq((1..5).to_a.to_set) }
-    specify { expect(attribute(enum: -> { 1..5 }).enum).to eq((1..5).to_a.to_set) }
-    specify { expect(attribute(enum: -> { 'hello' }).enum).to eq(['hello'].to_set) }
-    specify { expect(attribute(enum: -> { ['hello', 42] }).enum).to eq(['hello', 42].to_set) }
-    specify { expect(attribute(enum: -> { value }).enum).to eq((1..5).to_a.to_set) }
-    specify { expect(attribute(enum: ->(object) { object.value }).enum).to eq((1..5).to_a.to_set) }
-  end
-
-  describe '#enumerize' do
-    specify { expect(attribute.enumerize('anything')).to eq('anything') }
-    specify { expect(attribute(enum: ['hello', 42]).enumerize('hello')).to eq('hello') }
-    specify { expect(attribute(enum: ['hello', 42]).enumerize('world')).to eq(nil) }
-    specify { expect(attribute(enum: -> { 'hello' }).enumerize('hello')).to eq('hello') }
-    specify { expect(attribute(enum: -> { 1..5 }).enumerize(2)).to eq(2) }
-    specify { expect(attribute(enum: -> { 1..5 }).enumerize(42)).to eq(nil) }
-  end
-
   describe '#normalize' do
     specify { expect(attribute.normalize(' hello ')).to eq(' hello ') }
     specify { expect(attribute(normalizer: ->(v) { v.strip }).normalize(' hello ')).to eq('hello') }
@@ -93,8 +66,6 @@ describe Granite::Form::Model::Attributes::Attribute do
       let(:other) { 'other' }
 
       specify { expect(attribute(normalizer: ->(_v) { value }).normalize(' hello ')).to eq('value') }
-      specify { expect(attribute(normalizer: ->(_v, object) { object.value }).normalize(' hello ')).to eq('value') }
-      specify { expect(attribute(normalizer: ->(_v, _object) { other }).normalize(' hello ')).to eq('other') }
     end
 
     context 'integration' do

data/spec/granite/form/model/attributes/reflections/attribute_spec.rb

@@ -43,15 +43,6 @@ describe Granite::Form::Model::Attributes::Reflections::Attribute do
     specify { expect(reflection(default: -> {}).defaultizer).to be_a Proc }
   end
 
-  describe '#enumerizer' do
-    specify { expect(reflection.enumerizer).to be_nil }
-    specify { expect(reflection(enum: 42).enumerizer).to eq(42) }
-    specify { expect(reflection(enum: -> {}).enumerizer).to be_a Proc }
-    specify { expect(reflection(in: 42).enumerizer).to eq(42) }
-    specify { expect(reflection(in: -> {}).enumerizer).to be_a Proc }
-    specify { expect(reflection(enum: 42, in: -> {}).enumerizer).to eq(42) }
-  end
-
   describe '#normalizers' do
     specify { expect(reflection.normalizers).to eq([]) }
     specify { expect(reflection(normalizer: -> {}).normalizers).to be_a Array }

data/spec/granite/form/model/attributes/reflections/base/build_type_definition_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Reflections::Base::BuildTypeDefinition do
+  def build_type_definition(**options)
+    @reflection = Granite::Form::Model::Attributes::Reflections::Base.new(:field, options)
+    described_class.new(owner, @reflection).call
+  end
+
+  def have_type(type)
+    have_attributes(type: type, reflection: @reflection, owner: owner)
+  end
+
+  before do
+    stub_class :owner
+    stub_class(:dummy, String)
+  end
+
+  let(:owner) { Owner.new }
+
+  specify { expect { build_type_definition }.to raise_error('Type is not specified for `field`') }
+  specify { expect(build_type_definition(type: String)).to have_type(String) }
+  specify { expect(build_type_definition(type: :string)).to have_type(String) }
+  specify { expect(build_type_definition(type: Dummy)).to have_type(Dummy) }
+  specify { expect { build_type_definition(type: :blabla) }.to raise_error NameError }
+end

data/spec/granite/form/model/attributes/reflections/base_spec.rb

@@ -30,6 +30,8 @@ describe Granite::Form::Model::Attributes::Reflections::Base do
   end
 
   describe '#build_attribute' do
+    subject { reflection.build_attribute(owner, nil) }
+
     before do
       stub_class('SomeScope::Borogoves', described_class)
       stub_class('Granite::Form::Model::Attributes::Borogoves', Granite::Form::Model::Attributes::Base)
@@ -39,18 +41,22 @@ describe Granite::Form::Model::Attributes::Reflections::Base do
     let(:reflection) { SomeScope::Borogoves.new(:field, type: Object) }
     let(:owner) { Owner.new }
 
-    specify { expect(reflection.build_attribute(owner, nil)).to be_a(Granite::Form::Model::Attributes::Borogoves) }
-    specify { expect(reflection.build_attribute(owner, nil).name).to eq('field') }
-    specify { expect(reflection.build_attribute(owner, nil).owner).to eq(owner) }
+    it { is_expected.to be_a(Granite::Form::Model::Attributes::Borogoves) }
+    it { is_expected.to have_attributes(reflection: reflection, owner: owner, type: Object) }
   end
 
-  describe '#type' do
-    before { stub_class(:dummy, String) }
+  describe '#enum' do
+    specify { expect(reflection.enum).to be_nil }
+    specify { expect(reflection(enum: 42).enum).to eq(42) }
+    specify { expect(reflection(enum: -> {}).enum).to be_a Proc }
+    specify { expect(reflection(in: 42).enum).to eq(42) }
+    specify { expect(reflection(in: -> {}).enum).to be_a Proc }
+    specify { expect(reflection(enum: 42, in: -> {}).enum).to eq(42) }
+  end
 
-    specify { expect { reflection.type }.to raise_error('Type is not specified for `field`') }
-    specify { expect(reflection(type: String).type).to eq(String) }
-    specify { expect(reflection(type: :string).type).to eq(String) }
-    specify { expect(reflection(type: Dummy).type).to eq(Dummy) }
-    specify { expect { reflection(type: :blabla).type }.to raise_error NameError }
+  describe '#keys' do
+    specify { expect(reflection.keys).to eq([]) }
+    specify { expect(reflection(keys: ['a', :b]).keys).to eq(%w[a b]) }
+    specify { expect(reflection(keys: :c).keys).to eq(%w[c]) }
   end
 end

data/spec/granite/form/model/attributes/reflections/collection/build_type_definition_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Reflections::Collection::BuildTypeDefinition do
+  def build_type_definition(name = :name, **options)
+    @reflection = Granite::Form::Model::Attributes::Reflections::Collection.new(name, options)
+    described_class.new(owner, @reflection).call
+  end
+
+  def have_collection_type(type)
+    subtype_definition = have_attributes(type: type, reflection: @reflection, owner: owner)
+    have_attributes(subtype_definition: subtype_definition)
+  end
+
+  before do
+    stub_class :owner
+    stub_class(:dummy, String)
+  end
+
+  let(:owner) { Owner.new }
+
+  it { expect(build_type_definition(type: String)).to have_collection_type(String) }
+end

data/spec/granite/form/model/attributes/reflections/dictionary/build_type_definition_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Reflections::Dictionary::BuildTypeDefinition do
+  def build_type_definition(name = :name, **options)
+    @reflection = Granite::Form::Model::Attributes::Reflections::Dictionary.new(name, options)
+    described_class.new(owner, @reflection).call
+  end
+
+  def have_dictionary_type(type)
+    subtype_definition = have_attributes(type: type, reflection: @reflection, owner: owner)
+    have_attributes(subtype_definition: subtype_definition)
+  end
+
+  before do
+    stub_class :owner
+    stub_class(:dummy, String)
+  end
+
+  let(:owner) { Owner.new }
+
+  it { expect(build_type_definition(type: String)).to have_dictionary_type(String) }
+end

data/spec/granite/form/model/attributes/reflections/dictionary_spec.rb

@@ -34,10 +34,4 @@ describe Granite::Form::Model::Attributes::Reflections::Dictionary do
       expect(Target).to be_method_defined(:field_alias_values)
     end
   end
-
-  describe '#keys' do
-    specify { expect(reflection.keys).to eq([]) }
-    specify { expect(reflection(keys: ['a', :b]).keys).to eq(%w[a b]) }
-    specify { expect(reflection(keys: :c).keys).to eq(%w[c]) }
-  end
 end

data/spec/granite/form/model/attributes/reflections/represents/build_type_definition_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Granite::Form::Model::Attributes::Reflections::Represents::BuildTypeDefinition do
+  def build_type_definition(name = :name, **options)
+    @reflection = Granite::Form::Model::Attributes::Reflections::Represents.new(name, options.reverse_merge(of: :author))
+    described_class.new(owner, @reflection).call
+  end
+
+  def have_type(type)
+    have_attributes(type: type, reflection: @reflection, owner: owner)
+  end
+
+  let(:owner) { Owner.new }
+
+  before do
+    stub_model :author
+    stub_model(:owner) do
+      def author
+        @author ||= Author.new
+      end
+    end
+  end
+
+  it { expect(build_type_definition).to have_type(Object) }
+  it { expect(build_type_definition(type: String)).to have_type(String) }
+
+  context 'when defined in attribute' do
+    before { Author.attribute :name, String }
+
+    it { expect(build_type_definition).to have_type(String) }
+    it { expect(build_type_definition(type: Integer)).to have_type(Integer) }
+  end
+
+  context 'when defined in represented attribute' do
+    before do
+      stub_model(:real_author) do
+        attribute :name, Boolean
+      end
+      Author.class_eval do
+        include Granite::Form::Model::Representation
+        represents :name, of: :subject
+
+        def subject
+          @subject ||= RealAuthor.new
+        end
+      end
+    end
+
+    it { expect(build_type_definition).to have_type(Boolean) }
+  end
+
+  context 'when defined in references_many' do
+    before do
+      stub_class(:user, ActiveRecord::Base)
+      Author.class_eval do
+        include Granite::Form::Model::Associations
+        references_many :users
+      end
+    end
+
+    it do
+      attribute = build_type_definition(:user_ids)
+      expect(attribute).to be_a(Granite::Form::Types::Collection)
+      expect(attribute.subtype_definition).to have_type(Integer)
+    end
+  end
+
+  context 'when defined in collection' do
+    before do
+      Author.collection :users, String
+    end
+
+    it do
+      attribute = build_type_definition(:users)
+      expect(attribute).to be_a(Granite::Form::Types::Collection)
+      expect(attribute.subtype_definition).to have_type(String)
+    end
+  end
+
+  context 'when defined in dictionary' do
+    before do
+      Author.dictionary :numbers, Float
+    end
+
+    it do
+      attribute = build_type_definition(:numbers)
+      expect(attribute).to be_a(Granite::Form::Types::Dictionary)
+      expect(attribute.subtype_definition).to have_type(Float)
+    end
+  end
+
+  context 'when defined in ActiveRecord::Base' do
+    before do
+      stub_class(:author, ActiveRecord::Base) do
+        alias_attribute :full_name, :name
+      end
+    end
+
+    it { expect(build_type_definition).to have_type(String) }
+    it { expect(build_type_definition(:status)).to have_type(Integer) }
+    it { expect(build_type_definition(:full_name)).to have_type(String) }
+    it { expect(build_type_definition(:unknown_attribute)).to have_type(Object) }
+    it do
+      attribute = build_type_definition(:related_ids)
+      expect(attribute).to be_a(Granite::Form::Types::Collection)
+      expect(attribute.subtype_definition).to have_type(Integer)
+    end
+
+    context 'with enum' do
+      before do
+        if ActiveRecord.gem_version >= Gem::Version.new('7.0')
+          Author.enum :status, once: 1, many: 2
+        else
+          Author.enum status: %i[once many]
+        end
+      end
+
+      it { expect(build_type_definition(:status)).to have_type(String) }
+    end
+
+    context 'with serialized attribute' do
+      before { Author.serialize :data }
+
+      it { expect(build_type_definition(:data)).to have_type(Object) }
+    end
+  end
+end