shoulda-matchers 6.1.0 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 500d5928f097ad1ca9d9c1ed3a0e0c925f504549c1594b57e93efc92316df558
-  data.tar.gz: 8a94b930a96fe1f2e3a78c916ca4fa6b68c21ab61ae9baccb109ec51e9a2961c
+  metadata.gz: 87a298f618f08949dbe1c165b17dfbfc940a6675b2f790e655c9a43568956c31
+  data.tar.gz: ea5eaad001d24f89a698a4a944f2596da029c019a4bcc2f893c0881146dea058
 SHA512:
-  metadata.gz: 43d89cf2b6684f31f6fee6611fe694732446d50aee9fea5b8a5fefc79cd5ec4dc08337cb098e531cbfe4eac3ac46ed6cda46c6207b2f35956cf9b07d2925af1a
-  data.tar.gz: 586d777927cdafba0aa92ecc6c437b562a24a44aa343a8be309ee7563a3a2b98e4426c8804f1c40ad46a1987ff7f160e97473fcd178f3fdb57c2c471d210044b
+  metadata.gz: bcaf6fc8e3e59cf1936c2a346d1a02c1269ab8e231b7820c273873ed81cf6f97501bf15ea44503f357008064f34eaec66bc9a81f2938fd3876078d707979daea
+  data.tar.gz: 94a53d9576ea0df451d2ff0ff34528f8c035699e9d216e877ced2cdff156ae0a5d18bc106dc0b5fc487aebfd56807bd836d2cb9aa51ababfc232be5e3b94c2cf

data/README.md

@@ -385,8 +385,10 @@ about any of them, make sure to [consult the documentation][rubydocs]!
   tests your `belongs_to` associations.
 * **[define_enum_for](lib/shoulda/matchers/active_record/define_enum_for_matcher.rb)**
   tests usage of the `enum` macro.
