shoulda-matchers 4.1.2 → 4.5.0

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

@@ -108,14 +108,14 @@ module Shoulda
           {
             all_validation_errors: all_validation_errors,
             validation_error_messages: validation_error_messages,
-            validation_exception_message: nil
+            validation_exception_message: nil,
           }
-        rescue ::ActiveModel::StrictValidationFailed => exception
+        rescue ::ActiveModel::StrictValidationFailed => e
           @captured_validation_exception = true
           {
             all_validation_errors: nil,
             validation_error_messages: [],
-            validation_exception_message: exception.message
+            validation_exception_message: e.message,
           }
         end
       end

data/lib/shoulda/matchers/active_record.rb

@@ -1,26 +1,29 @@
-require "shoulda/matchers/active_record/association_matcher"
-require "shoulda/matchers/active_record/association_matchers"
-require "shoulda/matchers/active_record/association_matchers/counter_cache_matcher"
-require "shoulda/matchers/active_record/association_matchers/inverse_of_matcher"
-require "shoulda/matchers/active_record/association_matchers/join_table_matcher"
-require "shoulda/matchers/active_record/association_matchers/order_matcher"
-require "shoulda/matchers/active_record/association_matchers/through_matcher"
-require "shoulda/matchers/active_record/association_matchers/dependent_matcher"
-require "shoulda/matchers/active_record/association_matchers/required_matcher"
-require "shoulda/matchers/active_record/association_matchers/optional_matcher"
-require "shoulda/matchers/active_record/association_matchers/source_matcher"
-require "shoulda/matchers/active_record/association_matchers/model_reflector"
-require "shoulda/matchers/active_record/association_matchers/model_reflection"
-require "shoulda/matchers/active_record/association_matchers/option_verifier"
-require "shoulda/matchers/active_record/have_db_column_matcher"
-require "shoulda/matchers/active_record/have_db_index_matcher"
-require "shoulda/matchers/active_record/have_readonly_attribute_matcher"
-require "shoulda/matchers/active_record/have_secure_token_matcher"
-require "shoulda/matchers/active_record/serialize_matcher"
-require "shoulda/matchers/active_record/accept_nested_attributes_for_matcher"
-require "shoulda/matchers/active_record/define_enum_for_matcher"
-require "shoulda/matchers/active_record/uniqueness"
-require "shoulda/matchers/active_record/validate_uniqueness_of_matcher"
+require 'shoulda/matchers/active_record/association_matcher'
+require 'shoulda/matchers/active_record/association_matchers'
+require 'shoulda/matchers/active_record/association_matchers/counter_cache_matcher'
+require 'shoulda/matchers/active_record/association_matchers/inverse_of_matcher'
+require 'shoulda/matchers/active_record/association_matchers/join_table_matcher'
+require 'shoulda/matchers/active_record/association_matchers/order_matcher'
+require 'shoulda/matchers/active_record/association_matchers/through_matcher'
+require 'shoulda/matchers/active_record/association_matchers/dependent_matcher'
+require 'shoulda/matchers/active_record/association_matchers/required_matcher'
+require 'shoulda/matchers/active_record/association_matchers/optional_matcher'
+require 'shoulda/matchers/active_record/association_matchers/source_matcher'
+require 'shoulda/matchers/active_record/association_matchers/model_reflector'
+require 'shoulda/matchers/active_record/association_matchers/model_reflection'
+require 'shoulda/matchers/active_record/association_matchers/option_verifier'
+require 'shoulda/matchers/active_record/have_db_column_matcher'
+require 'shoulda/matchers/active_record/have_db_index_matcher'
+require 'shoulda/matchers/active_record/have_implicit_order_column'
+require 'shoulda/matchers/active_record/have_readonly_attribute_matcher'
+require 'shoulda/matchers/active_record/have_rich_text_matcher'
+require 'shoulda/matchers/active_record/have_secure_token_matcher'
+require 'shoulda/matchers/active_record/serialize_matcher'
+require 'shoulda/matchers/active_record/accept_nested_attributes_for_matcher'
+require 'shoulda/matchers/active_record/define_enum_for_matcher'
+require 'shoulda/matchers/active_record/uniqueness'
+require 'shoulda/matchers/active_record/validate_uniqueness_of_matcher'
+require 'shoulda/matchers/active_record/have_attached_matcher'
 
 module Shoulda
   module Matchers

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

