shoulda-matchers 4.1.1 → 4.4.1

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

@@ -35,7 +35,7 @@ module Shoulda
       #       include ActiveModel::Model
       #       attr_accessor :supported_os
       #
-      #       validates_exclusion_of :supported_os, in: ['Mac', 'Linux']
+      #       validates_exclusion_of :supported_os, in: 5..8
       #     end
       #
       #     # RSpec

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

@@ -311,15 +311,6 @@ EOT
           self
         end
 
-        def allow_blank
-          @options[:allow_blank] = true
-          self
-        end
-
-        def expects_to_allow_blank?
-          @options[:allow_blank]
-        end
-
         def allow_nil
           @options[:allow_nil] = true
           self
@@ -423,14 +414,14 @@ EOT
           allows_all_values_in_array? &&
             disallows_all_values_outside_of_array? &&
             allows_nil_value? &&
-            allows_blank_value?
+            allow_blank_matches?
         end
 
         def does_not_match_for_array?
           disallows_any_values_in_array? ||
             allows_any_value_outside_of_array? ||
             disallows_nil_value? ||
-            disallows_blank_value?
+            allow_blank_does_not_match?
         end
 
         def allows_lower_value
@@ -616,16 +607,6 @@ EOT
           @options[:allow_nil] && disallows_value_of(nil)
         end
 
-        def allows_blank_value?
-          @options[:allow_blank] != true ||
-            BLANK_VALUES.all? { |value| allows_value_of(value) }
-        end
-
-        def disallows_blank_value?
-          @options[:allow_blank] &&
-            BLANK_VALUES.any? { |value| disallows_value_of(value) }
-        end
-
         def inspected_array
           Shoulda::Matchers::Util.inspect_values(@array).to_sentence(
             two_words_connector: " or ",

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

@@ -232,13 +232,34 @@ module Shoulda
       #       it { should validate_length_of(:bio).is_at_least(15).allow_nil }
       #     end
       #
-      #     # Test::Unit
+      #     # Minitest (Shoulda)
       #     class UserTest < ActiveSupport::TestCase
       #       should validate_length_of(:bio).is_at_least(15).allow_nil
       #     end
       #
       # @return [ValidateLengthOfMatcher]
       #
+      # # ##### allow_blank
+      #
+      # Use `allow_blank` to assert that the attribute allows blank.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :bio
+      #
+      #       validates_length_of :bio, minimum: 15, allow_blank: true
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should validate_length_of(:bio).is_at_least(15).allow_blank }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_length_of(:bio).is_at_least(15).allow_blank
+      #     end
+      #
       def validate_length_of(attr)
         ValidateLengthOfMatcher.new(attr)
       end
@@ -331,7 +352,8 @@ module Shoulda
 
           lower_bound_matches? &&
             upper_bound_matches? &&
-            allow_nil_matches?
+            allow_nil_matches? &&
+            allow_blank_matches?
         end
 
         def does_not_match?(subject)
@@ -339,7 +361,8 @@ module Shoulda
 
           lower_bound_does_not_match? ||
             upper_bound_does_not_match? ||
-            allow_nil_does_not_match?
+            allow_nil_does_not_match? ||
+            allow_blank_does_not_match?
         end
 
         private
@@ -376,6 +399,7 @@ module Shoulda
         def disallows_lower_length?
           !@options.key?(:minimum) ||
             @options[:minimum] == 0 ||
+            (@options[:minimum] == 1 && expects_to_allow_blank?) ||
             disallows_length_of?(
               @options[:minimum] - 1,
               translated_short_message

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

@@ -204,6 +204,33 @@ module Shoulda
       #         is_greater_than(21)
       #     end
       #
+      # ##### is_other_than
+      #
+      # Use `is_other_than` to test usage of the `:other_than` option.
+      # This asserts that the attribute can take a number which is not equal to
+      # the given value.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :legal_age
+      #
+      #       validates_numericality_of :legal_age, other_than: 21
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Person, type: :model do
+      #       it do
+      #         should validate_numericality_of(:legal_age).
+      #           is_other_than(21)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:legal_age).
+      #         is_other_than(21)
+      #     end
+      #
       # ##### even
       #
       # Use `even` to test usage of the `:even` option. This asserts that the
@@ -395,6 +422,11 @@ module Shoulda
           self
         end
 
+        def is_other_than(value)
+          prepare_submatcher(comparison_matcher_for(value, :!=).for(@attribute))
+          self
+        end
+
         def with_message(message)
           @expects_custom_validation_message = true
           @expected_message = message

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

@@ -314,10 +314,11 @@ validation for you? Instead of using `validate_presence_of`, try
         def attribute_accepts_string_values?
           if association?
             false
-          elsif attribute_serializer
-            attribute_serializer.object_class == String
+          elsif attribute_serialization_coder.respond_to?(:object_class)
+            attribute_serialization_coder.object_class == String
           else
-            attribute_type.try(:type) == :string
+            RailsShim.supports_full_attributes_api?(model) &&
+              attribute_type.try(:type) == :string
           end
         end
 
@@ -355,12 +356,8 @@ validation for you? Instead of using `validate_presence_of`, try
           end
         end
 
-        def attribute_serializer
-          if attribute_type.respond_to?(:coder)
-            attribute_type.coder
-          else
-            nil
-          end
+        def attribute_serialization_coder
+          RailsShim.attribute_serialization_coder_for(model, @attribute)
         end
 
         def attribute_type

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

@@ -24,6 +24,11 @@ module Shoulda
           self
         end
 
+        def allow_blank
+          options[:allow_blank] = true
+          self
+        end
+
         def strict
           @expects_strict = true
           self
@@ -116,8 +121,20 @@ module Shoulda
           )
         end
 
