granite-form 0.3.0 → 0.4.0

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

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

@@ -6,32 +6,55 @@ describe Granite::Form::Model::Attributes::Reflections::Represents do
   end
 
   describe '.build' do
-    before { stub_class(:target) }
+    def build_reflection(column = :name, **options)
+      described_class.build(Target, Target, column, of: :subject, **options)
+    end
 
-    specify do
-      described_class.build(Class.new, Target, :field, of: :subject)
+    before do
+      stub_model(:author) do
+        attribute :name, String
+        attribute :age, Integer
+      end
 
-      expect(Target).to be_method_defined(:field)
-      expect(Target).to be_method_defined(:field=)
-      expect(Target).to be_method_defined(:field?)
-      expect(Target).to be_method_defined(:field_before_type_cast)
-      expect(Target).to be_method_defined(:field_default)
-      expect(Target).to be_method_defined(:field_values)
+      stub_model(:target) do
+        attribute :author, Author
+        alias_attribute :subject, :author
+      end
     end
-  end
 
-  describe '.generate_methods' do
-    before { stub_class(:target) }
+    let(:instance) { Target.new attributes }
+    let(:attributes) { {subject: Author.new} }
+    let!(:reflection) { build_reflection }
+
+    it { expect(reflection.reference).to eq('author') }
+
+    it do
+      expect(Target).to be_method_defined(:name)
+      expect(Target).to be_method_defined(:name=)
+      expect(Target).to be_method_defined(:name?)
+      expect(Target).to be_method_defined(:name_before_type_cast)
+      expect(Target).to be_method_defined(:name_default)
+      expect(Target).to be_method_defined(:name_values)
+    end
+
+    it { expect(instance).to be_valid }
+
+    context 'with missing `of` attribute value' do
+      let(:attributes) { super().except(:subject) }
+
+      it { expect { instance.validate }.to change { instance.errors.messages }.to(author: ["can't be blank"]) }
+
+      context 'with multiple reflections' do
+        before { build_reflection(:age) }
+
+        it { expect { instance.validate }.to change { instance.errors.messages }.to(author: ["can't be blank"]) }
+      end
 
-    specify do
-      described_class.generate_methods(:field_alias, Target)
+      context 'when validate_reference is false' do
+        let(:reflection) { build_reflection(validate_reference: false) }
 
-      expect(Target).to be_method_defined(:field_alias)
-      expect(Target).to be_method_defined(:field_alias=)
-      expect(Target).to be_method_defined(:field_alias?)
-      expect(Target).to be_method_defined(:field_alias_before_type_cast)
-      expect(Target).to be_method_defined(:field_alias_default)
-      expect(Target).to be_method_defined(:field_alias_values)
+        it { expect { instance.validate }.not_to change { instance.errors.messages } }
+      end
     end
   end
 

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

@@ -1,85 +1,108 @@
 require 'spec_helper'
 
 describe Granite::Form::Model::Attributes::Represents do
-  before { stub_model(:dummy) }
-
-  def attribute(*args)
-    options = args.extract_options!
-    Dummy.add_attribute(Granite::Form::Model::Attributes::Reflections::Represents, :full_name, options.reverse_merge(of: :subject))
-    Dummy.new.attribute(:full_name)
-  end
-
   before do
-    stub_model :subject do
-      attribute :full_name, String
+    stub_model :author
+    stub_model(:model) do
+      def author
+        @author ||= Author.new
+      end
     end
   end
 
-  describe '#new' do
-    before { attribute(:full_name) }
+  let(:model) { Model.new }
+  let(:attribute) { add_attribute }
+
+  def add_attribute(*args)
+    options = args.extract_options!.reverse_merge(of: :author)
+    name = args.first || :name
+    reflection = Model.add_attribute(Granite::Form::Model::Attributes::Reflections::Represents, name, options)
+    model.attribute(reflection.name)
+  end
+
+  describe '#initialize' do
+    before { Author.attribute :name, String, default: 'Default Name' }
+
     let(:attributes) { {foo: 'bar'} }
 
-    specify { expect { Dummy.new(attributes) }.to_not change { attributes } }
+    it { expect { Model.new(attributes) }.to_not change { attributes } }
+
+    it { expect(attribute.read).to eq('Default Name') }
+    it { expect(attribute.read_before_type_cast).to eq('Default Name') }
+
+    it { expect(add_attribute(default: -> { 'Field Default' }).read).to eq('Default Name') }
+
+    context 'when owner changes value after initialize' do
+      before do
+        attribute
+        model.author.name = 'Changed Name'
+      end
+
+      it { expect(attribute.read).to eq('Default Name') }
+      it { expect(attribute.read_before_type_cast).to eq('Default Name') }
+    end
   end
 
