shoulda-matchers 4.3.0 → 5.0.0.rc1

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

@@ -5,7 +5,7 @@ module Shoulda
       class ValidationMessageFinder
         include Helpers
 
-        def initialize(instance, attribute, context=nil)
+        def initialize(instance, attribute, context = nil)
           @instance = instance
           @attribute = attribute
           @context = context
@@ -50,7 +50,7 @@ module Shoulda
         end
 
         def validated_instance
-          @validated_instance ||= validate_instance
+          @_validated_instance ||= validate_instance
         end
 
         def validate_instance
@@ -58,8 +58,6 @@ module Shoulda
           @instance
         end
       end
-
     end
   end
 end
-

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

@@ -98,24 +98,19 @@ module Shoulda
 
           all_validation_errors = record.errors.dup
 
-          validation_error_messages =
-            if record.errors.respond_to?(:[])
-              record.errors[attribute]
-            else
-              record.errors.on(attribute)
-            end
+          validation_error_messages = record.errors[attribute]
 
           {
             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,27 +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_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/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
 
@@ -997,7 +1004,7 @@ module Shoulda
           @submatchers = []
           @missing = ''
 
-          if macro == :belongs_to && RailsShim.active_record_gte_5?
+          if macro == :belongs_to
             required(belongs_to_required_by_default?)
           end
         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,49 @@ 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
+          @missing = validate_foreign_key(klass)
+
+          @missing.nil?
+        end
+
+        def validate_foreign_key(klass)
+          if options.key?(:foreign_key) && !foreign_key_correct?
+            foreign_key_failure_message(klass, options[:foreign_key])
+          elsif !has_column?(klass, actual_foreign_key)
+            foreign_key_failure_message(klass, actual_foreign_key)
+          end
+        end
+
+        def has_column?(klass, column)
+          case column
+          when Array
+            column.all? { |c| has_column?(klass, c.to_s) }
           else
-            @missing = "#{klass} does not have a #{foreign_key} foreign key."
-            false
+            column_names_for(klass).include?(column.to_s)
           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
@@ -1383,19 +1444,27 @@ module Shoulda
           end
         end
 
-        def foreign_key
-          if foreign_key_reflection
-            if foreign_key_reflection.respond_to?(:foreign_key)
-              foreign_key_reflection.foreign_key.to_s
-            else
-              foreign_key_reflection.primary_key_name.to_s
-            end
+        def actual_foreign_key
+          return unless foreign_key_reflection
+
+          if foreign_key_reflection.options[:foreign_key]
+            foreign_key_reflection.options[:foreign_key]
+          elsif foreign_key_reflection.respond_to?(:foreign_key)
+            foreign_key_reflection.foreign_key
+          else
+            foreign_key_reflection.primary_key_name
           end
         end
 
         def foreign_key_reflection
-          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])
+          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