shoulda-matchers 2.8.0 → 3.0.0.rc1

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

@@ -67,6 +67,33 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Issue
+      #       include ActiveModel::Model
+      #       attr_accessor :severity
+      #
+      #       validates_inclusion_of :severity,
+      #         in: %w(low medium high),
+      #         on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe Issue do
+      #       it do
+      #         should validate_inclusion_of(:severity).
+      #           in_array(%w(low medium high)).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class IssueTest < ActiveSupport::TestCase
+      #       should validate_inclusion_of(:severity).
+      #         in_array(%w(low medium high)).
+      #         on(:create)
+      #     end
+      #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.
@@ -234,16 +261,6 @@ module Shoulda
         ValidateInclusionOfMatcher.new(attr)
       end
 
-      # @deprecated Use {#validate_inclusion_of} instead.
-      # @return [ValidateInclusionOfMatcher]
-      def ensure_inclusion_of(attr)
-        Shoulda::Matchers.warn_about_deprecated_method(
-          :ensure_inclusion_of,
-          :validate_inclusion_of
-        )
-        validate_inclusion_of(attr)
-      end
-
       # @private
       class ValidateInclusionOfMatcher < ValidationMatcher
         ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'

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

@@ -7,6 +7,31 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :password
+      #
+      #       validates_length_of :password, minimum: 10, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it do
+      #         should validate_length_of(:password).
+      #           is_at_least(10).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_length_of(:password).
+      #         is_at_least(10).
+      #         on(:create)
+      #     end
+      #
       # ##### is_at_least
       #
       # Use `is_at_least` to test usage of the `:minimum` option. This asserts
@@ -110,9 +135,9 @@ module Shoulda
       #
       #     class User
       #       include ActiveModel::Model
-      #       attr_accessor :api_token
+      #       attr_accessor :password
       #
-      #       validates_length_of :api_token,
+      #       validates_length_of :password,
       #         minimum: 10,
       #         message: "Password isn't long enough"
       #     end
@@ -197,16 +222,6 @@ module Shoulda
         ValidateLengthOfMatcher.new(attr)
       end
 
-      # @deprecated Use {#validate_length_of} instead.
-      # @return [ValidateLengthOfMatcher]
-      def ensure_length_of(attr)
-        Shoulda::Matchers.warn_about_deprecated_method(
-          :ensure_length_of,
-          :validate_length_of
-        )
-        validate_length_of(attr)
-      end
-
       # @private
       class ValidateLengthOfMatcher < ValidationMatcher
         include Helpers

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

@@ -23,6 +23,30 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Person
+      #       include ActiveModel::Model
+      #       attr_accessor :number_of_dependents
+      #
+      #       validates_numericality_of :number_of_dependents, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should validate_numericality_of(:number_of_dependents).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should validate_numericality_of(:number_of_dependents).on(:create)
+      #     end
+      #
       # ##### only_integer
       #
       # Use `only_integer` to test usage of the `:only_integer` option. This
@@ -290,9 +314,16 @@ module Shoulda
           @attribute = attribute
           @submatchers = []
           @diff_to_compare = DEFAULT_DIFF_TO_COMPARE
+          @strict = false
           add_disallow_value_matcher
         end
 