-  describe '#write' do
-    subject { Subject.new }
-    before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
-    let(:field) { attribute }
+  describe '#sync' do
+    before do
+      Author.attribute :name, String
+      attribute.write('New name')
+    end
+
+    it { expect { attribute.sync }.to change { model.author.name }.from(nil).to('New name') }
+
+    context 'when represented object does not respond to attribute name' do
+      let(:attribute) { add_attribute(:unknown_attribute) }
 
-    specify { expect { field.write('hello') }.to change { subject.full_name }.to('hello') }
+      it { expect { attribute.sync }.not_to raise_error }
+    end
   end
 
-  describe '#read' do
-    subject { Subject.new(full_name: :hello) }
-    before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
-    let(:field) { attribute(normalizer: ->(v) { v && v.is_a?(String) ? v.strip : v }, default: :world, enum: ['hello', '42', 'world', :world]) }
+  describe '#changed?' do
+    before { Author.attribute :name, Boolean }
 
-    specify { expect(field.read).to eq('hello') }
-    specify { expect(field.tap { |r| r.write(nil) }.read).to eq(:world) }
-    specify { expect(field.tap { |r| r.write(:world) }.read).to eq('world') }
-    specify { expect(field.tap { |r| r.write('hello') }.read).to eq('hello') }
-    specify { expect(field.tap { |r| r.write(' hello ') }.read).to eq(nil) }
-    specify { expect(field.tap { |r| r.write(42) }.read).to eq('42') }
-    specify { expect(field.tap { |r| r.write(43) }.read).to eq(nil) }
-    specify { expect(field.tap { |r| r.write('') }.read).to eq(nil) }
+    specify do
+      expect(model).to receive(:name_changed?)
+      expect(attribute).not_to be_changed
+    end
 
-    specify { expect { subject.full_name = 42 }.to change { field.read }.to('42') }
+    context 'when attribute has default value' do
+      let(:attribute) { add_attribute default: -> { true } }
 
-    context ':readonly' do
-      specify { expect(attribute(readonly: true).tap { |r| r.write('string') }.read).to eq('hello') }
+      specify do
+        expect(model).not_to receive(:name_changed?)
+        expect(attribute).to be_changed
+      end
     end
 
-    context do
-      subject { Subject.new }
-      let(:field) { attribute(default: -> { Time.now.to_f }) }
-      specify { expect { sleep(0.01) }.not_to change { field.read } }
+    context 'when attribute has false as default value' do
+      let(:attribute) { add_attribute default: false }
+
+      specify do
+        expect(model).not_to receive(:name_changed?)
+        expect(attribute).to be_changed
+      end
     end
   end
 
-  describe '#read_before_type_cast' do
-    subject { Subject.new(full_name: :hello) }
-    before { allow_any_instance_of(Dummy).to receive_messages(value: 42, subject: subject) }
-    let(:field) { attribute(normalizer: ->(v) { v.strip }, default: :world, enum: %w[hello 42 world]) }
+  describe 'typecasting' do
+    before { Author.attribute :name, String }
 
-    specify { expect(field.read_before_type_cast).to eq(:hello) }
-    specify { expect(field.tap { |r| r.write(nil) }.read_before_type_cast).to eq(:world) }
-    specify { expect(field.tap { |r| r.write(:world) }.read_before_type_cast).to eq(:world) }
-    specify { expect(field.tap { |r| r.write('hello') }.read_before_type_cast).to eq('hello') }
-    specify { expect(field.tap { |r| r.write(42) }.read_before_type_cast).to eq(42) }
-    specify { expect(field.tap { |r| r.write(43) }.read_before_type_cast).to eq(43) }
-    specify { expect(field.tap { |r| r.write('') }.read_before_type_cast).to eq('') }
+    def typecast(value)
+      attribute.write(value)
+      attribute.read
+    end
 
-    specify { expect { subject.full_name = 42 }.to change { field.read_before_type_cast }.to(42) }
+    it 'returns original value when it has right class' do
+      expect(typecast('1')).to eq '1'
+    end
 