-* **[have_and_belong_to_many](lib/shoulda/matchers/active_record/association_matcher.rb#L827)**
+* **[have_and_belong_to_many](lib/shoulda/matchers/active_record/association_matcher.rb)**
   tests your `has_and_belongs_to_many` associations.
+* **[have_delegated_type](lib/shoulda/matchers/active_record/association_matcher.rb#L687)**
+  tests usage of the `delegated_type` macro.
 * **[have_db_column](lib/shoulda/matchers/active_record/have_db_column_matcher.rb)**
   tests that the table that backs your model has a specific column.
 * **[have_db_index](lib/shoulda/matchers/active_record/have_db_index_matcher.rb)**
@@ -515,16 +517,20 @@ redistributed under the terms specified in the [LICENSE](LICENSE) file.
 
 [thoughtbot-website]: https://thoughtbot.com
 
+<!-- START /templates/footer.md -->
 ## About thoughtbot
 
-![thoughtbot][thoughtbot-logo]
-
-[thoughtbot-logo]: https://thoughtbot.com/brand_assets/93:44.svg
+![thoughtbot](https://thoughtbot.com/thoughtbot-logo-for-readmes.svg)
 
+This repo 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].
+We love open source software!
+See [our other projects][community].
+We are [available for hire][hire].
 
 [community]: https://thoughtbot.com/community?utm_source=github
-[hire]: https://thoughtbot.com?utm_source=github
+[hire]: https://thoughtbot.com/hire-us?utm_source=github
+
+
+<!-- END /templates/footer.md -->

data/lib/shoulda/matchers/action_controller/respond_with_matcher.rb

@@ -133,7 +133,7 @@ module Shoulda
           when :missing  then 404
           when :error    then 500..599
           when Symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[potential_symbol]
+            ::Rack::Utils.status_code(potential_symbol)
           else
             potential_symbol
           end

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

@@ -169,6 +169,36 @@ module Shoulda
       #         on(:create)
       #     end
       #
+      # ##### against
+      #
+      # Use `against` if the validation is on an attribute
+      # other than the attribute being validated:
+      #
+      #     class UserProfile
+      #       include ActiveModel::Model
+      #       attr_accessor :website_url
+      #
+      #       alias_attribute :url, :website_url
+      #
+      #       validates_format_of :url, with: URI.regexp
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe UserProfile, type: :model do
+      #       it do
+      #         should allow_value('https://foo.com').
+      #           for(:website_url).
+      #           against(:url)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserProfileTest < ActiveSupport::TestCase
+      #       should allow_value('https://foo.com').
+      #         for(:website_url).
+      #         against(:url)
+      #     end
+      #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.
@@ -349,6 +379,12 @@ module Shoulda
           self
         end
 
+        def against(attribute)
+          @attribute_to_check_message_against = attribute if attribute.present?
+
+          self
+        end
+
         def with_message(message, given_options = {})
           if message.present?
             @expects_custom_validation_message = true

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

@@ -13,12 +13,12 @@ module Shoulda
       #
       #     # RSpec
       #     RSpec.describe Person, type: :model do
-      #       it { should validate_comparison_of(:gpa).greater_than(10) }
+      #       it { should validate_comparison_of(:gpa).is_greater_than(10) }
       #     end
       #
       #     # Minitest (Shoulda)
       #     class PersonTest < ActiveSupport::TestCase
-      #       should validate_comparison_of(:gpa).greater_than(10)
+      #       should validate_comparison_of(:gpa).is_greater_than(10)
       #     end
       #
       # #### Qualifiers
@@ -39,14 +39,14 @@ module Shoulda
       #     RSpec.describe Person, type: :model do
       #       it do
       #         should validate_comparison_of(:number_of_dependents).
-      #           greater_than(0).
+      #           is_greater_than(0).
       #           on(:create)
       #       end
       #     end
       #
       #     # Minitest (Shoulda)
       #     class PersonTest < ActiveSupport::TestCase
-      #       should validate_comparison_of(:number_of_dependents).greater_than(0).on(:create)
+      #       should validate_comparison_of(:number_of_dependents).is_greater_than(0).on(:create)
       #     end
       #
       # ##### is_less_than

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

@@ -309,8 +309,8 @@ EOT
 
         def in_range(range)
           @range = range
-          @minimum = range.first
-          @maximum = range.max
+          @minimum = minimum_range_value
+          @maximum = maximum_range_value
           self
         end
 
@@ -400,6 +400,18 @@ EOT
 
         private
 
+        def minimum_range_value
+          @range.begin
+        end
+
+        def maximum_range_value
+          if @range.exclude_end?
+            @range.end ? (@range.end - 1) : nil
+          else
+            @range.end
+          end
+        end
+
         def matches_for_range?
           disallows_lower_value &&
             allows_minimum_value &&
@@ -441,27 +453,27 @@ EOT
         end
 
         def allows_minimum_value
-          allows_value_of(@minimum, @low_message)
+          @minimum.nil? || allows_value_of(@minimum, @low_message)
         end
 
         def disallows_minimum_value
-          disallows_value_of(@minimum, @low_message)
+          @minimum.nil? || disallows_value_of(@minimum, @low_message)
         end
 
         def allows_maximum_value
-          allows_value_of(@maximum, @high_message)
+          @maximum.nil? || allows_value_of(@maximum, @high_message)
         end
 
         def disallows_maximum_value
-          disallows_value_of(@maximum, @high_message)
+          @maximum.nil? || disallows_value_of(@maximum, @high_message)
         end
 
         def allows_higher_value
-          allows_value_of(@maximum + 1, @high_message)
+          @maximum.nil? || allows_value_of(@maximum + 1, @high_message)
         end
 
         def disallows_higher_value
-          disallows_value_of(@maximum + 1, @high_message)
+          @maximum.nil? || disallows_value_of(@maximum + 1, @high_message)
         end
 
         def allows_all_values_in_array?

data/lib/shoulda/matchers/active_record/association_matcher.rb

@@ -144,6 +144,28 @@ module Shoulda
       #         with_foreign_key('country_id')
       #     end
       #
+      # ##### with_foreign_type
+      #
+      # Use `with_foreign_type` to test usage of the `:foreign_type` option.
+      #
+      #     class Visitor < ActiveRecord::Base
+      #       belongs_to :location, foreign_type: 'facility_type', polymorphic: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Visitor, type: :model do
+      #       it do
+      #         should belong_to(:location).
+      #           with_foreign_type('facility_type')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VisitorTest < ActiveSupport::TestCase
+      #       should belong_to(:location).
+      #         with_foreign_type('facility_type')
+      #     end
+      #
       # ##### dependent
       #
       # Use `dependent` to assert that the `:dependent` option was specified.
@@ -217,6 +239,36 @@ module Shoulda
       #       should belong_to(:organization).touch(true)
       #     end
       #
+      # ##### strict_loading
+      #
+      # Use `strict_loading` to assert that the `:strict_loading` option was specified.
+      #
+      #     class Organization < ActiveRecord::Base
+      #       has_many :people, strict_loading: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Organization, type: :model do
+      #       it { should have_many(:people).strict_loading(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class OrganizationTest < ActiveSupport::TestCase
+      #       should have_many(:people).strict_loading(true)
+      #     end
+      #
+      # Default value is true when no argument is specified
+      #
+      #     # RSpec
+      #     RSpec.describe Organization, type: :model do
+      #       it { should have_many(:people).strict_loading }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class OrganizationTest < ActiveSupport::TestCase
+      #       should have_many(:people).strict_loading
+      #     end
+      #
       # ##### autosave
       #
       # Use `autosave` to assert that the `:autosave` option was specified.
@@ -326,6 +378,316 @@ module Shoulda
         AssociationMatcher.new(:belongs_to, name)
       end
 
+      # The `have_delegated_type` matcher is used to ensure that a `belong_to` association
+      # exists on your model using the delegated_type macro.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck)
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it { should have_delegated_type(:drivable) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### types
+      #
+      # Use `types` to test the types that are allowed for the association.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck)
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it do
+      #         should have_delegated_type(:drivable).
+      #           types(%w(Car Truck))
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).
+      #         types(%w(Car Truck))
+      #     end
+      #
+      # ##### conditions
+      #
+      # Use `conditions` if your association is defined with a scope that sets
+      # the `where` clause.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), scope: -> { where(with_wheels: true) }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it do
+      #         should have_delegated_type(:drivable).
+      #           conditions(with_wheels: true)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).
+      #         conditions(everyone_is_perfect: false)
+      #     end
+      #
+      # ##### order
+      #
+      # Use `order` if your association is defined with a scope that sets the
+      # `order` clause.
+      #
+      #     class Person < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), scope: -> { order('wheels desc') }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it { should have_delegated_type(:drivable).order('wheels desc') }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).order('wheels desc')
+      #     end
+      #
+      # ##### with_primary_key
+      #
+      # Use `with_primary_key` to test usage of the `:primary_key` option.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), primary_key: 'vehicle_id'
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it do
+      #         should have_delegated_type(:drivable).
+      #           with_primary_key('vehicle_id')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).
+      #         with_primary_key('vehicle_id')
+      #     end
+      #
+      # ##### with_foreign_key
+      #
+      # Use `with_foreign_key` to test usage of the `:foreign_key` option.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), foreign_key: 'drivable_uuid'
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it do
+      #         should have_delegated_type(:drivable).
+      #           with_foreign_key('drivable_uuid')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).
+      #         with_foreign_key('drivable_uuid')
+      #     end
+      #
+      # ##### dependent
+      #
+      # Use `dependent` to assert that the `:dependent` option was specified.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), dependent: :destroy
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it { should have_delegated_type(:drivable).dependent(:destroy) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).dependent(:destroy)
+      #     end
+      #
+      # To assert that *any* `:dependent` option was specified, use `true`:
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it { should have_delegated_type(:drivable).dependent(true) }
+      #     end
+      #
+      # To assert that *no* `:dependent` option was specified, use `false`:
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck)
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it { should have_delegated_type(:drivable).dependent(false) }
+      #     end
+      #
+      # ##### counter_cache
+      #
+      # Use `counter_cache` to assert that the `:counter_cache` option was
+      # specified.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), counter_cache: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it { should have_delegated_type(:drivable).counter_cache(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).counter_cache(true)
+      #     end
+      #
+      # ##### touch
+      #
+      # Use `touch` to assert that the `:touch` option was specified.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), touch: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it { should have_delegated_type(:drivable).touch(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).touch(true)
+      #     end
+      #
+      # ##### autosave
+      #
+      # Use `autosave` to assert that the `:autosave` option was specified.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), autosave: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Vehicle, type: :model do
+      #       it { should have_delegated_type(:drivable).autosave(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).autosave(true)
+      #     end
+      #
+      # ##### inverse_of
+      #
+      # Use `inverse_of` to assert that the `:inverse_of` option was specified.
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), inverse_of: :vehicle
+      #     end
+      #
+      #     # RSpec
+      #     describe Vehicle
+      #       it { should have_delegated_type(:drivable).inverse_of(:vehicle) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).inverse_of(:vehicle)
+      #     end
+      #
+      # ##### required
+      #
+      # Use `required` to assert that the association is not allowed to be nil.
+      # (Enabled by default in Rails 5+.)
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), required: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Vehicle
+      #       it { should have_delegated_type(:drivable).required }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).required
+      #     end
+      #
+      # ##### without_validating_presence
+      #
+      # Use `without_validating_presence` with `belong_to` to prevent the
+      # matcher from checking whether the association disallows nil (Rails 5+
+      # only). This can be helpful if you have a custom hook that always sets
+      # the association to a meaningful value:
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck)
+      #
+      #       before_validation :autoassign_drivable
+      #
+      #       private
+      #
+      #       def autoassign_drivable
+      #         self.drivable = Car.create!
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe Vehicle
+      #       it { should have_delegated_type(:drivable).without_validating_presence }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).without_validating_presence
+      #     end
+      #
+      # ##### optional
+      #
+      # Use `optional` to assert that the association is allowed to be nil.
+      # (Rails 5+ only.)
+      #
+      #     class Vehicle < ActiveRecord::Base
+      #       delegated_type :drivable, types: %w(Car Truck), optional: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Vehicle
+      #       it { should have_delegated_type(:drivable).optional }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class VehicleTest < ActiveSupport::TestCase
+      #       should have_delegated_type(:drivable).optional
+      #     end
+      #
+      # @return [AssociationMatcher]
+      #
+
+      def have_delegated_type(name)
+        AssociationMatcher.new(:belongs_to, name)
+      end
+
       # The `have_many` matcher is used to test that a `has_many` or `has_many
       # :through` association exists on your model.
       #
