shoulda-matchers 3.1.3 → 4.0.0.rc1

data/spec/unit/shoulda/matchers/active_record/association_matcher_spec.rb

@@ -82,18 +82,18 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher, type: :model do
     end
 
     it 'accepts an association with a valid :inverse_of option' do
-      expect(belonging_to_parent(inverse_of: :children))
-        .to belong_to(:parent).inverse_of(:children)
+      expect(belonging_to_with_inverse(:parent, :children)).
+        to belong_to(:parent).inverse_of(:children)
     end
 
     it 'rejects an association with a bad :inverse_of option' do
-      expect(belonging_to_parent(inverse_of: :other_children))
-        .not_to belong_to(:parent).inverse_of(:children)
+      expect(belonging_to_with_inverse(:parent, :other_children)).
+        not_to belong_to(:parent).inverse_of(:children)
     end
 
     it 'rejects an association that has no :inverse_of option' do
-      expect(belonging_to_parent)
-        .not_to belong_to(:parent).inverse_of(:children)
+      expect(belonging_to_parent).
+        not_to belong_to(:parent).inverse_of(:children)
     end
 
     it 'accepts an association with a valid :conditions option' do
@@ -279,11 +279,373 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher, type: :model do
       end
     end
 
-    def belonging_to_parent(options = {})
-      define_model :parent
+    context 'given the association is neither configured to be required nor optional' do
+      context 'when qualified with required(true)' do
+        if active_record_supports_optional_for_associations?
+          context 'when belongs_to is configured to be required by default' do
+            it 'passes' do
+              configuring_default_belongs_to_requiredness(true) do
+                expect(belonging_to_parent).to belong_to(:parent).required(true)
+              end
+            end
+          end
+
+          context 'when belongs_to is not configured to be required by default' do
+            it 'fails with an appropriate message' do
+              configuring_default_belongs_to_requiredness(false) do
+                assertion = lambda do
+                  expect(belonging_to_parent).
+                    to belong_to(:parent).required(true)
+                end
+
+                message = format_message(<<-MESSAGE, one_line: true)
+                  Expected Child to have a belongs_to association called parent
+                  (the association should have been defined with `required:
+                  true`, but was not)
+                MESSAGE
+
+                expect(&assertion).to fail_with_message(message)
+              end
+            end
+          end
+        else
+          it 'fails with an appropriate message' do
+            assertion = lambda do
+              expect(belonging_to_parent).
+                to belong_to(:parent).required(true)
+            end
+
+            message = format_message(<<-MESSAGE, one_line: true)
+              Expected Child to have a belongs_to association called parent
+              (the association should have been defined with `required:
+              true`, but was not)
+            MESSAGE
+
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
+      end
+
+      context 'when qualified with required(false)' do
+        if active_record_supports_optional_for_associations?
+          context 'when belongs_to is configured to be required by default' do
+            it 'fails with an appropriate message' do
+              configuring_default_belongs_to_requiredness(true) do
+                assertion = lambda do
+                  expect(belonging_to_parent).
+                    to belong_to(:parent).required(false)
+                end
+
+                message = format_message(<<-MESSAGE, one_line: true)
+                  Expected Child to have a belongs_to association called parent
+                  (the association should have been defined with `required:
+                  false`, but was not)
+                MESSAGE
+
+                expect(&assertion).to fail_with_message(message)
+              end
+            end
+          end
+
+          context 'when belongs_to is not configured to be required by default' do
+            it 'passes' do
+              configuring_default_belongs_to_requiredness(false) do
+                expect(belonging_to_parent).to belong_to(:parent).required(false)
+              end
+            end
+          end
+        else
+          it 'passes' do
+            expect(belonging_to_parent).to belong_to(:parent).required(false)
+          end
+        end
+      end
+
+      context 'when qualified with optional' do
+        if active_record_supports_optional_for_associations?
+          context 'when belongs_to is configured to be required by default' do
+            it 'fails with an appropriate message' do
+              configuring_default_belongs_to_requiredness(true) do
+                assertion = lambda do
+                  expect(belonging_to_parent).
+                    to belong_to(:parent).optional
+                end
+
+                message = format_message(<<-MESSAGE, one_line: true)
+                  Expected Child to have a belongs_to association called parent (the
+                  association should have been defined with `optional: true`, but
+                  was not)
+                MESSAGE
+
+                expect(&assertion).to fail_with_message(message)
+              end
+            end
+          end
+
+          context 'when belongs_to is not configured to be required by default' do
+            it 'passes' do
+              configuring_default_belongs_to_requiredness(false) do
+                expect(belonging_to_parent).to belong_to(:parent).optional
+              end
+            end
+          end
+        else
+          it 'passes' do
+            expect(belonging_to_parent).to belong_to(:parent).optional
+          end
+        end
+      end
+
+      context 'when qualified with nothing' do
+        if active_record_supports_optional_for_associations?
+          context 'when belongs_to is configured to be required by default' do
+            it 'passes' do
+              configuring_default_belongs_to_requiredness(true) do
+                expect(belonging_to_parent).to belong_to(:parent)
+              end
+            end
+          end
+
+          context 'when belongs_to is not configured to be required by default' do
+            it 'passes' do
+              configuring_default_belongs_to_requiredness(false) do
+                expect(belonging_to_parent).to belong_to(:parent)
+              end
+            end
+
+            context 'and a presence validation is on the attribute instead of using required: true' do
+              it 'passes' do
+                configuring_default_belongs_to_requiredness(false) do
+                  record = belonging_to_parent do
+                    validates_presence_of :parent
+                  end
+
+                  expect(record).to belong_to(:parent)
+                end
+              end
+            end
+
+            context 'and a presence validation is on the attribute with a condition' do
+              context 'and the condition is true' do
+                it 'passes' do
+                  configuring_default_belongs_to_requiredness(false) do
+                    child_model = create_child_model_belonging_to_parent do
+                      attr_accessor :condition
+                      validates_presence_of :parent, if: :condition
+                    end
+
+                    record = child_model.new(condition: true)
+
+                    expect(record).to belong_to(:parent)
+                  end
+                end
+              end
+
+              context 'and the condition is false' do
+                it 'passes' do
+                  configuring_default_belongs_to_requiredness(false) do
+                    child_model = create_child_model_belonging_to_parent do
+                      attr_accessor :condition
+                      validates_presence_of :parent, if: :condition
+                    end
+
+                    record = child_model.new(condition: false)
+
+                    expect(record).to belong_to(:parent)
+                  end
+                end
+              end
+            end
+          end
+        else
+          it 'passes' do
+            expect(belonging_to_parent).to belong_to(:parent)
+          end
+
+          context 'and a presence validation is on the attribute instead of using required: true' do
+            it 'passes' do
+              record = belonging_to_parent do
+                validates_presence_of :parent
+              end
+
+              expect(record).to belong_to(:parent)
+            end
+          end
+
+          context 'and a presence validation is on the attribute with a condition' do
+            context 'and the condition is true' do
+              it 'passes' do
+                child_model = create_child_model_belonging_to_parent do
+                  attr_accessor :condition
+                  validates_presence_of :parent, if: :condition
+                end
+
+                record = child_model.new(condition: true)
+
+                expect(record).to belong_to(:parent)
+              end
+            end
+
+            context 'and the condition is false' do
+              it 'passes' do
+                child_model = create_child_model_belonging_to_parent do
+                  attr_accessor :condition
+                  validates_presence_of :parent, if: :condition
+                end
+
+                record = child_model.new(condition: false)
+
+                expect(record).to belong_to(:parent)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    context 'given the association is configured with required: true' do
+      context 'when qualified with required(true)' do
+        it 'passes' do
+          expect(belonging_to_parent(required: true)).
+            to belong_to(:parent).required(true)
+        end
+      end
+
+      context 'when qualified with required(false)' do
+        it 'passes' do
+          assertion = lambda do
+            expect(belonging_to_parent(required: true)).
+              to belong_to(:parent).required(false)
+          end
+
+          message = format_message(<<-MESSAGE, one_line: true)
+            Expected Child to have a belongs_to association called parent (the
+            association should have been defined with `required: false`, but
+            was not)
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'when qualified with optional' do
+        it 'fails with an appropriate message' do
+          assertion = lambda do
+            expect(belonging_to_parent(required: true)).
+              to belong_to(:parent).optional
+          end
+
+          message = format_message(<<-MESSAGE, one_line: true)
+            Expected Child to have a belongs_to association called parent (the
+            association should have been defined with `optional: true`, but
+            was not)
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'when qualified with nothing' do
+        it 'passes' do
+          expect(belonging_to_parent(required: true)).to belong_to(:parent)
+        end
+      end
+    end
+
+    if active_record_supports_optional_for_associations?
+      context 'given the association is configured as optional: true' do
+        context 'when qualified with required(true)' do
+          it 'fails with an appropriate message' do
+            assertion = lambda do
+              expect(belonging_to_parent(optional: true)).
+                to belong_to(:parent).required(true)
+            end
+
+            message = format_message(<<-MESSAGE, one_line: true)
+              Expected Child to have a belongs_to association called parent (the
+              association should have been defined with `required: true`, but
+              was not)
+            MESSAGE
+
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
+
+        context 'when qualified with required(false)' do
+          it 'passes' do
+            expect(belonging_to_parent(optional: true)).
+              to belong_to(:parent).required(false)
+          end
+        end
+
+        context 'when qualified with optional' do
+          it 'passes' do
+            expect(belonging_to_parent(optional: true)).
+              to belong_to(:parent).optional
+          end
+        end
+
+        context 'when qualified with nothing' do
+          it 'fails with an appropriate message' do
+            assertion = lambda do
+              expect(belonging_to_parent(optional: true)).
+                to belong_to(:parent)
+            end
+
+            message = format_message(<<-MESSAGE, one_line: true)
+              Expected Child to have a belongs_to association called parent (the
+              association should have been defined with `required: true`, but
+              was not)
+            MESSAGE
+
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
+      end
+    end
+
+    def belonging_to_parent(options = {}, parent_options = {}, &block)
+      child_model = create_child_model_belonging_to_parent(
+        options,
+        parent_options,
+        &block
+      )
+      child_model.new
+    end
+
+    def create_child_model_belonging_to_parent(
+      options = {},
+      parent_options = {},
+      &block
+    )
+      define_model(:parent, parent_options)
+
       define_model :child, parent_id: :integer do
         belongs_to :parent, options