+        def allow_blank_matches?
+          !expects_to_allow_blank? ||
+            blank_values.all? { |value| allows_value_of(value) }
+        end
+
+        def allow_blank_does_not_match?
+          expects_to_allow_blank? &&
+            blank_values.all? { |value| disallows_value_of(value) }
+        end
+
         private
 
+        attr_reader :options
+
         def overall_failure_message
           Shoulda::Matchers.word_wrap(
             "Expected #{model.name} to #{description}, but this could not be " +
@@ -161,6 +178,14 @@ module Shoulda
           @last_submatcher_run = matcher
           matcher.matches?(subject)
         end
+
+        def expects_to_allow_blank?
+          options[:allow_blank]
+        end
+
+        def blank_values
+          ['', ' ', "\n", "\r", "\t", "\f"]
+        end
       end
     end
   end

data/lib/shoulda/matchers/active_record.rb

@@ -14,13 +14,16 @@ 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/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
@@ -1096,12 +1096,12 @@ module Shoulda
           self
         end
 
-        def optional
+        def optional(optional = true)
           remove_submatcher(AssociationMatchers::RequiredMatcher)
           add_submatcher(
             AssociationMatchers::OptionalMatcher,
             name,
-            true,
+            optional,
           )
           self
         end
@@ -1144,6 +1144,7 @@ module Shoulda
           @subject = subject
           association_exists? &&
             macro_correct? &&
+            validate_inverse_of_through_association &&
             (polymorphic? || class_exists?) &&
             foreign_key_exists? &&
             primary_key_exists? &&
@@ -1198,7 +1199,14 @@ module Shoulda
         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
@@ -1241,6 +1249,14 @@ module Shoulda
           end
         end
 
+        def validate_inverse_of_through_association
+          reflector.validate_inverse_of_through_association!
+          true
+        rescue ::ActiveRecord::ActiveRecordError => error
+          @missing = error.message
+          false
+        end
+
         def macro_supports_primary_key?
           macro == :belongs_to ||
             ([:has_many, :has_one].include?(macro) && !through?)
@@ -1394,7 +1410,7 @@ module Shoulda
         end
 
         def foreign_key_reflection
-          if [:has_one, :has_many].include?(macro) && reflection.options.include?(: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

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

@@ -29,7 +29,7 @@ module Shoulda
               if option_verifier.correct_for_string?(:join_table, options[:join_table_name])
                 true
               else
-                @failure_message = "#{name} should use '#{options[:join_table_name]}' for :join_table option"
+                @failure_message = "#{name} should use #{options[:join_table_name].inspect} for :join_table option"
                 false
               end
             else
@@ -38,7 +38,7 @@ module Shoulda
           end
 
           def join_table_exists?
-            if RailsShim.tables_and_views(connection).include?(join_table_name)
+            if RailsShim.tables_and_views(connection).include?(join_table_name.to_s)
               true
             else
               @failure_message = missing_table_message

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

@@ -35,12 +35,12 @@ module Shoulda
             join_table_name.to_s
           end
 
-          def association_relation
+          def association_relation(related_instance)
             relation = associated_class.all
 
             if reflection.scope
               # Source: AR::Associations::AssociationScope#eval_scope
-              relation.instance_exec(subject, &reflection.scope)
+              relation.instance_exec(related_instance, &reflection.scope)
             else
               relation
             end
@@ -65,16 +65,22 @@ module Shoulda
             end
           end
 
+          def validate_inverse_of_through_association!
+            if through?
+              reflection.check_validity!
+            end
+          end
+
+          def has_and_belongs_to_many_name
+            reflection.options[:through]
+          end
+
           protected
 
           attr_reader :reflection, :subject
 
           private
 
-          def has_and_belongs_to_many_name
-            reflection.options[:through]
-          end
-
           def has_and_belongs_to_many_name_table_name
             if has_and_belongs_to_many_reflection
               has_and_belongs_to_many_reflection.table_name

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

@@ -4,15 +4,32 @@ module Shoulda
       module AssociationMatchers
         # @private
         class ModelReflector
-          delegate :associated_class, :through?, :join_table_name,
-            :association_relation, :polymorphic?, :foreign_key,
-            :association_foreign_key, to: :reflection
+          delegate(
+            :associated_class,
+            :association_foreign_key,
+            :foreign_key,
+            :has_and_belongs_to_many_name,
+            :join_table_name,
+            :polymorphic?,
+            :validate_inverse_of_through_association!,
+            to: :reflection
+          )
+
+          delegate(
+            :through?,
+            to: :reflection,
+            allow_nil: true
+          )
 
           def initialize(subject, name)
             @subject = subject
             @name = name
           end
 
+          def association_relation
+            reflection.association_relation(subject)
+          end
+
           def reflection
             @reflection ||= reflect_on_association(name)
           end

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

@@ -0,0 +1,147 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      def have_one_attached(name)
+        HaveAttachedMatcher.new(:one, name)
+      end
+
+      def have_many_attached(name)
+        HaveAttachedMatcher.new(:many, name)
+      end
+
+      # @private
+      class HaveAttachedMatcher
+        attr_reader :name
+
+        def initialize(macro, name)
+          @macro = macro
+          @name = name
+        end
+
+        def description
+          "have a has_#{macro}_attached called #{name}"
+        end
+
+        def failure_message
+          <<-MESSAGE
+Expected #{expectation}, but this could not be proved.
+  #{@failure}
+          MESSAGE
+        end
+
+        def failure_message_when_negated
+          <<-MESSAGE
+Did not expect #{expectation}, but it does.
+          MESSAGE
+        end
+
+        def expectation
+          "#{model_class.name} to #{description}"
+        end
+
+        def matches?(subject)
+          @subject = subject
+          reader_attribute_exists? &&
+            writer_attribute_exists? &&
+            attachments_association_exists? &&
+            blobs_association_exists? &&
+            eager_loading_scope_exists?
+        end
+
+        private
+
+        attr_reader :subject, :macro
+
+        def reader_attribute_exists?
+          if subject.respond_to?(name)
+            true
+          else
+            @failure = "#{model_class.name} does not have a :#{name} method."
+            false
+          end
+        end
+
+        def writer_attribute_exists?
+          if subject.respond_to?("#{name}=")
+            true
+          else
+            @failure = "#{model_class.name} does not have a :#{name}= method."
+            false
+          end
+        end
+
+        def attachments_association_exists?
+          if attachments_association_matcher.matches?(subject)
+            true
+          else
+            @failure = attachments_association_matcher.failure_message
+            false
+          end
+        end
+
+        def attachments_association_matcher
+          @_attachments_association_matcher ||=
+            AssociationMatcher.new(
+              :"has_#{macro}",
+              attachments_association_name,
+            ).
+              conditions(name: name).
+              class_name('ActiveStorage::Attachment').
+              inverse_of(:record)
+        end
+
+        def attachments_association_name
+          case macro
+          when :one then
+            "#{name}_attachment"
+          when :many then
+            "#{name}_attachments"
+          end
+        end
+
+        def blobs_association_exists?
+          if blobs_association_matcher.matches?(subject)
+            true
+          else
+            @failure = blobs_association_matcher.failure_message
+            false
+          end
+        end
+
+        def blobs_association_matcher
+          @_blobs_association_matcher ||=
+            AssociationMatcher.new(
+              :"has_#{macro}",
+              blobs_association_name,
+            ).
+              through(attachments_association_name).
+              class_name('ActiveStorage::Blob').
+              source(:blob)
+        end
+
+        def blobs_association_name
+          case macro
+          when :one then
+            "#{name}_blob"
+          when :many then
+            "#{name}_blobs"
+          end
+        end
+
+        def eager_loading_scope_exists?
+          if model_class.respond_to?("with_attached_#{name}")
+            true
+          else
+            @failure = "#{model_class.name} does not have a " \
+                       ":with_attached_#{name} scope."
+            false
+          end
+        end
+
+        def model_class
+          subject.class
+        end
+      end
+    end
+  end
+end