formtastic 3.1.2 → 4.0.0

data/spec/helpers/reflection_helper_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe 'Formtastic::Helpers::Reflection' do
+RSpec.describe 'Formtastic::Helpers::Reflection' do
 
   include FormtasticSpecHelper
 
@@ -20,11 +20,11 @@ describe 'Formtastic::Helpers::Reflection' do
   context 'with an ActiveRecord object' do
     it "should return association details on an ActiveRecord association" do
       @reflection_tester = ReflectionTester.new(@new_post)
-      @reflection_tester.reflection_for(:sub_posts).should_not be_nil
+      expect(@reflection_tester.reflection_for(:sub_posts)).not_to be_nil
     end
     it "should return association details on a MongoMapper association" do
       @reflection_tester = ReflectionTester.new(@new_mm_post)
-      @reflection_tester.reflection_for(:sub_posts).should_not be_nil
+      expect(@reflection_tester.reflection_for(:sub_posts)).not_to be_nil
     end
   end
   

data/spec/helpers/semantic_errors_helper_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe 'Formtastic::FormBuilder#semantic_errors' do
+RSpec.describe 'Formtastic::FormBuilder#semantic_errors' do
 
   include FormtasticSpecHelper
 
@@ -12,31 +12,31 @@ describe 'Formtastic::FormBuilder#semantic_errors' do
     @base_errors = ['base error message', 'nasty error']
     @base_error = 'one base error'
     @errors = double('errors')
-    @new_post.stub(:errors).and_return(@errors)
+    allow(@new_post).to receive(:errors).and_return(@errors)
   end
 
   describe 'when there is only one error on base' do
     before do
-      @errors.stub(:[]).with(errors_matcher(:base)).and_return(@base_error)
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
     end
 
     it 'should render an unordered list' do
       semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors.should have_tag('ul.errors li', @base_error)
+        expect(builder.semantic_errors).to have_tag('ul.errors li', :text => @base_error)
       end
     end
   end
 
   describe 'when there is more than one error on base' do
     before do
-      @errors.stub(:[]).with(errors_matcher(:base)).and_return(@base_errors)
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_errors)
     end
 
     it 'should render an unordered list' do
       semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors.should have_tag('ul.errors')
+        expect(builder.semantic_errors).to have_tag('ul.errors')
         @base_errors.each do |error|
-          builder.semantic_errors.should have_tag('ul.errors li', error)
+          expect(builder.semantic_errors).to have_tag('ul.errors li', :text => error)
         end
       end
     end
@@ -44,67 +44,67 @@ describe 'Formtastic::FormBuilder#semantic_errors' do
 
   describe 'when there are errors on title' do
     before do
-      @errors.stub(:[]).with(errors_matcher(:title)).and_return(@title_errors)
-      @errors.stub(:[]).with(errors_matcher(:base)).and_return([])
+      allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return(@title_errors)
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return([])
     end
 
     it 'should render an unordered list' do
       semantic_form_for(@new_post) do |builder|
         title_name = builder.send(:localized_string, :title, :title, :label) || builder.send(:humanized_attribute_name, :title)
-        builder.semantic_errors(:title).should have_tag('ul.errors li', title_name << " " << @title_errors.to_sentence)
+        expect(builder.semantic_errors(:title)).to have_tag('ul.errors li', :text => title_name << " " << @title_errors.to_sentence)
       end
     end
   end
 
   describe 'when there are errors on title and base' do
     before do
-      @errors.stub(:[]).with(errors_matcher(:title)).and_return(@title_errors)
-      @errors.stub(:[]).with(errors_matcher(:base)).and_return(@base_error)
+      allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return(@title_errors)
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
     end
 
     it 'should render an unordered list' do
       semantic_form_for(@new_post) do |builder|
         title_name = builder.send(:localized_string, :title, :title, :label) || builder.send(:humanized_attribute_name, :title)
-        builder.semantic_errors(:title).should have_tag('ul.errors li', title_name << " " << @title_errors.to_sentence)
-        builder.semantic_errors(:title).should have_tag('ul.errors li', @base_error)
+        expect(builder.semantic_errors(:title)).to have_tag('ul.errors li', :text => title_name << " " << @title_errors.to_sentence)
+        expect(builder.semantic_errors(:title)).to have_tag('ul.errors li', :text => @base_error)
       end
     end
   end
 
   describe 'when there are no errors' do
     before do