-      end.new
+
+        if block
+          class_eval(&block)
+        end
+      end
+    end
+
+    def belonging_to_with_inverse(association, inverse_association)
+      parent_model_name = association.to_s.singularize
+      child_model_name = inverse_association.to_s.singularize
+      parent_foreign_key = "#{parent_model_name}_id"
+
+      define_model parent_model_name do
+        has_many inverse_association
+      end
+
+      child_model = define_model(
+        child_model_name,
+        parent_foreign_key => :integer,
+      ) do
+        belongs_to association, inverse_of: inverse_association
+      end
+
+      child_model.new
     end
 
     def belonging_to_non_existent_class(model_name, assoc_name, options = {})
@@ -526,6 +888,33 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher, type: :model do
       }.to fail_with_message(message)
     end
 
+    if rails_5_x?
+      context 'index_errors' do
+        it 'accepts an association with a matching :index_errors option' do
+          define_model :child, parent_id: :integer
+          define_model :parent do
+            has_many :children, index_errors: true
+          end
+          expect(Parent.new).to have_many(:children).index_errors(true)
+        end
+
+        it 'rejects an association with a non-matching :index_errors option and returns the correct message' do
+          define_model :child, parent_id: :integer
+          define_model :parent do
+            has_many :children, autosave: false
+          end
+
+          message =
+            'Expected Parent to have a has_many association called children ' +
+            '(children should have index_errors set to true)'
+
+          expect {
+            expect(Parent.new).to have_many(:children).index_errors(true)
+          }.to fail_with_message(message)
+        end
+      end
+    end
+
     context 'validate' do
       it 'accepts when the :validate option matches' do
         expect(having_many_children(validate: false)).to have_many(:children).validate(false)