@@ -455,6 +817,24 @@ module Shoulda
       #       should have_many(:worries).with_foreign_key('worrier_id')
       #     end
       #
+      # ##### with_foreign_type
+      #
+      # Use `with_foreign_type` to test usage of the `:foreign_type` option.
+      #
+      #     class Hotel < ActiveRecord::Base
+      #       has_many :visitors, foreign_key: 'facility_type', as: :location
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Hotel, type: :model do
+      #       it { should have_many(:visitors).with_foreign_type('facility_type') }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class HotelTest < ActiveSupport::TestCase
+      #       should have_many(:visitors).with_foreign_type('facility_type')
+      #     end
+      #
       # ##### dependent
       #
       # Use `dependent` to assert that the `:dependent` option was specified.
@@ -726,6 +1106,24 @@ module Shoulda
       #       should have_one(:job).with_foreign_key('worker_id')
       #     end
       #
+      # ##### with_foreign_type
+      #
+      # Use `with_foreign_type` to test usage of the `:foreign_type` option.
+      #
+      #     class Hotel < ActiveRecord::Base
+      #       has_one :special_guest, foreign_type: 'facility_type', as: :location
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Hotel, type: :model do
+      #       it { should have_one(:special_guest).with_foreign_type('facility_type') }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class HotelTest < ActiveSupport::TestCase
+      #       should have_one(:special_guest).with_foreign_type('facility_type')
+      #     end
+      #
       # ##### through
       #
       # Use `through` to test usage of the `:through` option. This asserts that