-      @errors.stub(:[]).with(errors_matcher(:title)).and_return(nil)
-      @errors.stub(:[]).with(errors_matcher(:base)).and_return(nil)
+      allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return(nil)
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(nil)
     end
 
     it 'should return nil' do
       semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors(:title).should be_nil
+        expect(builder.semantic_errors(:title)).to be_nil
       end
     end
   end
 
   describe 'when there is one error on base and options with class is passed' do
     before do
-      @errors.stub(:[]).with(errors_matcher(:base)).and_return(@base_error)
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
     end
 
     it 'should render an unordered list with given class' do
       semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors(:class => "awesome").should have_tag('ul.awesome li', @base_error)
+        expect(builder.semantic_errors(:class => "awesome")).to have_tag('ul.awesome li', :text => @base_error)
       end
     end
   end
   
   describe 'when :base is passed in as an argument' do
     before do
-      @errors.stub(:[]).with(errors_matcher(:base)).and_return(@base_error)
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
     end
 
     it 'should ignore :base and only render base errors once' do
       semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors(:base).should have_tag('ul li', :count => 1)
-        builder.semantic_errors(:base).should_not have_tag('ul li', "Base #{@base_error}")
+        expect(builder.semantic_errors(:base)).to have_tag('ul li', :count => 1)
+        expect(builder.semantic_errors(:base)).not_to have_tag('ul li', :text => "Base #{@base_error}")
       end
     end
   end

data/spec/i18n_spec.rb

@@ -1,22 +1,22 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe 'Formtastic::I18n' do
+RSpec.describe 'Formtastic::I18n' do
 
   FORMTASTIC_KEYS = [:required, :yes, :no, :create, :update].freeze
 
   it "should be defined" do
-    lambda { Formtastic::I18n }.should_not raise_error
+    expect { Formtastic::I18n }.not_to raise_error
   end
 
   describe "default translations" do
     it "should be defined" do
-      lambda { Formtastic::I18n::DEFAULT_VALUES }.should_not raise_error
-      Formtastic::I18n::DEFAULT_VALUES.is_a?(::Hash).should == true
+      expect { Formtastic::I18n::DEFAULT_VALUES }.not_to raise_error
+      expect(Formtastic::I18n::DEFAULT_VALUES.is_a?(::Hash)).to eq(true)
     end
 
     it "should exists for the core I18n lookup keys" do
-      (Formtastic::I18n::DEFAULT_VALUES.keys & FORMTASTIC_KEYS).size.should == FORMTASTIC_KEYS.size
+      expect((Formtastic::I18n::DEFAULT_VALUES.keys & FORMTASTIC_KEYS).size).to eq(FORMTASTIC_KEYS.size)
     end
   end
 
@@ -42,23 +42,23 @@ describe 'Formtastic::I18n' do
 
     it "should translate core strings correctly" do
       ::I18n.backend.store_translations :en, {:formtastic => {:required => 'Default Required'}}
-      Formtastic::I18n.t(:required).should  == "Default Required"
-      Formtastic::I18n.t(:yes).should       == "Default Yes"
-      Formtastic::I18n.t(:no).should        == "Default No"
-      Formtastic::I18n.t(:create, :model => 'Post').should == "Default Create Post"
-      Formtastic::I18n.t(:update, :model => 'Post').should == "Default Update Post"
+      expect(Formtastic::I18n.t(:required)).to  eq("Default Required")
+      expect(Formtastic::I18n.t(:yes)).to       eq("Default Yes")
+      expect(Formtastic::I18n.t(:no)).to        eq("Default No")
+      expect(Formtastic::I18n.t(:create, :model => 'Post')).to eq("Default Create Post")
+      expect(Formtastic::I18n.t(:update, :model => 'Post')).to eq("Default Update Post")
     end
 
     it "should all belong to scope 'formtastic'" do
-      Formtastic::I18n.t(:duck, :scope => [:custom_scope]).should == 'Duck'
+      expect(Formtastic::I18n.t(:duck, :scope => [:custom_scope])).to eq('Duck')
     end
 
     it "should override default I18n lookup args if these are specified" do