@@ -826,6 +1215,31 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher, type: :model do
       end
     end
 
+    if active_record_supports_optional_for_associations?
+      context 'given an association with a matching :required option' do
+        it 'passes' do
+          expect(having_one_detail(required: true)).
+            to have_one(:detail).required
+        end
+      end
+    end
+
+    context 'given an association with a non-matching :required option' do
+      it 'fails with an appropriate message' do
+        assertion = lambda do
+          expect(having_one_detail(required: false)).
+            to have_one(:detail).required
+        end
+
+        message =
+          'Expected Person to have a has_one association called detail ' +
+          '(the association should have been defined with `required: true`, ' +
+          'but was not)'
+
+        expect(&assertion).to fail_with_message(message)
+      end
+    end
+
     def having_one_detail(options = {})
       define_model :detail, person_id: :integer
       define_model(:person).tap do |model|
@@ -1210,7 +1624,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher, type: :model do
   def define_association_with_conditions(model, macro, name, conditions, other_options={})
     args = []
     options = {}
-    if Shoulda::Matchers::RailsShim.active_record_major_version == 4
+    if active_record_supports_relations?
       args << proc { where(conditions) }
     else
       options[:conditions] = conditions
@@ -1222,7 +1636,7 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher, type: :model do
   def define_association_with_order(model, macro, name, order, other_options={})
     args = []
     options = {}
-    if Shoulda::Matchers::RailsShim.active_record_major_version == 4
+    if active_record_supports_relations?
       args << proc { order(order) }
     else
       options[:order] = order
@@ -1232,11 +1646,27 @@ describe Shoulda::Matchers::ActiveRecord::AssociationMatcher, type: :model do
   end
 
   def dependent_options
-    case Rails.version
-    when /\A3/
-      [:destroy, :delete, :nullify, :restrict]
-    when /\A4/
+    if active_record_supports_more_dependent_options?
       [:destroy, :delete, :nullify, :restrict_with_exception, :restrict_with_error]
+    else
+      [:destroy, :delete, :nullify, :restrict]
     end
   end
+
+  def configuring_default_belongs_to_requiredness(value, &block)
+    configuring_application(
+      ActiveRecord::Base,
+      :belongs_to_required_by_default,
+      value,
+      &block
+    )
+  end
+
+  def configuring_application(config, name, value)
+    previous_value = config.send(name)
+    config.send("#{name}=", value)
+    yield
+  ensure
+    config.send("#{name}=", previous_value)
+  end
 end