@@ -1068,6 +1466,11 @@ module Shoulda
           self
         end
 
+        def types(types)
+          @options[:types] = types
+          self
+        end
+
         def autosave(autosave)
           @options[:autosave] = autosave
           self
@@ -1088,6 +1491,11 @@ module Shoulda
           self
         end
 
+        def with_foreign_type(foreign_type)
+          @options[:foreign_type] = foreign_type
+          self
+        end
+
         def with_primary_key(primary_key)
           @options[:primary_key] = primary_key
           self
@@ -1128,6 +1536,11 @@ module Shoulda
           self
         end
 
+        def strict_loading(strict_loading = true)
+          @options[:strict_loading] = strict_loading
+          self
+        end
+
         def join_table(join_table_name)
           @options[:join_table_name] = join_table_name
           self
@@ -1160,6 +1573,7 @@ module Shoulda
             macro_correct? &&
             validate_inverse_of_through_association &&
             (polymorphic? || class_exists?) &&
+            foreign_type_matches? &&
             foreign_key_exists? &&
             primary_key_exists? &&
             query_constraints_exists? &&
@@ -1170,6 +1584,8 @@ module Shoulda
             conditions_correct? &&
             validate_correct? &&
             touch_correct? &&
+            types_correct? &&
+            strict_loading_correct? &&
             submatchers_match?
         end
 