-      Formtastic::I18n.t(:duck_pond, :scope => [:custom_scope], :ducks => 15).should == '15 ducks in a pond'
+      expect(Formtastic::I18n.t(:duck_pond, :scope => [:custom_scope], :ducks => 15)).to eq('15 ducks in a pond')
     end
 
     it "should be possible to override default values" do
-      Formtastic::I18n.t(:required, :default => 'Nothing found!').should == 'Nothing found!'
+      expect(Formtastic::I18n.t(:required, :default => 'Nothing found!')).to eq('Nothing found!')
     end
 
   end
@@ -71,7 +71,7 @@ describe 'Formtastic::I18n' do
 
     it "should use default strings" do
       (Formtastic::I18n::DEFAULT_VALUES.keys).each do |key|
-        Formtastic::I18n.t(key, :model => '%{model}').should == Formtastic::I18n::DEFAULT_VALUES[key]
+        expect(Formtastic::I18n.t(key, :model => '%{model}')).to eq(Formtastic::I18n::DEFAULT_VALUES[key])
       end
     end
 
@@ -98,8 +98,8 @@ describe 'Formtastic::I18n' do
           }
         }}
 
-      @new_post.stub(:title)
-      @new_post.stub(:column_for_attribute).with(:title).and_return(double('column', :type => :string, :limit => 255))
+      allow(@new_post).to receive(:title)
+      allow(@new_post).to receive(:column_for_attribute).with(:title).and_return(double('column', :type => :string, :limit => 255))
     end
 
     after do
@@ -108,7 +108,7 @@ describe 'Formtastic::I18n' do
 
     it "lookup scopes should be defined" do
       with_config :i18n_lookups_by_default, true do
-        lambda { Formtastic::I18n::SCOPES }.should_not raise_error
+        expect { Formtastic::I18n::SCOPES }.not_to raise_error
       end
     end
 
@@ -117,7 +117,7 @@ describe 'Formtastic::I18n' do
         concat(semantic_form_for(@new_post) do |builder|
           concat(builder.input(:title))
         end)
-        output_buffer.should have_tag("form label", /Hello post!/)
+        expect(output_buffer).to have_tag("form label", :text => /Hello post!/)
       end
     end
 
@@ -126,7 +126,7 @@ describe 'Formtastic::I18n' do
         concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
           concat(builder.input(:title))
         end)
-        output_buffer.should have_tag("form label", /Hello project!/)
+        expect(output_buffer).to have_tag("form label", :text => /Hello project!/)
       end
     end
 
@@ -135,7 +135,7 @@ describe 'Formtastic::I18n' do
         concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
           concat(builder.input(:author))
         end)
-        output_buffer.should have_tag("form label", /Author/)
+        expect(output_buffer).to have_tag("form label", :text => /Author/)
       end
     end
 
@@ -146,7 +146,7 @@ describe 'Formtastic::I18n' do
             concat(f.input(:name))
           end)
         end)
-        output_buffer.should have_tag("form label", /Hello author name!/)
+        expect(output_buffer).to have_tag("form label", :text => /Hello author name!/)
       end
     end
 
@@ -157,7 +157,7 @@ describe 'Formtastic::I18n' do
             concat(f.input(:name))
           end
         end)
-        output_buffer.should have_tag("form label", /Hello author name!/)
+        expect(output_buffer).to have_tag("form label", :text => /Hello author name!/)
       end
     end
 
@@ -168,7 +168,7 @@ describe 'Formtastic::I18n' do
             concat(f.input(:title))
           end
         end)
-        output_buffer.should have_tag("form label", /Hello project!/)
+        expect(output_buffer).to have_tag("form label", :text => /Hello project!/)
       end
     end
     
@@ -179,7 +179,7 @@ describe 'Formtastic::I18n' do
             concat(f.input(:name))
           end
         end)
-        output_buffer.should have_tag("form label", /Hello author name!/)
+        expect(output_buffer).to have_tag("form label", :text => /Hello author name!/)
       end
     end
 
@@ -188,7 +188,7 @@ describe 'Formtastic::I18n' do
         concat(semantic_form_for(@new_post) do |builder|
           concat(builder.input(:body))
         end)
-        output_buffer.should have_tag("form label", /Elaborate/)
+        expect(output_buffer).to have_tag("form label", :text => /Elaborate/)
       end
     end
     