-    context ':readonly' do
-      specify { expect(attribute(readonly: true).tap { |r| r.write('string') }.read_before_type_cast).to eq(:hello) }
+    it 'returns converted value to a proper type' do
+      expect(typecast(1)).to eq '1'
     end
 
-    context do
-      subject { Subject.new }
-      let(:field) { attribute(default: -> { Time.now.to_f }) }
-      specify { expect { sleep(0.01) }.not_to change { field.read_before_type_cast } }
+    it 'ignores nil' do
+      expect(typecast(nil)).to be_nil
     end
   end
 end

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

@@ -4,15 +4,11 @@ describe Granite::Form::Model::Attributes do
   let(:model) do
     stub_model do
       include Granite::Form::Model::Associations
-      include Granite::Form::Model::Localization
 
       attribute :id, Integer
       attribute :full_name, String
       alias_attribute :name, :full_name
 
-      localized :t, String
-      alias_attribute :title, :t
-
       embeds_one(:author) {}
       embeds_many(:projects) {}
     end
@@ -34,8 +30,8 @@ describe Granite::Form::Model::Attributes do
 
   describe '.attribute_names' do
     specify { expect(stub_model.attribute_names).to eq([]) }
-    specify { expect(model.attribute_names).to eq(%w[id full_name t author projects]) }
-    specify { expect(model.attribute_names(false)).to eq(%w[id full_name t]) }
+    specify { expect(model.attribute_names).to eq(%w[id full_name author projects]) }
+    specify { expect(model.attribute_names(false)).to eq(%w[id full_name]) }
   end
 
   describe '.inspect' do
@@ -100,8 +96,8 @@ describe Granite::Form::Model::Attributes do
 
   describe '#attribute_names' do
     specify { expect(stub_model.new.attribute_names).to eq([]) }
-    specify { expect(model.new.attribute_names).to eq(%w[id full_name t author projects]) }
-    specify { expect(model.new.attribute_names(false)).to eq(%w[id full_name t]) }
+    specify { expect(model.new.attribute_names).to eq(%w[id full_name author projects]) }
+    specify { expect(model.new.attribute_names(false)).to eq(%w[id full_name]) }
   end
 
   describe '#attribute_present?' do
@@ -114,11 +110,11 @@ describe Granite::Form::Model::Attributes do
     specify { expect(stub_model.new.attributes).to eq({}) }
     specify do
       expect(model.new(name: 'Name').attributes)
-        .to match('id' => nil, 'full_name' => 'Name', 't' => {}, 'author' => nil, 'projects' => nil)
+        .to match('id' => nil, 'full_name' => 'Name', 'author' => nil, 'projects' => nil)
     end
     specify do
       expect(model.new(name: 'Name').attributes(false))
-        .to match('id' => nil, 'full_name' => 'Name', 't' => {})
+        .to match('id' => nil, 'full_name' => 'Name')
     end
   end
 
@@ -198,6 +194,35 @@ describe Granite::Form::Model::Attributes do
     end
   end
 