@@ -1265,14 +1681,24 @@ module Shoulda
         end
 
         def macro_is_not_through?
-          macro == :belongs_to ||
-            ([:has_many, :has_one].include?(macro) && !through?)
+          macro == :belongs_to || has_association_not_through?
+        end
+
+        def has_association_not_through?
+          [:has_many, :has_one].include?(macro) && !through?
         end
 
         def foreign_key_exists?
           !(belongs_foreign_key_missing? || has_foreign_key_missing?)
         end
 
+        def foreign_type_matches?
+          !options.key?(:foreign_type) || (
+            !belongs_foreign_type_missing? &&
+            !has_foreign_type_missing?
+          )
+        end
+
         def primary_key_exists?
           !macro_is_not_through? || primary_key_correct?(model_class)
         end
@@ -1299,12 +1725,20 @@ module Shoulda
           macro == :belongs_to && !class_has_foreign_key?(model_class)
         end
 
+        def belongs_foreign_type_missing?
+          macro == :belongs_to && !class_has_foreign_type?(model_class)
+        end
+
         def has_foreign_key_missing?
-          [:has_many, :has_one].include?(macro) &&
-            !through? &&
+          has_association_not_through? &&
             !class_has_foreign_key?(associated_class)
         end
 
+        def has_foreign_type_missing?
+          has_association_not_through? &&
+            !class_has_foreign_type?(associated_class)
+        end
+
         def class_name_correct?
           if options.key?(:class_name)
             if option_verifier.correct_for_constant?(
@@ -1414,6 +1848,45 @@ module Shoulda
           end
         end
 
+        def types_correct?
+          if options.key?(:types)
+            types = options[:types]
+
+            correct = types.all? do |type|
+              scope_name = type.tableize.tr('/', '_')
+              singular   = scope_name.singularize
+              query      = "#{singular}?"
+
+              Object.const_defined?(type) && @subject.respond_to?(query) &&
+                @subject.respond_to?(singular)
+            end
+
+            if correct
+              true
+            else
+              @missing = "#{name} should have types: #{options[:types]}"
+              false
+            end
+          else
+            true
+          end
+        end
+
+        def strict_loading_correct?
+          return true unless options.key?(:strict_loading)
+
+          if option_verifier.correct_for_boolean?(:strict_loading, options[:strict_loading])
+            return true
+          end
+
+          @missing = [
+            "#{name} should have strict_loading set to ",
+            options[:strict_loading].to_s,
+          ].join
+
+          false
+        end
+
         def class_has_foreign_key?(klass)
           @missing = validate_foreign_key(klass)
 
@@ -1428,6 +1901,22 @@ module Shoulda
           end
         end
 
+        def class_has_foreign_type?(klass)
+          if options.key?(:foreign_type) && !foreign_type_correct?
+            @missing = foreign_type_failure_message(
+              klass,
+              options[:foreign_type],
+            )
+
+            false
+          elsif !has_column?(klass, foreign_type)
+            @missing = foreign_type_failure_message(klass, foreign_type)
+            false
+          else
+            true
+          end
+        end
+
         def has_column?(klass, column)
           case column
           when Array
@@ -1444,10 +1933,21 @@ module Shoulda
           )
         end
 