@@ -158,17 +158,20 @@ module Shoulda
         end
 
         def allow_destroy_correct?
-          failure_message = "#{should_or_should_not(@options[:allow_destroy])} allow destroy"
+          failure_message = "#{should_or_should_not(@options[:allow_destroy])}"\
+            ' allow destroy'
           verify_option_is_correct(:allow_destroy, failure_message)
         end
 
         def limit_correct?
-          failure_message = "limit should be #{@options[:limit]}, got #{config[:limit]}"
+          failure_message = "limit should be #{@options[:limit]},"\
+            " got #{config[:limit]}"
           verify_option_is_correct(:limit, failure_message)
         end
 
         def update_only_correct?
-          failure_message = "#{should_or_should_not(@options[:update_only])} be update only"
+          failure_message = "#{should_or_should_not(@options[:update_only])}"\
+            ' be update only'
           verify_option_is_correct(:update_only, failure_message)
         end
 

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

@@ -920,21 +920,21 @@ module Shoulda
       # asserts that the table you're referring to actually exists.
       #
       #     class Person < ActiveRecord::Base
-      #       has_and_belongs_to_many :issues, join_table: 'people_tickets'
+      #       has_and_belongs_to_many :issues, join_table: :people_tickets
       #     end
       #
       #     # RSpec
       #     RSpec.describe Person, type: :model do
       #       it do
       #         should have_and_belong_to_many(:issues).
-      #           join_table('people_tickets')
+      #           join_table(:people_tickets)
       #       end
       #     end
       #
       #     # Minitest (Shoulda)
       #     class PersonTest < ActiveSupport::TestCase
       #       should have_and_belong_to_many(:issues).
-      #         join_table('people_tickets')
+      #         join_table(:people_tickets)
       #     end
       #
       # ##### validate
@@ -985,6 +985,13 @@ module Shoulda
 
       # @private
       class AssociationMatcher
+        MACROS = {
+          'belongs_to' => 'belong to',
+          'has_many' => 'have many',
+          'has_one' => 'have one',
+          'has_and_belongs_to_many' => 'have and belong to many',
+        }.freeze
+
         delegate :reflection, :model_class, :associated_class, :through?,
           :polymorphic?, to: :reflector
 
@@ -1096,12 +1103,12 @@ module Shoulda
           self
         end
 
-        def optional
+        def optional(optional = true)
           remove_submatcher(AssociationMatchers::RequiredMatcher)
           add_submatcher(
             AssociationMatchers::OptionalMatcher,
             name,
-            true,
+            optional,
           )
           self
         end
@@ -1128,7 +1135,9 @@ module Shoulda
 
         def description
           description = "#{macro_description} #{name}"
-          description += " class_name => #{options[:class_name]}" if options.key?(:class_name)
+          if options.key?(:class_name)
+            description += " class_name => #{options[:class_name]}"
+          end
           [description, submatchers.map(&:description)].flatten.join(' ')
         end
 
@@ -1144,6 +1153,7 @@ module Shoulda
           @subject = subject
           association_exists? &&
             macro_correct? &&
+            validate_inverse_of_through_association &&
             (polymorphic? || class_exists?) &&
             foreign_key_exists? &&
             primary_key_exists? &&
@@ -1162,7 +1172,8 @@ module Shoulda
         end
 
         def option_verifier
-          @option_verifier ||= AssociationMatchers::OptionVerifier.new(reflector)
+          @_option_verifier ||=
+            AssociationMatchers::OptionVerifier.new(reflector)
         end
 
         protected
@@ -1170,7 +1181,7 @@ module Shoulda
         attr_reader :submatchers, :missing, :subject, :macro
 
         def reflector