@@ -199,7 +199,7 @@ describe 'Formtastic::I18n' do
             concat(f.input(:login))
           end)
         end)
-        output_buffer.should have_tag("form label", /Hello login/)
+        expect(output_buffer).to have_tag("form label", :text => /Hello login/)
       end
     end
 

data/spec/input_class_finder_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 require 'formtastic/input_class_finder'
 
-describe Formtastic::InputClassFinder do
+RSpec.describe Formtastic::InputClassFinder do
   it_behaves_like 'Specialized Class Finder' do
     let(:default) { Formtastic::Inputs }
     let(:namespaces_setting) { :input_namespaces }

data/spec/inputs/base/collections_spec.rb

@@ -0,0 +1,76 @@
+require 'fast_spec_helper'
+require 'inputs/base/collections'
+
+class MyInput
+  include Formtastic::Inputs::Base::Collections
+end
+
+RSpec.describe MyInput do
+  let(:builder) { double }
+  let(:template) { double }
+  let(:model_class) { double }
+  let(:model) { double(:class => model_class) }
+  let(:model_name) { "post" }
+  let(:method) { double }
+  let(:options) { Hash.new }
+  
+  let(:instance) { MyInput.new(builder, template, model, model_name, method, options) }
+
+  # class Whatever < ActiveRecord::Base
+  #   enum :status => [:active, :archived]
+  # end
+  #
+  # Whatever.statuses
+  #
+  # Whatever.new.status
+  #
+  # f.input :status
+  describe "#collection_from_enum" do
+    
+    let(:method) { :status }
+
+    context "when an enum is defined for the method" do
+      before do
+        statuses = ActiveSupport::HashWithIndifferentAccess.new("active"=>0, "inactive"=>1)
+        allow(model_class).to receive(:statuses) { statuses }
+        allow(model).to receive(:defined_enums) { {"status" => statuses } }
+      end
+
+      context 'no translations available' do
+        it 'returns an Array of EnumOption objects based on the enum options hash' do
+          expect(instance.collection_from_enum).to eq [["Active", "active"],["Inactive", "inactive"]]
+        end
+      end
+
+      context 'with translations' do
+        before do
+          ::I18n.backend.store_translations :en, :activerecord => {
+            :attributes => {
+              :post => {
+                :statuses => {
+                  :active => "I am active",
+                  :inactive => "I am inactive"
+                }
+              }
+            }
+          }
+        end
+        it 'returns an Array of EnumOption objects based on the enum options hash' do
+          expect(instance.collection_from_enum).to eq [["I am active", "active"],["I am inactive", "inactive"]]
+        end
+
+        after do
+          ::I18n.backend.store_translations :en, {}
+        end
+      end
+    end
+
+    context "when an enum is not defined" do
+      it 'returns nil' do
+        expect(instance.collection_from_enum).to eq nil
+      end
+    end
+  end
+
+end
+

data/spec/inputs/base/validations_spec.rb

