shoulda-matchers 6.1.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 500d5928f097ad1ca9d9c1ed3a0e0c925f504549c1594b57e93efc92316df558
-  data.tar.gz: 8a94b930a96fe1f2e3a78c916ca4fa6b68c21ab61ae9baccb109ec51e9a2961c
+  metadata.gz: d549ac8f3629ad37bc56d0d09daf37416ec23d78374a8ed6a630ea23e5c9e487
+  data.tar.gz: f09bc94b6be181564cdde56729c2055192a4725adee4ba8b6b7f8e84429fe9a0
 SHA512:
-  metadata.gz: 43d89cf2b6684f31f6fee6611fe694732446d50aee9fea5b8a5fefc79cd5ec4dc08337cb098e531cbfe4eac3ac46ed6cda46c6207b2f35956cf9b07d2925af1a
-  data.tar.gz: 586d777927cdafba0aa92ecc6c437b562a24a44aa343a8be309ee7563a3a2b98e4426c8804f1c40ad46a1987ff7f160e97473fcd178f3fdb57c2c471d210044b
+  metadata.gz: 1f3ba08a6d15ad56cb583c0a8289e180854f5d89020b3182b2d6140289800d71bca467f187c9a4718ba26078cc2562f6377d77b00a0e84f2e683079d62ef60d3
+  data.tar.gz: 45d0141c79d9642439c9c03ffcd8e41d1aee993eafaea11fc72812456ead1dcf17d1698e9eb7f311c40945c54c77fc4e573a820ffa115fc344e9b0049ed69479

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,21 @@ 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/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/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,7 @@ module Shoulda
           end
 
           def symlink_to(parent)
-            namespace.set(name, parent.dup)
+            namespace.set(name, Class.new(parent))
           end
 
           def to_s

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.2.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.2.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-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -198,7 +198,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Simple one-liner tests for common Rails functionality