-          @reflector ||= AssociationMatchers::ModelReflector.new(subject, name)
+          @_reflector ||= AssociationMatchers::ModelReflector.new(subject, name)
         end
 
         def add_submatcher(matcher_class, *args)
@@ -1185,20 +1196,18 @@ module Shoulda
         end
 
         def macro_description
-          case macro.to_s
-          when 'belongs_to'
-            'belong to'
-          when 'has_many'
-            'have many'
-          when 'has_one'
-            'have one'
-          when 'has_and_belongs_to_many'
-            'have and belong to many'
-          end
+          MACROS[macro.to_s]
         end
 
         def expectation
-          "#{model_class.name} to have a #{macro} association called #{name}"
+          expectation =
+            "#{model_class.name} to have a #{macro} association called #{name}"
+
+          if through?
+            expectation << " through #{reflector.has_and_belongs_to_many_name}"
+          end
+
+          expectation
         end
 
         def missing_options
@@ -1207,14 +1216,14 @@ module Shoulda
         end
 
         def failing_submatchers
-          @failing_submatchers ||= submatchers.select do |matcher|
-            !matcher.matches?(subject)
+          @_failing_submatchers ||= submatchers.reject do |matcher|
+            matcher.matches?(subject)
           end
         end
 
         def missing_options_for_failing_submatchers
-          if defined?(@failing_submatchers)
-            @failing_submatchers.map(&:missing_option)
+          if defined?(@_failing_submatchers)
+            @_failing_submatchers.map(&:missing_option)
           else
             []
           end
@@ -1241,6 +1250,14 @@ module Shoulda
           end
         end
 
+        def validate_inverse_of_through_association
+          reflector.validate_inverse_of_through_association!
+          true
+        rescue ::ActiveRecord::ActiveRecordError => e
+          @missing = e.message
+          false
+        end
+
         def macro_supports_primary_key?
           macro == :belongs_to ||
             ([:has_many, :has_one].include?(macro) && !through?)
@@ -1266,10 +1283,14 @@ module Shoulda
 
         def class_name_correct?
           if options.key?(:class_name)
-            if option_verifier.correct_for_constant?(:class_name, options[:class_name])
+            if option_verifier.correct_for_constant?(
+              :class_name,
+              options[:class_name],
+            )
               true
             else
-              @missing = "#{name} should resolve to #{options[:class_name]} for class_name"
+              @missing = "#{name} should resolve to #{options[:class_name]}"\
+                ' for class_name'
               false
             end
           else
@@ -1278,7 +1299,10 @@ module Shoulda
         end
 
         def join_table_correct?
-          if macro != :has_and_belongs_to_many || join_table_matcher.matches?(@subject)
+          if (
+            macro != :has_and_belongs_to_many ||
+            join_table_matcher.matches?(@subject)
+          )
             true
           else
             @missing = join_table_matcher.failure_message
@@ -1287,8 +1311,10 @@ module Shoulda
         end
 
         def join_table_matcher
-          @join_table_matcher ||=
-            AssociationMatchers::JoinTableMatcher.new(self, reflector)
+          @_join_table_matcher ||= AssociationMatchers::JoinTableMatcher.new(
+            self,
+            reflector,
+          )
         end
 
         def class_exists?
@@ -1301,10 +1327,14 @@ module Shoulda
 
         def autosave_correct?
           if options.key?(:autosave)
-            if option_verifier.correct_for_boolean?(:autosave, options[:autosave])
+            if option_verifier.correct_for_boolean?(
+              :autosave,
+              options[:autosave],
+            )
               true
             else
-              @missing = "#{name} should have autosave set to #{options[:autosave]}"
+              @missing = "#{name} should have autosave set to"\
+                " #{options[:autosave]}"
               false
             end
           else
@@ -1317,23 +1347,27 @@ module Shoulda
 
           if option_verifier.correct_for_boolean?(
             :index_errors,
-            options[:index_errors]
+            options[:index_errors],
           )
             true
           else
             @missing =
               "#{name} should have index_errors set to " +
