shoulda-matchers 3.1.3 → 4.0.0.rc1

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

@@ -16,10 +16,11 @@ module Shoulda
           def call
             if description_clauses_for_qualifiers.any?
               main_description +
+                clause_for_allow_blank_or_nil +
                 ', ' +
                 description_clauses_for_qualifiers.to_sentence
             else
-              main_description
+              main_description + clause_for_allow_blank_or_nil
             end
           end
 
@@ -29,14 +30,18 @@ module Shoulda
 
           private
 
-          def description_clauses_for_qualifiers
-            description_clauses = []
-
+          def clause_for_allow_blank_or_nil
             if matcher.try(:expects_to_allow_blank?)
-              description_clauses << 'but only if it is not blank'
+              ' as long as it is not blank'
             elsif matcher.try(:expects_to_allow_nil?)
-              description_clauses << 'but only if it is not nil'
+              ' as long as it is not nil'
+            else
+              ''
             end
+          end
+
+          def description_clauses_for_qualifiers
+            description_clauses = []
 
             if matcher.try(:expects_strict?)
               description_clauses << 'raising a validation exception'

data/lib/shoulda/matchers/active_record.rb

@@ -6,6 +6,8 @@ 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"
@@ -13,6 +15,7 @@ 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"

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

@@ -217,7 +217,7 @@ module Shoulda
       #       should belong_to(:organization).touch(true)
       #     end
       #
-      # #### autosave
+      # ##### autosave
       #
       # Use `autosave` to assert that the `:autosave` option was specified.
       #
@@ -253,6 +253,44 @@ module Shoulda
       #       should belong_to(:organization).inverse_of(:employees)
       #     end
       #
+      # ##### required
+      #
+      # Use `required` to assert that the association is not allowed to be nil.
+      # (Enabled by default in Rails 5+.)
+      #
+      #     class Person < ActiveRecord::Base
+      #       belongs_to :organization, required: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person
+      #       it { should belong_to(:organization).required }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should belong_to(:organization).required
+      #     end
+      #
+      # ##### optional
+      #
+      # Use `optional` to assert that the association is allowed to be nil.
+      # (Rails 5+ only.)
+      #
+      #     class Person < ActiveRecord::Base
+      #       belongs_to :organization, optional: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person
+      #       it { should belong_to(:organization).optional }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should belong_to(:organization).optional
+      #     end
+      #
       # @return [AssociationMatcher]
       #
       def belong_to(name)
@@ -468,7 +506,7 @@ module Shoulda
       #       should have_many(:ideas).validate(false)
       #     end
       #
-      # #### autosave
+      # ##### autosave
       #
       # Use `autosave` to assert that the `:autosave` option was specified.
       #
@@ -486,6 +524,25 @@ module Shoulda
       #       should have_many(:games).autosave(true)
       #     end
       #
+      # ##### index_errors
+      #
+      # Use `index_errors` to assert that the `:index_errors` option was
+      # specified.
+      #
+      #     class Player < ActiveRecord::Base
+      #       has_many :games, index_errors: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Player, type: :model do
+      #       it { should have_many(:games).index_errors(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PlayerTest < ActiveSupport::TestCase
+      #       should have_many(:games).index_errors(true)
+      #     end
+      #
       # ##### inverse_of
       #
       # Use `inverse_of` to assert that the `:inverse_of` option was specified.
@@ -696,7 +753,7 @@ module Shoulda
       #       should have_one(:parking_card).validate(false)
       #     end
       #
-      # #### autosave
+      # ##### autosave
       #
       # Use `autosave` to assert that the `:autosave` option was specified.
       #
@@ -714,6 +771,25 @@ module Shoulda
       #       should have_one(:bank).autosave(true)
       #     end
       #
+      # ##### required
+      #
+      # Use `required` to assert that the association is not allowed to be nil.
+      # (Rails 5+ only.)
+      #
+      #     class Person < ActiveRecord::Base
+      #       has_one :brain, required: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Person
+      #       it { should have_one(:brain).required }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should have_one(:brain).required
+      #     end
+      #
       # @return [AssociationMatcher]
       #
       def have_one(name)
@@ -854,7 +930,7 @@ module Shoulda
       #         validate(false)
       #     end
       #
-      # #### autosave
+      # ##### autosave
       #
       # Use `autosave` to assert that the `:autosave` option was specified.
       #
@@ -891,42 +967,63 @@ module Shoulda
           @options = {}
           @submatchers = []
           @missing = ''
+
+          if macro == :belongs_to && RailsShim.active_record_gte_5?
+            required(belongs_to_required_by_default?)
+          end
         end
 
         def through(through)
-          through_matcher = AssociationMatchers::ThroughMatcher.new(through, name)
-          add_submatcher(through_matcher)
+          add_submatcher(
+            AssociationMatchers::ThroughMatcher,
+            through,
+            name,
+          )
           self
         end
 
         def dependent(dependent)
-          dependent_matcher = AssociationMatchers::DependentMatcher.new(dependent, name)
-          add_submatcher(dependent_matcher)
+          add_submatcher(
+            AssociationMatchers::DependentMatcher,
+            dependent,
+            name,
+          )
           self
         end
 
         def order(order)
-          order_matcher = AssociationMatchers::OrderMatcher.new(order, name)
-          add_submatcher(order_matcher)
+          add_submatcher(
+            AssociationMatchers::OrderMatcher,
+            order,
+            name,
+          )
           self
         end
 
         def counter_cache(counter_cache = true)
-          counter_cache_matcher = AssociationMatchers::CounterCacheMatcher.new(counter_cache, name)
-          add_submatcher(counter_cache_matcher)
+          add_submatcher(
+            AssociationMatchers::CounterCacheMatcher,
+            counter_cache,
+            name,
+          )
           self
         end
 
         def inverse_of(inverse_of)
