shoulda-matchers 4.0.1 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e90bda8ad7aa6bef803eddafa1a0aee31f4228372a5d4ba30255682cc841ed6
-  data.tar.gz: 33c33b0e10964e0dfd3d80e9e680b361a96f817205cd513786779593e3681ae7
+  metadata.gz: 1856891b0a96aaa5ed99a48490288b2bbd3547c7779ab1d8477a33b61cbb0c7d
+  data.tar.gz: b3768f6532318b37de78e6959a1c7be2e28e19b4618d966a7ca0dab0cfa96ceb
 SHA512:
-  metadata.gz: 71099155dc17393673681f6255d4dc52735182de139ccf798939b2a3f8ea310e5547286f91ddbd914b98d58fccb7cecc2a0277ecdab1febd6ecf7b918de888b0
-  data.tar.gz: 1b4624af4740f43192336f624f748c3506131d1ce57f29c65591dce5f0ceee8e0d12a5860a81ddadadec4e423e94662f166a5d91dc7df82050d53353e82994a7
+  metadata.gz: dc99bd232c8f9a3eeff2ea7b82b36821339b20090b40c750c282b48d413b99028fcb69ec775ecb37a43d7e6d59a0c090213c35ede384ed95303d010a5e00ed90
+  data.tar.gz: 56dbd1bd6978b59743e6936118a535e276b7672f12a0b46b69b3baf164b6dcac0688ee26ec66ccb11b2d0af8d1374567d401ef1f46d3f54bd6d3ccee8cf55085

data/README.md

@@ -1,20 +1,39 @@
 # Shoulda Matchers [![Gem Version][version-badge]][rubygems] [![Build Status][travis-badge]][travis] ![Downloads][downloads-badge] [![Hound][hound-badge]][hound]
 
+[version-badge]: https://img.shields.io/gem/v/shoulda-matchers.svg
+[rubygems]: https://rubygems.org/gems/shoulda-matchers
+[travis-badge]: https://img.shields.io/travis/thoughtbot/shoulda-matchers/master.svg
+[travis]: https://travis-ci.org/thoughtbot/shoulda-matchers
+[downloads-badge]: https://img.shields.io/gem/dtv/shoulda-matchers.svg
+[hound-badge]: https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg
+[hound]: https://houndci.com
+
 [![shoulda-matchers][logo]][website]
 