+        def foreign_type_correct?
+          option_verifier.correct_for_string?(
+            :foreign_type,
+            options[:foreign_type],
+          )
+        end
+
         def foreign_key_failure_message(klass, foreign_key)
           "#{klass} does not have a #{foreign_key} foreign key."
         end
 
+        def foreign_type_failure_message(klass, foreign_type)
+          "#{klass} does not have a #{foreign_type} foreign type."
+        end
+
         def primary_key_correct?(klass)
           if options.key?(:primary_key)
             if option_verifier.correct_for_string?(
@@ -1490,6 +1990,14 @@ module Shoulda
           end
         end
 
+        def foreign_type
+          if [:has_one, :has_many].include?(macro)
+            reflection.type
+          else
+            reflection.foreign_type
+          end
+        end
+
         def submatchers_match?
           failing_submatchers.empty?
         end

data/lib/shoulda/matchers/active_record/association_matchers/model_reflection.rb

@@ -13,7 +13,11 @@ module Shoulda
           end
 
           def associated_class
-            reflection.klass
+            if polymorphic?
+              subject
+            else
+              reflection.klass
+            end
           end
 
           def polymorphic?
@@ -70,6 +74,10 @@ module Shoulda
             reflection.options[:through]
           end
 
+          def strict_loading?
+            reflection.options.fetch(:strict_loading, subject.strict_loading_by_default)
+          end
+
           protected
 
           attr_reader :reflection, :subject

data/lib/shoulda/matchers/active_record/association_matchers/model_reflector.rb

@@ -8,6 +8,7 @@ module Shoulda
             :associated_class,
             :association_foreign_key,
             :foreign_key,
+            :foreign_type,
             :has_and_belongs_to_many_name,
             :join_table_name,
             :polymorphic?,

data/lib/shoulda/matchers/active_record/association_matchers/option_verifier.rb

@@ -122,6 +122,10 @@ module Shoulda
             reflector.associated_class
           end
 
+          def actual_value_for_strict_loading
+            reflection.strict_loading?
+          end
+
           def actual_value_for_option(name)
             option_value = reflection.options[name]
 

data/lib/shoulda/matchers/active_record/define_enum_for_matcher.rb

@@ -187,8 +187,95 @@ module Shoulda
       #         without_scopes
       #     end
       #
-      # @return [DefineEnumForMatcher]
+      # ##### with_default
+      #
+      # Use `with_default` to test that the enum is defined with a
+      # default value. A proc can also be passed, and will be called once each
+      # time a new value is needed. (If using Time or Date, it's recommended to
+      # freeze time or date to avoid flaky tests):
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], default: :closed
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           with_default(:closed)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         with_default(:closed)
+      #     end
       #
+      # ##### validating
+      #
+      # Use `validating` to test that the enum is being validated.
+      # Can take a boolean value and an allowing_nil keyword argument:
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], validate: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           validating
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         validating
+      #     end
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], validate: { allow_nil: true }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           validating(allowing_nil: true)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         validating(allowing_nil: true)
+      #     end
+      #
+      # ##### without_instance_methods
+      #
+      # Use `without_instance_methods` to exclude the check for instance methods.
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], instance_methods: false
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           without_instance_methods
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         without_instance_methods
+      #     end
+      #
+      # @return [DefineEnumForMatcher]
       def define_enum_for(attribute_name)
         DefineEnumForMatcher.new(attribute_name)
       end
@@ -197,7 +284,7 @@ module Shoulda
       class DefineEnumForMatcher
         def initialize(attribute_name)
           @attribute_name = attribute_name
-          @options = { expected_enum_values: [], scopes: true }
+          @options = { expected_enum_values: [], scopes: true, instance_methods: true }
         end
 
         def description
@@ -222,6 +309,12 @@ module Shoulda
           description
         end
 