@@ -0,0 +1,480 @@
+require 'fast_spec_helper'
+require 'active_model'
+require 'inputs/base/validations'
+
+class MyInput
+  attr_accessor :validations
+  include Formtastic::Inputs::Base::Validations
+
+  def validations?
+    true
+  end
+end
+
+RSpec.describe MyInput do
+  let(:builder) { double }
+  let(:template) { double }
+  let(:model_class) { double }
+  let(:model) { double(:class => model_class) }
+  let(:model_name) { "post" }
+  let(:method) { double }
+  let(:options) { Hash.new }
+  let(:validator) { double }
+  let(:instance) do
+    MyInput.new(builder, template, model, model_name, method, options).tap do |my_input|
+      my_input.validations = validations
+    end
+  end
+
+  describe '#required?' do
+    context 'with a single validator' do
+      let(:validations) { [validator] }
+
+      context 'with options[:required] being true' do
+        let(:options) { {required: true} }
+
+        it 'is required' do
+          expect(instance.required?).to be_truthy
+        end
+      end
+
+      context 'with options[:required] being false' do
+        let(:options) { {required: false} }
+
+        it 'is not required' do
+          expect(instance.required?).to be_falsey
+        end
+      end
+
+      context 'with negated validation' do
+        it 'is not required' do
+          instance.not_required_through_negated_validation!
+          expect(instance.required?).to be_falsey
+        end
+      end
+
+      context 'with presence validator' do
+        let (:validator) { double(options: {}, kind: :presence) }
+
+        it 'is required' do
+          expect(instance.required?).to be_truthy
+        end
+
+        context 'with options[:on] as symbol' do
+          context 'with save context' do
+            let (:validator) { double(options: {on: :save}, kind: :presence) }
+
+            it 'is required' do
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with create context' do
+            let (:validator) { double(options: {on: :create}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is not required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_falsey
+            end
+          end
+
+          context 'with update context' do
+            let (:validator) { double(options: {on: :update}, kind: :presence) }
+
+            it 'is not required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_falsey
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+        end
+
+        context 'with options[:on] as array' do
+          context 'with save context' do
+            let (:validator) { double(options: {on: [:save]}, kind: :presence) }
+
+            it 'is required' do
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with create context' do
+            let (:validator) { double(options: {on: [:create]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is not required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_falsey
+            end
+          end
+
+          context 'with update context' do
+            let (:validator) { double(options: {on: [:update]}, kind: :presence) }
+
+            it 'is not required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_falsey
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with save and create context' do
+            let (:validator) { double(options: {on: [:save, :create]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with save and update context' do
+            let (:validator) { double(options: {on: [:save, :create]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with create and update context' do
+            let (:validator) { double(options: {on: [:create, :update]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with save and other context' do
+            let (:validator) { double(options: {on: [:save, :foo]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with create and other context' do
+            let (:validator) { double(options: {on: [:create, :foo]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is not required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_falsey
+            end
+          end
+
+          context 'with update and other context' do
+            let (:validator) { double(options: {on: [:update, :foo]}, kind: :presence) }
+
+            it 'is not required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_falsey
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+        end
+      end
+
+      context 'with inclusion validator' do
+        context 'with allow blank' do
+          let (:validator) { double(options: {allow_blank: true}, kind: :inclusion) }
+
+          it 'is not required' do
+            expect(instance.required?).to be_falsey
+          end
+        end
+
+        context 'without allow blank' do
+          let (:validator) { double(options: {allow_blank: false}, kind: :inclusion) }
+
+          it 'is required' do
+            expect(instance.required?).to be_truthy
+          end
+        end
+      end
+
+      context 'with a length validator' do
+        context 'with allow blank' do
+          let (:validator) { double(options: {allow_blank: true}, kind: :length) }
+
+          it 'is not required' do
+            expect(instance.required?).to be_falsey
+          end
+        end
+
+        context 'without allow blank' do
+          let (:validator) { double(options: {allow_blank: false}, kind: :length) }
+
+          it 'is not required' do
+            expect(instance.required?).to be_falsey
+          end
+
+          context 'with a minimum > 0' do
+            let (:validator) { double(options: {allow_blank: false, minimum: 1}, kind: :length) }
+
+            it 'is required' do
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with a minimum <= 0' do
+            let (:validator) { double(options: {allow_blank: false, minimum: 0}, kind: :length) }
+
+            it 'is not required' do
+              expect(instance.required?).to be_falsey
+            end
+          end
+
+          context 'with a defined range starting with > 0' do
+            let (:validator) { double(options: {allow_blank: false, within: 1..5}, kind: :length) }
+
+            it 'is required' do
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with a defined range starting with <= 0' do
+            let (:validator) { double(options: {allow_blank: false, within: 0..5}, kind: :length) }
+
+            it 'is not required' do
+              expect(instance.required?).to be_falsey
+            end
+          end
+        end
+      end
+
+      context 'with another validator' do
+        let (:validator) { double(options: {allow_blank: true}, kind: :foo) }
+
+        it 'is not required' do
+          expect(instance.required?).to be_falsey
+        end
+      end
+    end
+
+    context 'with multiple validators' do
+      let(:validations) { [validator1, validator2] }
+
+      context 'with a on create presence validator and a on update presence validator' do
+        let(:validator1) { double(options: {on: :create}, kind: :presence) }
+        let(:validator2) { double(options: {}, kind: :presence) }
+
+        before :example do
+          allow(model).to receive(:new_record?).and_return(false)
+        end
+
+        it 'is required' do
+          expect(instance.required?).to be_truthy
+        end
+      end
+
+      context 'with a on create presence validator and a presence validator' do
+        let (:validator1) { double(options: {on: :create}, kind: :presence) }
+        let (:validator2) { double(options: {}, kind: :presence) }
+
+        before :example do
+          allow(model).to receive(:new_record?).and_return(false)
+        end
+
+        it 'is required' do
+          expect(instance.required?).to be_truthy
+        end
+      end
+
+      context 'with a on create presence validator and a allow blank inclusion validator' do
+        let(:validator1) { double(options: {on: :create}, kind: :presence) }
+        let(:validator2) { double(options: {allow_blank: true}, kind: :inclusion) }
+
+        before :example do
+          allow(model).to receive(:new_record?).and_return(false)
+        end
+
+        it 'is required' do
+          expect(instance.required?).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe '#validation_min' do
+    let(:validations) { [validator] }
+
+    context 'with a greater_than numericality validator' do
+      let(:validator) { double(options: { greater_than: option_value }, kind: :numericality) }
+
+      context 'with a symbol' do
+        let(:option_value) { :a_symbol }
+
+        it 'returns one greater' do
+          allow(model).to receive(:send).with(option_value).and_return(14)
+          expect(instance.validation_min).to eq 15
+        end
+      end
+
+      context 'with a proc' do
+        let(:option_value) { Proc.new { 10 } }
+
+        it 'returns one greater' do
+          expect(instance.validation_min).to eq 11
+        end
+      end
+
+      context 'with a number' do
+        let(:option_value) { 8 }
+
+        it 'returns one greater' do
+          expect(instance.validation_min).to eq 9
+        end
+      end
+    end
+
+    context 'with a greater_than_or_equal_to numericality validator' do
+      let(:validator) do
+        double(
+          options: { greater_than_or_equal_to: option_value },
+          kind: :numericality
+        )
+      end
+
+      context 'with a symbol' do
+        let(:option_value) { :a_symbol }
+
+        it 'returns the instance method amount' do
+          allow(model).to receive(:send).with(option_value).and_return(14)
+          expect(instance.validation_min).to eq 14
+        end
+      end
+
+      context 'with a proc' do
+        let(:option_value) { Proc.new { 10 } }
+
+        it 'returns the proc amount' do
+          expect(instance.validation_min).to eq 10
+        end
+      end
+
+      context 'with a number' do
+        let(:option_value) { 8 }
+
+        it 'returns the number' do
+          expect(instance.validation_min).to eq 8
+        end
+      end
+    end
+  end
+
+  describe '#validation_max' do
+    let(:validations) do
+      [
+        ActiveModel::Validations::NumericalityValidator.new(
+          validator_options.merge(attributes: :an_attribute)
+        )
+      ]
+    end
+
+    context 'with a less_than numericality validator' do
+      let(:validator_options) { { less_than: option_value } }
+
+      context 'with a symbol' do
+        let(:option_value) { :a_symbol }
+
+        it 'returns one less' do
+          allow(model).to receive(:send).with(option_value).and_return(14)
+          expect(instance.validation_max).to eq 13
+        end
+      end
+
+      context 'with a proc' do
+        let(:option_value) { proc { 10 } }
+
+        it 'returns one less' do
+          expect(instance.validation_max).to eq 9
+        end
+      end
+
+      context 'with a number' do
+        let(:option_value) { 8 }
+
+        it 'returns one less' do
+          expect(instance.validation_max).to eq 7
+        end
+      end
+    end
+
+    context 'with a less_than_or_equal_to numericality validator' do
+      let(:validator_options) { { less_than_or_equal_to: option_value } }
+
+      context 'with a symbol' do
+        let(:option_value) { :a_symbol }
+
+        it 'returns the instance method amount' do
+          allow(model).to receive(:send).with(option_value).and_return(14)
+          expect(instance.validation_max).to eq 14
+        end
+      end
+
+      context 'with a proc' do
+        let(:option_value) { proc { 10 } }
+
+        it 'returns the proc amount' do
+          expect(instance.validation_max).to eq 10
+        end
+      end
+
+      context 'with a number' do
+        let(:option_value) { 8 }
+
+        it 'returns the number' do
+          expect(instance.validation_max).to eq 8
+        end
+      end
+    end
+  end
+end
+