+  describe '#sync_attributes' do
+    before do
+      stub_class :author, ActiveRecord::Base do
+        alias_attribute :full_name, :name
+      end
+
+      stub_model :model do
+        include Granite::Form::Model::Dirty
+        include Granite::Form::Model::Representation
+
+        attribute :age, Integer
+        attribute :author, Author
+        represents :name, :full_name, of: :author
+      end
+    end
+
+    let(:author) { Author.new }
+    let(:model) { Model.new(attributes) }
+    let(:attributes) { {author: author, name: 'Author Name', full_name: nil, age: 25} }
+
+    it { expect { model.sync_attributes }.to change(author, :name).to('Author Name') }
+
+    context 'with aliased attribute' do
+      let(:attributes) { super().merge(name: nil, full_name: 'Name Alias') }
+
+      it { expect { model.sync_attributes }.to change(author, :name).to('Name Alias') }
+    end
+  end
+
   describe '#inspect' do
     specify { expect(stub_model.new.inspect).to match(/#<#<Class:0x\w+> \(no attributes\)>/) }
     specify { expect(stub_model(:user).new.inspect).to match(/#<User \(no attributes\)>/) }
@@ -218,19 +243,24 @@ describe Granite::Form::Model::Attributes do
   context 'attributes integration' do
     let(:model) do
       stub_class do
+        include Granite::Form::Util
         include Granite::Form::Model::Attributes
         include Granite::Form::Model::Associations
         attr_accessor :name
 
         attribute :id, Integer
         attribute :hello, Object
-        attribute :string, String, default: ->(record) { record.name }
+        attribute :string, String, default: -> { name }
         attribute :count, Integer, default: '10'
         attribute(:calc, Integer) { 2 + 3 }
         attribute :enum, Integer, enum: [1, 2, 3]
         attribute :enum_with_default, Integer, enum: [1, 2, 3], default: '2'
         attribute :foo, Boolean, default: false
-        collection :array, Integer, enum: [1, 2, 3], default: 7
+        collection :array, Integer, enum: [1, 2, 3], default: [2], normalizer: ->(v) { v.uniq }
+        dictionary :dict, Integer, keys: %w[from to], enum: [1, 2, 3], default: {from: 1}, normalizer: proc { |v|
+          next v if v[:from].nil? || v[:to].nil? || v[:from] <= v[:to]
+          {from: v[:to], to: v[:from]}.with_indifferent_access
+        }
 
         def initialize(name = nil)
           super()
@@ -286,23 +316,54 @@ describe Granite::Form::Model::Attributes do
       end
     end
 
-    context 'array' do
-      specify do
-        subject.array = [2, 4]
-        expect(subject.array).to eq([2, nil])
+    describe 'array' do
+      def with_assigned_value(value)
+        subject.array = value
+        expect(subject)
       end
+
       specify do
-        subject.array = [2, 4]
-        expect(subject.array?).to eq(true)
+        expect(subject).to have_attributes(
+          array: [2],
+          array_before_type_cast: [2],
+          array?: true,
+          array_default: [2],
+          array_values: [1, 2, 3]
+        )
       end
-      specify do
-        subject.array = [2, 4]
-        expect(subject.array_values).to eq([1, 2, 3])
+
+      specify { with_assigned_value(nil).to have_attributes(array: [2], array_before_type_cast: [2]) }
+      specify { with_assigned_value([nil]).to have_attributes(array: [nil], array_before_type_cast: [nil]) }
+      specify { with_assigned_value(1).to have_attributes(array: [1], array_before_type_cast: 1) }
+      specify { with_assigned_value([1, 2]).to have_attributes(array: [1, 2], array_before_type_cast: [1, 2]) }
+      specify { with_assigned_value([2, 4]).to have_attributes(array: [2, nil], array_before_type_cast: [2, 4]) }
+      specify { with_assigned_value(%w[1 2]).to have_attributes(array: [1, 2], array_before_type_cast: %w[1 2]) }
+      specify { with_assigned_value([1, 2, 1]).to have_attributes(array: [1, 2], array_before_type_cast: [1, 2, 1]) }
+    end
+
+    describe 'dict' do
+      def with_assigned_value(value)
+        subject.dict = value
+        expect(subject)
       end
+
       specify do
-        subject.array = [2, 4]
-        expect(subject.array_default).to eq(7)
+        expect(subject).to have_attributes(
+          dict: {from: 1},
+          dict_before_type_cast: {from: 1},
+          dict?: true,
+          dict_default: {from: 1},
+          dict_values: [1, 2, 3]
+        )
       end
+
+      specify { with_assigned_value(nil).to have_attributes(dict: {'from' => 1}, dict_before_type_cast: {from: 1}) }
+      specify { with_assigned_value([nil]).to have_attributes(dict: {}, dict_before_type_cast: [nil]) }
+      specify { with_assigned_value(1).to have_attributes(dict: {}, dict_before_type_cast: 1) }
+      specify { with_assigned_value(from: 1, to: 2).to have_attributes(dict: {'from' => 1, 'to' => 2}, dict_before_type_cast: {from: 1, to: 2}) }
+      specify { with_assigned_value(from: 2, to: 4).to have_attributes(dict: {'from' => 2, 'to' => nil}, dict_before_type_cast: {from: 2, to: 4}) }
+      specify { with_assigned_value(from: '1', to: '2').to have_attributes(dict: {'from' => 1, 'to' => 2}, dict_before_type_cast: {from: '1', to: '2'}) }
+      specify { with_assigned_value(from: 3, to: 1).to have_attributes(dict: {'from' => 1, 'to' => 3}, dict_before_type_cast: {from: 3, to: 1}) }
     end
 
     context 'attribute caching' do

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

@@ -5,7 +5,6 @@ describe Granite::Form::Model::Dirty do
     stub_class(:author, ActiveRecord::Base) {}
     stub_model :premodel do
       include Granite::Form::Model::Persistence
-      include Granite::Form::Model::Localization
       include Granite::Form::Model::Associations
 
       attribute :age, Integer, default: 33
@@ -22,7 +21,6 @@ describe Granite::Form::Model::Dirty do
       attribute :name, String
       alias_attribute :n, :name
       collection :numbers, Integer
-      localized :title, String
     end
   end
 
@@ -70,10 +68,6 @@ describe Granite::Form::Model::Dirty do
   specify { expect(Model.new(a: '42').tap { |m| m.update(a: '43') }.changes).to eq('age' => [33, 43]) }
   specify { expect(Model.new(numbers: '42').changes).to eq('numbers' => [[], [42]]) }
 
-  # Have no idea how should it work right now
-  specify { expect(Model.new(title: 'Hello').changes).to eq('title' => [nil, 'Hello']) }
-  specify { expect(Model.new(title_translations: {en: 'Hello'}).changes).to eq('title' => [nil, 'Hello']) }
-
   specify { expect(Model.new).not_to respond_to :something_changed? }
   specify { expect(Model.new).to respond_to :n_changed? }
 

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

@@ -23,15 +23,12 @@ describe Granite::Form::Model::Representation do
     specify { expect(Post.new(author: author).rate).to eq(42) }
     specify { expect(Post.new(author: author).rate_before_type_cast).to eq('42') }
     specify { expect(Post.new(rate: '33', author: author).rate).to eq(33) }
-    specify { expect(Post.new(rate: '33', author: author).author.rate).to eq(33) }
     specify { expect(Post.new(r: '33', author: author).rate).to eq(33) }
-    specify { expect(Post.new(r: '33', author: author).author.rate).to eq(33) }
     specify { expect(Post.new(author: author).rate?).to eq(true) }
     specify { expect(Post.new(rate: nil, author: author).rate?).to eq(false) }
 
     specify { expect(Post.new.rate).to be_nil }
     specify { expect(Post.new.rate_before_type_cast).to be_nil }
-    specify { expect { Post.new(rate: '33') }.to raise_error(NoMethodError) }
 
     context 'ActionController::Parameters' do
       let(:params) { instance_double('ActionController::Parameters', to_unsafe_hash: {rate: '33', author: author}) }
@@ -48,12 +45,13 @@ describe Granite::Form::Model::Representation do
         expect(Post.new(author: author, rate: '33').changes)
           .to eq('author' => [nil, author], 'rate' => [42, 33])
 
+        author.rate = 33
         expect(Post.new(author: author, rate: '33').changes)
           .to eq('author' => [nil, author])
       end
     end
 
-    context do
+    context 'when represents references_one association' do
       before do
         stub_class(:author, ActiveRecord::Base)
 
@@ -71,7 +69,6 @@ describe Granite::Form::Model::Representation do
       specify { expect(Post.reflect_on_attribute(:name).reference).to eq('author') }
 
       specify { expect(Post.new(name: '33', author: author).name).to eq('33') }
-      specify { expect(Post.new(name: '33', author: author).author.name).to eq('33') }
     end
 
     context 'multiple attributes in a single represents definition' do
@@ -89,11 +86,11 @@ describe Granite::Form::Model::Representation do
         end
       end
 
-      let(:author) { Author.new(first_name: 'John', last_name: 'Doe') }
+      let(:author) { Author.new }
       let(:post) { Post.new }
 
       specify do
-        expect { post.update(author: author) }
+        expect { post.update(first_name: 'John', last_name: 'Doe') }
           .to change { post.first_name }.to('John')
           .and change { post.last_name }.to('Doe')
       end

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

@@ -1,10 +1,37 @@
 require 'spec_helper'
 
 describe Granite::Form::Model::Validations do
+  let!(:add_validations) { model.validates :name, presence: true }
+
   let(:model) do
     stub_model(:model) do
       attribute :name, String
-      validates :name, presence: true
+    end
+  end
+
+  before { add_validations }
+
+  describe '.validates_nested?' do
+    subject { model.validates_presence?(:name) }
+
+    it { is_expected.to be_truthy }
+
+    context 'when using string name' do
+      subject { model.validates_presence?('name') }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when attribute has no validations' do
+      let(:add_validations) {}
+
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when attribute has different validations' do
+      let(:add_validations) { model.validates :name, length: {maximum: 100} }
+
+      it { is_expected.to be_falsey }
     end
   end