+        def strict
+          @submatchers.each(&:strict)
+          @strict = true
+          self
+        end
+
         def only_integer
           prepare_submatcher(
             NumericalityMatchers::OnlyIntegerMatcher.new(@attribute)
@@ -353,22 +384,38 @@ module Shoulda
           self
         end
 
+        def on(context)
+          @submatchers.each { |matcher| matcher.on(context) }
+          self
+        end
+
         def matches?(subject)
           @subject = subject
-          failing_submatchers.empty?
+          first_failing_submatcher.nil?
         end
 
         def description
-          "only allow #{allowed_types} for #{@attribute}#{comparison_descriptions}"
+          description_parts = ["only allow #{allowed_types} for #{@attribute}"]
+
+          if comparison_descriptions.present?
+            description_parts << comparison_descriptions
+          end
+
+          if @strict
+            description_parts.insert(1, 'strictly')
+            description_parts.join(', ')
+          else
+            description_parts.join(' ')
+          end
         end
 
         def failure_message
-          last_failing_submatcher.failure_message
+          first_failing_submatcher.failure_message
         end
         alias failure_message_for_should failure_message
 
         def failure_message_when_negated
-          last_failing_submatcher.failure_message_when_negated
+          first_failing_submatcher.failure_message_when_negated
         end
         alias failure_message_for_should_not failure_message_when_negated
 
@@ -403,21 +450,10 @@ module Shoulda
           @diff_to_compare = [@diff_to_compare, matcher.diff_to_compare].max
         end
 
-        def submatchers_and_results
-          @_submatchers_and_results ||=
-            @submatchers.map do |matcher|
-              { matcher: matcher, matched: matcher.matches?(@subject) }
-            end
-        end
-
-        def failing_submatchers
-          submatchers_and_results.
-            select { |x| !x[:matched] }.
-            map { |x| x[:matcher] }
-        end
-
-        def last_failing_submatcher
-          failing_submatchers.last
+        def first_failing_submatcher
+          @_first_failing_submatcher ||= @submatchers.detect do |submatcher|
+            !submatcher.matches?(@subject)
+          end
         end
 
         def allowed_types
@@ -431,7 +467,7 @@ module Shoulda
 
         def comparison_descriptions
           description_array = submatcher_comparison_descriptions
-          description_array.empty? ? '' : ' which are ' + submatcher_comparison_descriptions.join(' and ')
+          description_array.empty? ? '' : 'which are ' + submatcher_comparison_descriptions.join(' and ')
         end
 
         def submatcher_comparison_descriptions

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

@@ -140,17 +140,9 @@ module Shoulda
         end
 
         def disallows_and_double_checks_value_of!(value, message)
-          error_class = Shoulda::Matchers::ActiveModel::CouldNotSetPasswordError
-
-          disallows_value_of(value, message) do |matcher|
-            matcher._after_setting_value do
-              actual_value = @subject.__send__(@attribute)
-
-              if !actual_value.nil?
-                raise error_class.create(@subject.class)
-              end
-            end
-          end
+          disallows_value_of(value, message)
+        rescue ActiveModel::AllowValueMatcher::CouldNotSetAttributeError
+          raise ActiveModel::CouldNotSetPasswordError.create(@subject.class)
         end
 
         def blank_value

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

@@ -0,0 +1,65 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class ValidationMessageFinder
+        include Helpers
+
+        def initialize(instance, attribute, context=nil)
+          @instance = instance
+          @attribute = attribute
+          @context = context
+        end
+
+        def allow_description(allowed_values)
+          "allow #{@attribute} to be set to #{allowed_values}"
+        end
+
+        def expected_message_from(attribute_message)
+          attribute_message
+        end
+
+        def has_messages?
+          errors.present?
+        end
+
+        def source_description
+          'errors'
+        end
+
+        def messages_description
+          if errors.empty?
+            ' no errors'
+          else
+            " errors:\n#{pretty_error_messages(validated_instance)}"
+          end
+        end
+
+        def messages
+          Array(messages_for_attribute)
+        end
+
+        private
+
+        def messages_for_attribute
+          errors[@attribute]
+        end
+
+        def errors
+          validated_instance.errors
+        end
+
+        def validated_instance
+          @validated_instance ||= validate_instance
+        end
+
+        def validate_instance
+          @instance.valid?(*@context)
+          @instance
+        end
+      end
+
+    end
+  end
+end
+

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

@@ -774,6 +774,29 @@ module Shoulda
       #         class_name('City')
       #     end
       #
+      # ##### join_table
+      #
+      # Use `join_table` to test usage of the `:join_table` option. This
+      # asserts that the table you're referring to actually exists.
+      #
+      #     class Person < ActiveRecord::Base
+      #       has_and_belongs_to_many :issues, join_table: 'people_tickets'
+      #     end
+      #
+      #     # RSpec
+      #     describe Person do
+      #       it do
+      #         should have_and_belong_to_many(:issues).
+      #           join_table('people_tickets')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PersonTest < ActiveSupport::TestCase
+      #       should have_and_belong_to_many(:issues).
+      #         join_table('people_tickets')
+      #     end
+      #
       # ##### validate
       #
       # Use `validate` to test that the `:validate` option was specified.
@@ -823,7 +846,9 @@ module Shoulda
       # @private
       class AssociationMatcher
         delegate :reflection, :model_class, :associated_class, :through?,
-          :join_table, :polymorphic?, to: :reflector
+          :polymorphic?, to: :reflector
+
+        attr_reader :name, :options
 
         def initialize(macro, name)
           @macro = macro
@@ -905,6 +930,11 @@ module Shoulda
           self
         end
 
+        def join_table(join_table_name)
+          @options[:join_table_name] = join_table_name
+          self
+        end
+
         def description
           description = "#{macro_description} #{name}"
           description += " class_name => #{options[:class_name]}" if options.key?(:class_name)
@@ -937,18 +967,22 @@ module Shoulda
             submatchers_match?
         end
 
+        def join_table_name
+          options[:join_table_name] || reflector.join_table_name
+        end
+
+        def option_verifier
+          @option_verifier ||= AssociationMatchers::OptionVerifier.new(reflector)
+        end
+
         protected
 
-        attr_reader :submatchers, :missing, :subject, :macro, :name, :options
+        attr_reader :submatchers, :missing, :subject, :macro
 
         def reflector
           @reflector ||= AssociationMatchers::ModelReflector.new(subject, name)
         end
 
-        def option_verifier
-          @option_verifier ||= AssociationMatchers::OptionVerifier.new(reflector)
-        end
-
         def add_submatcher(matcher)
           @submatchers << matcher
         end

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

@@ -8,8 +8,8 @@ module Shoulda
 
           alias :missing_option :failure_message
 
-          delegate :model_class, :join_table, :associated_class,
-            to: :association_matcher
+          delegate :model_class, :join_table_name, :associated_class, :options,
+            :name, :option_verifier, to: :association_matcher
 
           delegate :connection, to: :model_class
 
@@ -19,12 +19,26 @@ module Shoulda
           end
 
           def matches?(subject)
-            join_table_exists? &&
+            join_table_option_correct? &&
+              join_table_exists? &&
               join_table_has_correct_columns?
           end
 
+          def join_table_option_correct?
+            if options.key?(: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]}' for :join_table option"
+                false
+              end
+            else
+              true
+            end
+          end
+
           def join_table_exists?
-            if connection.tables.include?(join_table)
+            if connection.tables.include?(join_table_name)
               true
             else
               @failure_message = missing_table_message
@@ -60,16 +74,16 @@ module Shoulda
           end
 
           def actual_join_table_columns
-            connection.columns(join_table).map(&:name)
+            connection.columns(join_table_name).map(&:name)
           end
 
           def missing_table_message
-            "join table #{join_table} doesn't exist"
+            "join table #{join_table_name} doesn't exist"
           end
 
           def missing_columns_message
             missing = missing_columns.join(', ')
-            "join table #{join_table} missing #{column_label}: #{missing}"
+            "join table #{join_table_name} missing #{column_label}: #{missing}"
           end
 
           def column_label