shoulda-matchers 4.4.0 → 5.0.0

data/lib/shoulda/matchers/active_record.rb

@@ -1,23 +1,35 @@
-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
     # This module provides matchers that are used to test behavior within
     # ActiveRecord classes.
     module ActiveRecord
-      autoload :AcceptNestedAttributesForMatcher, 'shoulda/matchers/active_record/accept_nested_attributes_for_matcher'
-      autoload :AssociationMatcher, 'shoulda/matchers/active_record/association_matcher'
-      autoload :AssociationMatchers, 'shoulda/matchers/active_record/association_matchers'
-      autoload :DefineEnumForMatcher, 'shoulda/matchers/active_record/define_enum_for_matcher'
-      autoload :HaveAttachedMatcher, 'shoulda/matchers/active_record/have_attached_matcher'
-      autoload :HaveDbColumnMatcher, 'shoulda/matchers/active_record/have_db_column_matcher'
-      autoload :HaveDbIndexMatcher, 'shoulda/matchers/active_record/have_db_index_matcher'
-      autoload :HaveImplicitOrderColumnMatcher, 'shoulda/matchers/active_record/have_implicit_order_column'
-      autoload :HaveReadonlyAttributeMatcher, 'shoulda/matchers/active_record/have_readonly_attribute_matcher'
-      autoload :HaveRichText, 'shoulda/matchers/active_record/have_rich_text_matcher'
-      autoload :HaveSecureTokenMatcher, 'shoulda/matchers/active_record/have_secure_token_matcher'
-      autoload :SerializeMatcher, 'shoulda/matchers/active_record/serialize_matcher'
-      autoload :Uniqueness, 'shoulda/matchers/active_record/uniqueness'
     end
   end
 end

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

@@ -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
 
@@ -1163,7 +1172,8 @@ module Shoulda
         end
 
         def option_verifier
-          @option_verifier ||= AssociationMatchers::OptionVerifier.new(reflector)
+          @_option_verifier ||=
+            AssociationMatchers::OptionVerifier.new(reflector)
         end
 
         protected
@@ -1171,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)
@@ -1186,16 +1196,7 @@ 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
@@ -1215,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
@@ -1252,8 +1253,8 @@ module Shoulda
         def validate_inverse_of_through_association
           reflector.validate_inverse_of_through_association!
           true
-        rescue ::ActiveRecord::ActiveRecordError => error
-          @missing = error.message
+        rescue ::ActiveRecord::ActiveRecordError => e
+          @missing = e.message
           false
         end
 
@@ -1282,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
@@ -1294,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
@@ -1303,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?
@@ -1317,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
@@ -1333,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
@@ -1376,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
@@ -1399,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

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

@@ -3,18 +3,6 @@ module Shoulda
     module ActiveRecord
       # @private
       module AssociationMatchers
-        autoload :CounterCacheMatcher, 'shoulda/matchers/active_record/association_matchers/counter_cache_matcher'
-        autoload :InverseOfMatcher, 'shoulda/matchers/active_record/association_matchers/inverse_of_matcher'
-        autoload :JoinTableMatcher, 'shoulda/matchers/active_record/association_matchers/join_table_matcher'
-        autoload :OrderMatcher, 'shoulda/matchers/active_record/association_matchers/order_matcher'
-        autoload :ThroughMatcher, 'shoulda/matchers/active_record/association_matchers/through_matcher'
-        autoload :DependentMatcher, 'shoulda/matchers/active_record/association_matchers/dependent_matcher'
-        autoload :RequiredMatcher, 'shoulda/matchers/active_record/association_matchers/required_matcher'
-        autoload :OptionalMatcher, 'shoulda/matchers/active_record/association_matchers/optional_matcher'
-        autoload :SourceMatcher, 'shoulda/matchers/active_record/association_matchers/source_matcher'
-        autoload :ModelReflector, 'shoulda/matchers/active_record/association_matchers/model_reflector'
-        autoload :ModelReflection, 'shoulda/matchers/active_record/association_matchers/model_reflection'
-        autoload :OptionVerifier, 'shoulda/matchers/active_record/association_matchers/option_verifier'
       end
     end
   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

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

@@ -18,7 +18,7 @@ module Shoulda
             @reflector = reflector
           end
 
-          def matches?(subject)
+          def matches?(_subject)
             join_table_option_correct? &&
               join_table_exists? &&
               join_table_has_correct_columns?
@@ -26,10 +26,14 @@ module Shoulda
 
           def join_table_option_correct?
             if options.key?(:join_table_name)
-              if option_verifier.correct_for_string?(:join_table, options[:join_table_name])
+              if option_verifier.correct_for_string?(
+                :join_table,
+                options[:join_table_name],
+              )
                 true
               else
-                @failure_message = "#{name} should use #{options[:join_table_name].inspect} for :join_table option"
+                @failure_message = "#{name} should use"\
+                  " #{options[:join_table_name].inspect} for :join_table option"
                 false
               end
             else
@@ -38,7 +42,8 @@ module Shoulda
           end
 
           def join_table_exists?
-            if RailsShim.tables_and_views(connection).include?(join_table_name.to_s)
+            if connection.data_sources.
+                include?(join_table_name.to_s)
               true
             else
               @failure_message = missing_table_message
@@ -64,8 +69,8 @@ module Shoulda
           delegate :foreign_key, :association_foreign_key, to: :reflector
 
           def missing_columns
-            @missing_columns ||= expected_join_table_columns.select do |key|
-              !actual_join_table_columns.include?(key.to_s)
+            @_missing_columns ||= expected_join_table_columns.reject do |key|
+              actual_join_table_columns.include?(key.to_s)
             end
           end