-          inverse_of_matcher =
-            AssociationMatchers::InverseOfMatcher.new(inverse_of, name)
-          add_submatcher(inverse_of_matcher)
+          add_submatcher(
+            AssociationMatchers::InverseOfMatcher,
+            inverse_of,
+            name,
+          )
           self
         end
 
         def source(source)
-          source_matcher = AssociationMatchers::SourceMatcher.new(source, name)
-          add_submatcher(source_matcher)
+          add_submatcher(
+            AssociationMatchers::SourceMatcher,
+            source,
+            name,
+          )
           self
         end
 
@@ -940,6 +1037,11 @@ module Shoulda
           self
         end
 
+        def index_errors(index_errors)
+          @options[:index_errors] = index_errors
+          self
+        end
+
         def class_name(class_name)
           @options[:class_name] = class_name
           self
@@ -955,6 +1057,26 @@ module Shoulda
           self
         end
 
+        def required(required = true)
+          remove_submatcher(AssociationMatchers::OptionalMatcher)
+          add_submatcher(
+            AssociationMatchers::RequiredMatcher,
+            name,
+            required,
+          )
+          self
+        end
+
+        def optional
+          remove_submatcher(AssociationMatchers::RequiredMatcher)
+          add_submatcher(
+            AssociationMatchers::OptionalMatcher,
+            name,
+            true,
+          )
+          self
+        end
+
         def validate(validate = true)
           @options[:validate] = validate
           self
@@ -994,6 +1116,7 @@ module Shoulda
             class_name_correct? &&
             join_table_correct? &&
             autosave_correct? &&
+            index_errors_correct? &&
             conditions_correct? &&
             validate_correct? &&
             touch_correct? &&
@@ -1016,8 +1139,15 @@ module Shoulda
           @reflector ||= AssociationMatchers::ModelReflector.new(subject, name)
         end
 
-        def add_submatcher(matcher)
-          @submatchers << matcher
+        def add_submatcher(matcher_class, *args)
+          remove_submatcher(matcher_class)
+          submatchers << matcher_class.new(*args)
+        end
+
+        def remove_submatcher(matcher_class)
+          submatchers.delete_if do |submatcher|
+            submatcher.is_a?(matcher_class)
+          end
         end
 
         def macro_description
@@ -1039,12 +1169,12 @@ module Shoulda
 
         def missing_options
           missing_options = [missing, missing_options_for_failing_submatchers]
-          missing_options.flatten.compact.join(', ')
+          missing_options.flatten.select(&:present?).join(', ')
         end
 
         def failing_submatchers
-          @failing_submatchers ||= submatchers.reject do |matcher|
-            matcher.matches?(subject)
+          @failing_submatchers ||= submatchers.select do |matcher|
+            !matcher.matches?(subject)
           end
         end
 
@@ -1148,6 +1278,22 @@ module Shoulda
           end
         end
 
+        def index_errors_correct?
+          return true unless options.key?(:index_errors)
+
+          if option_verifier.correct_for_boolean?(
+            :index_errors,
+            options[:index_errors]
+          )
+            true
+          else
+            @missing =
+              "#{name} should have index_errors set to " +
+              "#{options[:index_errors]}"
+            false
+          end
+        end
+
         def conditions_correct?
           if options.key?(:conditions)
             if option_verifier.correct_for_relation_clause?(:conditions, options[:conditions])
@@ -1226,6 +1372,10 @@ module Shoulda
         def submatchers_match?
           failing_submatchers.empty?
         end
+
+        def belongs_to_required_by_default?
+          ::ActiveRecord::Base.belongs_to_required_by_default
+        end
       end
     end
   end

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

@@ -38,7 +38,7 @@ module Shoulda
           end
 
           def join_table_exists?
-            if connection.tables.include?(join_table_name)
+            if RailsShim.tables_and_views(connection).include?(join_table_name)
               true
             else
               @failure_message = missing_table_message

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

@@ -34,15 +34,16 @@ module Shoulda
 
           def correct_for?(*args)
             expected_value, name, type = args.reverse
+
             if expected_value.nil?
               true
             else
-              expected_value = type_cast(
+              type_cast_expected_value = type_cast(
                 type,
                 expected_value_for(type, name, expected_value)
               )
               actual_value = type_cast(type, actual_value_for(name))
-              expected_value == actual_value
+              type_cast_expected_value == actual_value
             end
           end
 
@@ -65,10 +66,14 @@ module Shoulda
 
           def type_cast(type, value)
             case type
-              when :string, :relation_clause then value.to_s
-              when :boolean                  then !!value
-              when :hash                     then Hash(value).stringify_keys
-              else                                value
+            when :string, :relation_clause
+              value.to_s
+            when :boolean
+              !!value
+            when :hash
+              Hash(value).stringify_keys
+            else
+              value
             end
           end
 

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

@@ -0,0 +1,46 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class OptionalMatcher
+          attr_reader :missing_option
+
+          def initialize(attribute_name, optional)
+            @optional = optional
+            @submatcher = ActiveModel::AllowValueMatcher.new(nil).
+              for(attribute_name)
+            @missing_option = ''
+          end
+
+          def description
+            "optional: #{optional}"
+          end
+
+          def matches?(subject)
+            if submatcher_passes?(subject)
+              true
+            else
+              @missing_option =
+                'the association should have been defined ' +
+                "with `optional: #{optional}`, but was not"
+              false
+            end
+          end
+
+          private
+
+          attr_reader :optional, :submatcher
+
+          def submatcher_passes?(subject)
+            if optional
+              submatcher.matches?(subject)
+            else
+              submatcher.does_not_match?(subject)
+            end
+          end
+        end
+      end
+    end
+  end
+end