-Shoulda Matchers provides RSpec- and Minitest-compatible one-liners that test
-common Rails functionality. These tests, if written by hand, would be much
-longer, more complex, and error-prone.
+[logo]: https://matchers.shoulda.io/images/shoulda-matchers-logo.png
+[website]: https://matchers.shoulda.io/
+
+Shoulda Matchers provides RSpec- and Minitest-compatible one-liners to test
+common Rails functionality that, if written by hand, would be much longer, more
+complex, and error-prone.
+
+## Quick links
+
+📖 **[Read the documentation for the latest version (4.1.0)][rubydocs].**  
+📢 **[See what's changed in a recent version][news].**
 
-**[View the documentation for the latest version (4.0.0).][rubydocs]**
+[rubydocs]: http://matchers.shoulda.io/docs
+[news]: NEWS.md
 
----
+## Table of contents
 
 * [Getting started](#getting-started)
    * [RSpec](#rspec)
-      * [Availability of matchers in various example groups](#availability-of-matchers-in-various-example-groups)
-      * [<code>should</code> vs <code>is_expected.to</code>](#should-vs-is_expectedto)
    * [Minitest](#minitest)
+* [Usage](#usage)
+  * [On the subject of `subject`](#on-the-subject-of-subject)
+  * [Availability of RSpec matchers in example groups](#availability-of-rspec-matchers-in-example-groups)
+  * [`should` vs `is_expected.to`](#should-vs-is_expectedto)
 * [Matchers](#matchers)
    * [ActiveModel matchers](#activemodel-matchers)
    * [ActiveRecord matchers](#activerecord-matchers)
@@ -35,7 +54,6 @@ Start by including `shoulda-matchers` in your Gemfile:
 ```ruby
 group :test do
   gem 'shoulda-matchers'
-  gem 'rails-controller-testing'
 end
 ```
 
@@ -61,14 +79,7 @@ Shoulda::Matchers.configure do |config|
 end
 ```
 
-Now you're ready to use matchers in your tests! For instance, you might decide
-to add a matcher to one of your models:
-
-```ruby
-RSpec.describe Person, type: :model do
-  it { should validate_presence_of(:name) }
-end
-```
+Now you're ready to [use matchers in your tests](#usage)!
 
 #### Non-Rails apps
 
@@ -88,23 +99,144 @@ Shoulda::Matchers.configure do |config|
 end
 ```
 
-Now you're ready to use matchers in your tests! For instance, you might decide
-to add a matcher to one of your models:
+Now you're ready to [use matchers in your tests](#usage)!
+
+### Minitest
+
+Shoulda Matchers was originally a component of [Shoulda][shoulda], a gem that
+also provides `should` and `context` syntax via
+[`shoulda-context`][shoulda-context].
+
+[shoulda]: https://github.com/thoughtbot/shoulda
+[shoulda-context]: https://github.com/thoughtbot/shoulda-context
+
+At the moment, `shoulda` has not been updated to support `shoulda-matchers` 3.x
+and 4.x, so you'll want to add the following to your Gemfile:
 
 ```ruby
-RSpec.describe Person, type: :model do
-  it { should validate_presence_of(:name) }
+group :test do
+  gem 'shoulda', '~> 3.5'
+  gem 'shoulda-matchers', '~> 2.0'
+  gem 'rails-controller-testing'
+end
+```
+
+Now you're ready to [use matchers in your tests](#usage)!
+
+## Usage
+
+The matchers provided by this gem are divided into different categories
+depending on what you're testing within your Rails app:
+
+* [database models backed by ActiveRecord](#activemodel-matchers)
+* [non-database models, form objects, etc. backed by
+  ActiveModel](#activerecord-matchers)
+* [controllers](#actioncontroller-matchers)
+* [routes](#routing-matchers) (RSpec only)
+* [usage of Rails-specific features like `delegate`](#independent-matchers)
+
+All matchers are designed to be prepended primarily with the word `should`,
+which is a special directive in both RSpec and Shoulda. For instance, a model
+test case may look something like:
+
+``` ruby
+# RSpec
+RSpec.describe MenuItem, type: :model do
+  describe 'associations' do
+    it { should belong_to(:category).class_name('MenuCategory') }
+  end
+
+  describe 'validations' do
+    it { should validate_presence_of(:name) }
+    it { should validate_uniqueness_of(:name).scoped_to(:category_id) }
+  end
+end
+
+# Minitest (Shoulda)
+class MenuItemTest < ActiveSupport::TestCase
+  context 'associations' do
+    should belong_to(:category).class_name('MenuCategory')
+  end
+
+  context 'validations' do
+    should validate_presence_of(:name)
+    should validate_uniqueness_of(:name).scoped_to(:category_id)
+  end
+end
+```
+
+For the full set of matchers you can use, [see below](#matchers).
+
+### On the subject of `subject`
+
+For both RSpec and Shoulda, the **subject** is an implicit reference to the
+object under test, and all of the matchers make use of it internally when they
+are run. This is always set automatically by your test framework in any given
+test case; however, in certain cases it can be advantageous to override the
+subject. For instance, when testing validations in a model, it is customary to
+provide a valid model instead of a fresh one:
+
+``` ruby
+# RSpec
+RSpec.describe Post, type: :model do
+  describe 'validations' do
+    # Here we're using FactoryBot, but you could use anything
+    subject { build(:post) }
+
+    it { should validate_presence_of(:title) }
+  end
+end
+
+# Minitest (Shoulda)
+class PostTest < ActiveSupport::TestCase
+  context 'validations' do
+    subject { build(:post) }
+
+    should validate_presence_of(:title)
+  end
+end
+```
+
+When overriding the subject in this manner, then, it's important to provide the
+correct object. **When in doubt, provide an instance of the class under test.**
+This is particularly necessary for controller tests, where it is easy to
+accidentally write something like:
+
+``` ruby
+RSpec.describe PostsController, type: :controller do
+  describe 'GET #index' do
+    subject { get :index }
+
+    # This may work...
+    it { should have_http_status(:success) }
+    # ...but this will not!
+    it { should permit(:title, :body).for(:post) }
+  end
 end
 ```
 
-For more of an idea of what you can use, [see the list of matchers
-below](#matchers).
+In this case, you would want to use `before` rather than `subject`:
 
-#### Availability of matchers in various example groups
+``` ruby
+RSpec.describe PostsController, type: :controller do
+  describe 'GET #index' do
+    before { get :index }
 
-Regardless of your project, it's important to keep in mind that since
-shoulda-matchers provides four categories of matchers, there are four different
-levels where you can use these matchers:
+    # Notice that we have to assert have_http_status on the response here...
+    it { expect(response).to have_http_status(:success) }
+    # ...but we do not have to provide a subject for render_template
+    it { should render_template('index') }
+  end
+end
+```
+
+### Availability of RSpec matchers in example groups
+
+If you're using RSpec, then you're probably familiar with the concept of example
+groups: these are different kinds of test cases, and each of them has special
+behavior around them. As alluded to [above](#usage), this gem works in a similar
+way, and there are matchers that are only available in certain types of example
+groups:
 
 * ActiveRecord and ActiveModel matchers are available only in model example
   groups, i.e., those tagged with `type: :model` or in files located under
@@ -112,17 +244,19 @@ levels where you can use these matchers:
 * ActionController matchers are available only in controller example groups,
   i.e., those tagged with `type: :controller` or in files located under
   `spec/controllers`.
-* The `route` matcher is available also in routing example groups, i.e., those
+* The `route` matcher is available in routing example groups, i.e., those
   tagged with `type: :routing` or in files located under `spec/routing`.
 * Independent matchers are available in all example groups.
 
-**⚠️ If you are using ActiveModel or ActiveRecord outside of Rails** and you want
-to use model matchers in certain example groups, you'll need to manually include
-them. Here's a good way of doing that:
+As long as you're using Rails, you don't need to worry about this — everything
+should "just work".
 
-```ruby
-require 'shoulda-matchers'
+**However, if you are using ActiveModel or ActiveRecord outside of Rails**, and
+you want to use model matchers in certain example groups, you'll need to
+manually include the module that holds those matchers. A good way to do this is
+to place the following in your `spec_helper.rb`:
 
+```ruby
 RSpec.configure do |config|
   config.include(Shoulda::Matchers::ActiveModel, type: :model)
   config.include(Shoulda::Matchers::ActiveRecord, type: :model)
@@ -137,13 +271,13 @@ describe MySpecialModel, type: :model do
 end
 ```
 
-#### `should` vs `is_expected.to`
+### `should` vs `is_expected.to`
 
-Note that in this README and throughout the documentation we're using the
-`should` form of RSpec's one-liner syntax over `is_expected.to`. The `should`
-form works regardless of how you've configured RSpec — meaning you can still use
-it even when using the `expect` syntax. But if you prefer to use
-`is_expected.to`, you can do that too:
+In this README and throughout the documentation, we're using the `should` form
+of RSpec's one-liner syntax over `is_expected.to`. The `should` form works
+regardless of how you've configured RSpec — meaning you can still use it even
+when using the `expect` syntax. But if you prefer to use `is_expected.to`, you
+can do that too:
 
 ```ruby
 RSpec.describe Person, type: :model do
@@ -151,36 +285,11 @@ RSpec.describe Person, type: :model do
 end
 ```
 
-### Minitest
-
-Shoulda Matchers was originally a component of [Shoulda][shoulda], a gem that
-also provides `should` and `context` syntax via
-[`shoulda-context`][shoulda-context].
-
-At the moment, `shoulda` has not been updated to support `shoulda-matchers` 3.x
-and 4.x, so you'll want to add the following to your Gemfile:
-
-```ruby
-group :test do
-  gem 'shoulda', '~> 3.5'
-  gem 'shoulda-matchers', '~> 2.0'
-end
-```
-
-Now you're ready to use matchers in your tests! For instance, you might decide
-to add a matcher to one of your models:
-
-```ruby
-class PersonTest < ActiveSupport::TestCase
-  should validate_presence_of(:name)
-end
-```
-
-For more of an idea of what you can use, [see the list of matchers
-below](#matchers).
-
 ## Matchers
 
+The following is a list of matchers shipped with the gem. If you need details
+about any of them, make sure to [consult the documentation][rubydocs]!
+
 ### ActiveModel matchers
 
 * **[allow_value](lib/shoulda/matchers/active_model/allow_value_matcher.rb)**
@@ -259,6 +368,11 @@ below](#matchers).
 * **[use_before_action](lib/shoulda/matchers/action_controller/callback_matcher.rb#L54)**
   tests that a `before_action` callback is defined in your controller.
 
+### Routing matchers
+
+* **[route](lib/shoulda/matchers/action_controller/route_matcher.rb)** tests
+  your routes.
+
 ### Independent matchers
 
 * **[delegate_method](lib/shoulda/matchers/independent/delegate_method_matcher.rb)**
@@ -267,11 +381,10 @@ below](#matchers).
 
 ## Compatibility
 
-Shoulda Matchers 4 is tested and supported against Rails 5.x, Rails 4.2, RSpec
-3.x, Minitest 5, Minitest 4, and Ruby 2.3+.
+Shoulda Matchers is tested and supported against Ruby 2.4+, Rails 5.x, Rails
+4.2.x, RSpec 3.x, and Minitest 5.x.
 
-For Rails 4.0/4.1 and Ruby 2.0/2.1/2.2 compatibility, please use
-[shoulda-matchers 3.1.3][v3.1.3].
+For Ruby < 2.4 and Rails < 4.1 compatibility, please use [v3.1.3][v3.1.3].
 
 [v3.1.3]: https://github.com/thoughtbot/shoulda-matchers/releases/tag/v3.1.3
 
@@ -280,6 +393,8 @@ For Rails 4.0/4.1 and Ruby 2.0/2.1/2.2 compatibility, please use
 Shoulda Matchers is open source, and we are grateful for
 [everyone][contributors] who's contributed so far.
 
+[contributors]: https://github.com/thoughtbot/shoulda-matchers/contributors
+
 If you'd like to contribute, please take a look at the
 [instructions](CONTRIBUTING.md) for installing dependencies and crafting a good
 pull request.
@@ -296,32 +411,19 @@ Shoulda Matchers is copyright © 2006-2019
 and may be redistributed under the terms specified in the
 [MIT-LICENSE](MIT-LICENSE) file.
 
+[thoughtbot-website]: https://thoughtbot.com
+
 ## About thoughtbot
 
 ![thoughtbot][thoughtbot-logo]
 
+[thoughtbot-logo]: https://presskit.thoughtbot.com/images/thoughtbot-logo-for-readmes.svg
+
 Shoulda Matchers is maintained and funded by thoughtbot, inc. The names and
 logos for thoughtbot are trademarks of thoughtbot, inc.
 
 We are passionate about open source software. See [our other
 projects][community]. We are [available for hire][hire].
 
-[rubydocs]: http://matchers.shoulda.io/docs/v4.0.0.rc1
 [community]: https://thoughtbot.com/community?utm_source=github
 [hire]: https://thoughtbot.com?utm_source=github
-[version-badge]: https://img.shields.io/gem/v/shoulda-matchers.svg
-[rubygems]: httpss://rubygems.org/gems/shoulda-matchers
-[travis-badge]: https://img.shields.io/travis/thoughtbot/shoulda-matchers/master.svg
-[travis]: https://travis-ci.org/thoughtbot/shoulda-matchers
-[downloads-badge]: https://img.shields.io/gem/dtv/shoulda-matchers.svg
-[contributors]: https://github.com/thoughtbot/shoulda-matchers/contributors
-[shoulda]: https://github.com/thoughtbot/shoulda
-[shoulda-context]: https://github.com/thoughtbot/shoulda-context
-[Zeus]: https://github.com/burke/zeus
-[Appraisal]: https://github.com/thoughtbot/appraisal
-[hound-badge]: https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg
-[hound]: https://houndci.com
-[thoughtbot-website]: https://thoughtbot.com
-[thoughtbot-logo]: https://presskit.thoughtbot.com/images/thoughtbot-logo-for-readmes.svg
-[logo]: https://matchers.shoulda.io/images/shoulda-matchers-logo.png
-[website]: https://matchers.shoulda.io/

data/lib/shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher.rb

@@ -17,6 +17,7 @@ module Shoulda
             :ignore_interference_by_writer,
             :ignoring_interference_by_writer,
             :matches?,
+            :does_not_match?,
             :on,
             :strict,
             :with_message,

data/lib/shoulda/matchers/active_model/qualifiers.rb

@@ -8,5 +8,6 @@ module Shoulda
   end
 end
 
+require_relative 'qualifiers/allow_nil'
 require_relative 'qualifiers/ignore_interference_by_writer'
 require_relative 'qualifiers/ignoring_interference_by_writer'

data/lib/shoulda/matchers/active_model/qualifiers/allow_nil.rb

@@ -0,0 +1,26 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      module Qualifiers
+        # @private
+        module AllowNil
+          def initialize(*args)
+            super
+            @expects_to_allow_nil = false
+          end
+
+          def allow_nil
+            @expects_to_allow_nil = true
+            self
+          end
+
+          protected
+
+          def expects_to_allow_nil?
+            @expects_to_allow_nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_model/validate_numericality_of_matcher.rb

@@ -562,7 +562,8 @@ module Shoulda
 
         def has_been_qualified?
           @submatchers.any? do |submatcher|
-            submatcher.class.parent == NumericalityMatchers
+            Shoulda::Matchers::RailsShim.parent_of(submatcher.class) ==
+              NumericalityMatchers
           end
         end
 

data/lib/shoulda/matchers/active_model/validate_presence_of_matcher.rb

@@ -57,6 +57,27 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # ##### allow_nil
+      #
+      # Use `allow_nil` if your model has an optional attribute.
+      #
+      #   class Robot
+      #     include ActiveModel::Model
+      #     attr_accessor :nickname
+      #
+      #     validates_presence_of :nickname, allow_nil: true
+      #   end
+      #
+      #   # RSpec
+      #   RSpec.describe Robot, type: :model do
+      #     it { should validate_presence_of(:nickname).allow_nil }
+      #   end
+      #
+      #   # Minitest (Shoulda)
+      #   class RobotTest < ActiveSupport::TestCase
+      #     should validate_presence_of(:nickname).allow_nil
+      #   end
+      #
       # ##### on
       #
       # Use `on` if your validation applies only under a certain context.
@@ -111,6 +132,8 @@ module Shoulda
 
       # @private
       class ValidatePresenceOfMatcher < ValidationMatcher
+        include Qualifiers::AllowNil
+
         def initialize(attribute)
           super
           @expected_message = :blank
@@ -122,9 +145,16 @@ module Shoulda
           possibly_ignore_interference_by_writer
 
           if secure_password_being_validated?
-            disallows_and_double_checks_value_of!(blank_value, @expected_message)
+            ignore_interference_by_writer.default_to(when: :blank?)
+
+            disallowed_values.all? do |value|
+              disallows_and_double_checks_value_of!(value)
+            end
           else
-            disallows_original_or_typecast_value?(blank_value, @expected_message)
+            (!expects_to_allow_nil? || allows_value_of(nil)) &&
+              disallowed_values.all? do |value|
+                disallows_original_or_typecast_value?(value)
+              end
           end
         end
 
@@ -134,9 +164,16 @@ module Shoulda
           possibly_ignore_interference_by_writer
 
           if secure_password_being_validated?
-            allows_and_double_checks_value_of!(blank_value, @expected_message)
+            ignore_interference_by_writer.default_to(when: :blank?)
+
+            disallowed_values.any? do |value|
+              allows_and_double_checks_value_of!(value)
+            end
           else
-            allows_original_or_typecast_value?(blank_value, @expected_message)
+            (expects_to_allow_nil? && !allows_value_of(nil)) ||
+              disallowed_values.any? do |value|
+                allows_original_or_typecast_value?(value)
+              end
           end
         end
 
@@ -144,12 +181,30 @@ module Shoulda
           "validate that :#{@attribute} cannot be empty/falsy"
         end
 
+        def failure_message
+          message = super
+
+          if should_add_footnote_about_belongs_to?
+            message << "\n\n"
+            message << Shoulda::Matchers.word_wrap(<<-MESSAGE.strip, indent: 2)
+You're getting this error because #{reason_for_existing_presence_validation}.
+*This* presence validation doesn't use "can't be blank", the usual validation
+message, but "must exist" instead.
+
+With that said, did you know that the `belong_to` matcher can test this
+validation for you? Instead of using `validate_presence_of`, try
+#{suggestions_for_belongs_to}
+            MESSAGE
+          end
+
+          message
+        end
+
         private
 
         def secure_password_being_validated?
-          defined?(::ActiveModel::SecurePassword) &&
-            @subject.class.ancestors.include?(::ActiveModel::SecurePassword::InstanceMethodsOnActivation) &&
-            @attribute == :password
+          Shoulda::Matchers::RailsShim.digestible_attributes_in(@subject).
+            include?(@attribute)
         end
 
         def possibly_ignore_interference_by_writer
@@ -158,45 +213,136 @@ module Shoulda
           end
         end
 
-        def allows_and_double_checks_value_of!(value, message)
-          allows_value_of(value, message)
+        def allows_and_double_checks_value_of!(value)
+          allows_value_of(value, @expected_message)
         rescue ActiveModel::AllowValueMatcher::AttributeChangedValueError
-          raise ActiveModel::CouldNotSetPasswordError.create(@subject.class)
+          raise ActiveModel::CouldNotSetPasswordError.create(model)
         end
 
-        def allows_original_or_typecast_value?(value, message)
-          allows_value_of(blank_value, @expected_message)
+        def allows_original_or_typecast_value?(value)
+          allows_value_of(value, @expected_message)
         end
 
-        def disallows_and_double_checks_value_of!(value, message)
-          disallows_value_of(value, message)
+        def disallows_and_double_checks_value_of!(value)
+          disallows_value_of(value, @expected_message)
         rescue ActiveModel::AllowValueMatcher::AttributeChangedValueError
-          raise ActiveModel::CouldNotSetPasswordError.create(@subject.class)
+          raise ActiveModel::CouldNotSetPasswordError.create(model)
         end
 
-        def disallows_original_or_typecast_value?(value, message)
-          disallows_value_of(blank_value, @expected_message)
+        def disallows_original_or_typecast_value?(value)
+          disallows_value_of(value, @expected_message)
         end
 
-        def blank_value
+        def disallowed_values
           if collection?
-            []
+            [Array.new]
           else
-            nil
+            values = []
+
+            if !association_being_validated?
+              values << ''
+            end
+
+            if !expects_to_allow_nil?
+              values << nil
+            end
+
+            values
           end
         end
 
         def collection?
-          if reflection
-            [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
+          if association_reflection
+            [:has_many, :has_and_belongs_to_many].include?(
+              association_reflection.macro,
+            )
           else
             false
           end
         end
 
-        def reflection
-          @subject.class.respond_to?(:reflect_on_association) &&
-            @subject.class.reflect_on_association(@attribute)
+        def should_add_footnote_about_belongs_to?
+          belongs_to_association_being_validated? &&
+            presence_validation_exists_on_attribute?
+        end
+
+        def reason_for_existing_presence_validation
+          if belongs_to_association_configured_to_be_required?
+            "you've instructed your `belongs_to` association to add a " +
+              'presence validation to the attribute'
+          else
+            # assume ::ActiveRecord::Base.belongs_to_required_by_default == true
+            'ActiveRecord is configured to add a presence validation to all ' +
+              '`belongs_to` associations, and this includes yours'
+          end
+        end
+
+        def suggestions_for_belongs_to
+          if belongs_to_association_configured_to_be_required?
+            <<~MESSAGE
+              one of the following instead, depending on your use case:
+
+                    #{example_of_belongs_to(with: [:optional, false])}
+                    #{example_of_belongs_to(with: [:required, true])}
+            MESSAGE
+          else
+            <<~MESSAGE
+              the following instead:
+
+                    #{example_of_belongs_to}
+            MESSAGE
+          end
+        end
+
+        def example_of_belongs_to(with: nil)
+          initial_call = "should belong_to(:#{association_name})"
+          inside =
+            if with
+              "#{initial_call}.#{with.first}(#{with.second})"
+            else
+              initial_call
+            end
+
+          if Shoulda::Matchers.integrations.test_frameworks.any?(&:n_unit?)
+            inside
+          else
+            "it { #{inside} }"
+          end
+        end
+
+        def belongs_to_association_configured_to_be_required?
+          association_options[:optional] == false ||
+            association_options[:required] == true
+        end
+
+        def belongs_to_association_being_validated?
+          association_being_validated? &&
+            association_reflection.macro == :belongs_to
+        end
+
+        def association_being_validated?
+          !!association_reflection
+        end
+
+        def association_name
+          association_reflection.name
+        end
+
+        def association_options
+          association_reflection&.options
+        end
+
+        def association_reflection
+          model.respond_to?(:reflect_on_association) &&
+            model.reflect_on_association(@attribute)
+        end
+
+        def presence_validation_exists_on_attribute?
+          model._validators.include?(@attribute)
+        end
+
+        def model
+          @subject.class
         end
       end
     end