-              "#{options[:index_errors]}"
+              options[:index_errors].to_s
             false
           end
         end
 
         def conditions_correct?
           if options.key?(:conditions)
-            if option_verifier.correct_for_relation_clause?(:conditions, options[:conditions])
+            if option_verifier.correct_for_relation_clause?(
+              :conditions,
+              options[:conditions],
+            )
               true
             else
-              @missing = "#{name} should have the following conditions: #{options[:conditions]}"
+              @missing = "#{name} should have the following conditions:" +
+                         " #{options[:conditions]}"
               false
             end
           else
@@ -1360,22 +1394,38 @@ module Shoulda
         end
 
         def class_has_foreign_key?(klass)
-          if options.key?(:foreign_key)
-            option_verifier.correct_for_string?(:foreign_key, options[:foreign_key])
-          elsif column_names_for(klass).include?(foreign_key)
-            true
-          else
-            @missing = "#{klass} does not have a #{foreign_key} foreign key."
+          if options.key?(:foreign_key) && !foreign_key_correct?
+            @missing = foreign_key_failure_message(klass, options[:foreign_key])
             false
+          elsif !column_names_for(klass).include?(foreign_key)
+            @missing = foreign_key_failure_message(klass, foreign_key)
+            false
+          else
+            true
           end
         end
 
+        def foreign_key_correct?
+          option_verifier.correct_for_string?(
+            :foreign_key,
+            options[:foreign_key],
+          )
+        end
+
+        def foreign_key_failure_message(klass, foreign_key)
+          "#{klass} does not have a #{foreign_key} foreign key."
+        end
+
         def primary_key_correct?(klass)
           if options.key?(:primary_key)
-            if option_verifier.correct_for_string?(:primary_key, options[:primary_key])
+            if option_verifier.correct_for_string?(
+              :primary_key,
+              options[:primary_key],
+            )
               true
             else
-              @missing = "#{klass} does not have a #{options[:primary_key]} primary key"
+              @missing = "#{klass} does not have a #{options[:primary_key]}"\
+                ' primary key'
               false
             end
           else
@@ -1394,8 +1444,14 @@ module Shoulda
         end
 
         def foreign_key_reflection
-          if [:has_one, :has_many].include?(macro) && reflection.options.include?(:inverse_of)
-            associated_class.reflect_on_association(reflection.options[:inverse_of])
+          if (
+            [:has_one, :has_many].include?(macro) &&
+            reflection.options.include?(:inverse_of) &&
+            reflection.options[:inverse_of] != false
+          )
+            associated_class.reflect_on_association(
+              reflection.options[:inverse_of],
+            )
           else
             reflection
           end

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

@@ -19,7 +19,10 @@ module Shoulda
           def matches?(subject)
             self.subject = ModelReflector.new(subject, name)
 
-            if option_verifier.correct_for_string?(:counter_cache, counter_cache)
+            if option_verifier.correct_for_string?(
+              :counter_cache,
+              counter_cache,
+            )
               true
             else
               self.missing_option = "#{name} should have #{description}"
@@ -32,7 +35,7 @@ module Shoulda
           attr_accessor :subject, :counter_cache, :name
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
         end
       end

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

@@ -34,7 +34,7 @@ module Shoulda
           private
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
 
           def option_matches?
@@ -43,8 +43,8 @@ module Shoulda
 
           def option_type
             case dependent
-              when true, false then :boolean
-              else :string
+            when true, false then :boolean
+            else :string
             end
           end
 
@@ -52,7 +52,7 @@ module Shoulda
             [
               "#{name} should have",
               (dependent == true ? 'a' : dependent),
-              'dependency'
+              'dependency',
             ].join(' ')
           end
         end

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

@@ -32,7 +32,7 @@ module Shoulda
           attr_accessor :subject, :inverse_of, :name
 
           def option_verifier
-            @option_verifier ||= OptionVerifier.new(subject)
+            @_option_verifier ||= OptionVerifier.new(subject)
           end
         end
       end