+        def validating(value = true, allowing_nil: false)
+          options[:validating] = value
+          options[:allowing_nil] = allowing_nil
+          self
+        end
+
         def with_values(expected_enum_values)
           options[:expected_enum_values] = expected_enum_values
           self
@@ -247,6 +340,16 @@ module Shoulda
           self
         end
 
+        def without_instance_methods
+          options[:instance_methods] = false
+          self
+        end
+
+        def with_default(default_value)
+          options[:default] = default_value
+          self
+        end
+
         def matches?(subject)
           @record = subject
 
@@ -254,7 +357,9 @@ module Shoulda
             enum_values_match? &&
             column_type_matches? &&
             enum_value_methods_exist? &&
-            scope_presence_matches?
+            scope_presence_matches? &&
+            default_value_matches? &&
+            validating_matches?
         end
 
         def failure_message
@@ -277,6 +382,30 @@ module Shoulda
 
         private
 
+        def validating_matches?
+          return true if options[:validating].nil?
+
+          validator = find_enum_validator
+
+          if expected_validating? == !!validator
+            if validator&.options&.dig(:allow_nil).present? == expected_allowing_nil?
+              true
+            else
+              @failure_message_continuation =
+                "However, #{attribute_name.inspect} is allowing nil values"
+              false
+            end
+          else
+            @failure_message_continuation =
+              if expected_validating?
+                "However, #{attribute_name.inspect} is not being validated"
+              else
+                "However, #{attribute_name.inspect} is being validated"
+              end
+            false
+          end
+        end
+
         attr_reader :attribute_name, :options, :record,
           :failure_message_continuation
 
@@ -292,6 +421,21 @@ module Shoulda
               )
             end
 
+            if options[:default].present?
+              expectation << ', with a default value of '
+              expectation << Shoulda::Matchers::Util.inspect_value(expected_default_value)
+            end
+
+            if expected_validating?
+              expectation << ', and being validated '
+              expectation <<
+                if expected_allowing_nil?
+                  'allowing nil values'
+                else
+                  'not allowing nil values'
+                end
+            end
+
             if expected_prefix
               expectation <<
                 if expected_suffix
@@ -413,16 +557,24 @@ module Shoulda
         end
 
         def enum_value_methods_exist?
-          if instance_methods_exist?
-            true
-          else
+          if options[:instance_methods]
+            return true if instance_methods_exist?
+
             message = missing_methods_message
+            message << " (we can't tell which)" if [expected_prefix, expected_suffix].any?
+
+            @failure_message_continuation = message
 
-            message << " (we can't tell which)"
+            false
+          elsif instance_methods_exist?
+            message = "#{attribute_name.inspect} does map to these values"
+            message << ' with instance methods, but expected no instance methods'
 
             @failure_message_continuation = message
 
             false
+          else
+            true
           end
         end
 
@@ -471,11 +623,50 @@ module Shoulda
           elsif expected_suffix
             message << 'configured with either a different suffix or no '
             message << 'suffix at all'
+          elsif expected_instance_methods?
+            message << 'configured with no instance methods'
           else
             ''
           end
         end
 
+        def default_value_matches?
+          return true if options[:default].blank?
+
+          if actual_default_value.nil?
+            @failure_message_continuation = 'However, no default value was set'
+            return false
+          end
+
+          if actual_default_value == expected_default_value
+            true
+          else
+            String.new.tap do |message|
+              message << 'However, the default value is '
+              message << Shoulda::Matchers::Util.inspect_value(actual_default_value)
+              @failure_message_continuation = message
+            end
+            false
+          end
+        end
+
+        def expected_default_value
+          options[:default].respond_to?(:call) ? options[:default].call : options[:default]
+        end
+
+        def actual_default_value
+          attribute_schema = model.attributes_to_define_after_schema_loads[attribute_name.to_s]
+
+          value = case attribute_schema
+                  in [_, { default: default_value } ]
+                    default_value
+                  in [_, default_value]
+                    default_value
+                  end
+
+          value.respond_to?(:call) ? value.call : value
+        end
+
         def singleton_methods_exist?
           expected_singleton_methods.all? do |method|
             model.singleton_methods.include?(method)
@@ -509,6 +700,10 @@ module Shoulda
           end
         end
 
+        def expected_instance_methods?
+          options[:instance_methods]
+        end
+
         def expected_prefix
           if options.include?(:prefix)
             if options[:prefix] == true
@@ -529,6 +724,22 @@ module Shoulda
           end
         end
 
+        def expected_validating?
+          options[:validating].present?
+        end
+
+        def expected_allowing_nil?
+          options[:allowing_nil].present?
+        end
+
+        def find_enum_validator
+          record.class.validators.detect do |validator|
+            validator.kind == :inclusion &&
+              validator.attributes.include?(attribute_name.to_s) &&
+              validator.options[:in] == expected_enum_values
+          end
+        end
+
         def exclude_scopes?
           !options[:scopes]
         end

data/lib/shoulda/matchers/active_record/normalize_matcher.rb

@@ -40,7 +40,7 @@ module Shoulda
       #
       #     # Minitest (Shoulda)
       #     class User < ActiveSupport::TestCase
-      #       should normalize(:email, handle).from(" Example\n").to("example")
+      #       should normalize(:email, :handle).from(" Example\n").to("example")
       #     end
       #
       # If the normalization accepts nil values with the `apply_to_nil` option,

data/lib/shoulda/matchers/active_record/uniqueness/model.rb

@@ -29,7 +29,19 @@ module Shoulda
           end
 
           def symlink_to(parent)
-            namespace.set(name, parent.dup)
+            table_name = parent.table_name
+
+            new_class = Class.new(parent) do
+              define_singleton_method :table_name do
+                table_name
+              end
+
+              define_singleton_method :base_class do
+                self
+              end
+            end
+
+            namespace.set(name, new_class)
           end
 
           def to_s

data/lib/shoulda/matchers/doublespeak.rb

@@ -1,5 +1,4 @@
 require 'forwardable'
-require 'logger'
 
 module Shoulda
   module Matchers

data/lib/shoulda/matchers/integrations/libraries/action_controller.rb

@@ -12,15 +12,17 @@ module Shoulda
           def integrate_with(test_framework)
             test_framework.include(matchers_module, type: :controller)
 
-            include_into(::ActionController::TestCase, matchers_module) do
-              def subject # rubocop:disable Lint/NestedMethodDefinition
-                @controller
+            tap do |instance|
+              ActiveSupport.on_load(:action_controller_test_case, run_once: true) do
+                instance.include_into(::ActionController::TestCase, instance.matchers_module) do
+                  def subject # rubocop:disable Lint/NestedMethodDefinition
+                    @controller
+                  end
+                end
               end
             end
           end
 
-          private
-
           def matchers_module
             Shoulda::Matchers::ActionController
           end

data/lib/shoulda/matchers/integrations/libraries/routing.rb

@@ -12,11 +12,13 @@ module Shoulda
           def integrate_with(test_framework)
             test_framework.include(matchers_module, type: :routing)
 
-            include_into(::ActionController::TestCase, matchers_module)
+            tap do |instance|
+              ActiveSupport.on_load(:action_controller_test_case, run_once: true) do
+                instance.include_into(::ActionController::TestCase, instance.matchers_module)
+              end
+            end
           end
 
-          private
-
           def matchers_module
             Shoulda::Matchers::Routing
           end

data/lib/shoulda/matchers/util.rb

@@ -66,7 +66,7 @@ module Shoulda
       end
 
       def self.inspect_range(range)
-        "#{inspect_value(range.first)} to #{inspect_value(range.last)}"
+        "#{inspect_value(range.begin)} to #{inspect_value(range.end)}"
       end
 
       def self.inspect_hash(hash)

data/lib/shoulda/matchers/version.rb

@@ -1,6 +1,6 @@
 module Shoulda
   module Matchers
     # @private
-    VERSION = '6.1.0'.freeze
+    VERSION = '6.3.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shoulda-matchers
 version: !ruby/object:Gem::Version
-  version: 6.1.0
+  version: 6.3.0
 platform: ruby
 authors:
 - Tammer Saleh
@@ -14,7 +14,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-19 00:00:00.000000000 Z
+date: 2024-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport