shoulda-matchers 2.8.0 → 3.0.0.rc1

data/lib/shoulda/matchers/action_controller/set_session_or_flash_matcher.rb

@@ -0,0 +1,103 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # @private
+      class SetSessionOrFlashMatcher
+        def initialize(store)
+          @store = store
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def [](key)
+          @key = key
+          self
+        end
+
+        def to(expected_value = nil, &block)
+          if block
+            unless context_set?
+              message = "When specifying a value as a block, a context must be specified beforehand, e.g., #{store.name}.in_context(context).to { ... }"
+              raise ArgumentError, message
+            end
+
+            @expected_value = context.instance_eval(&block)
+          else
+            @expected_value = expected_value
+          end
+
+          self
+        end
+
+        def description
+          "should #{expectation_description}"
+        end
+
+        def matches?(controller)
+          @controller = store.controller = controller
+          !store.empty? && key_matches? && expected_value_matches?
+        end
+
+        def failure_message
+          "Expected #{controller.class} to #{expectation_description}, but it did not"
+        end
+        alias_method :failure_message_for_should, :failure_message
+
+        def failure_message_when_negated
+          "Expected #{controller.class} not to #{expectation_description}, but it did"
+        end
+        alias_method :failure_message_for_should_not,
+          :failure_message_when_negated
+
+        protected
+
+        attr_reader :store, :context, :key, :expected_value, :controller
+
+        private
+
+        def context_set?
+          defined?(@context)
+        end
+
+        def key_set?
+          defined?(@key)
+        end
+
+        def expected_value_set?
+          defined?(@expected_value)
+        end
+
+        def key_matches?
+          !key_set? || store.has_key?(key)
+        end
+
+        def expected_value_matches?
+          !expected_value_set? || store.has_value?(expected_value)
+        end
+
+        def expectation_description
+          string = 'set'
+
+          if key_set?
+            string << " #{store.name}[#{key.inspect}]"
+          else
+            string << " any key in #{store.name}"
+          end
+
+          if expected_value_set?
+            if expected_value.is_a?(Regexp)
+              string << " to a value matching #{expected_value.inspect}"
+            else
+              string << " to #{expected_value.inspect}"
+            end
+          end
+
+          string
+        end
+      end
+    end
+  end
+end

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

@@ -84,9 +84,6 @@ module Shoulda
         end
 
         def as(role)
-          if active_model_less_than_3_1?
-            raise 'You can specify role only in Rails 3.1 or greater'
-          end
           @options[:role] = role
           self
         end
@@ -153,20 +150,12 @@ module Shoulda
         end
 
         def authorizer
-          if active_model_less_than_3_1?
-            @subject.class.active_authorizer
-          else
-            @subject.class.active_authorizer[role]
-          end
+          @subject.class.active_authorizer[role]
         end
 
         def class_name
           @subject.class.name
         end
-
-        def active_model_less_than_3_1?
-          ::ActiveModel::VERSION::STRING.to_f < 3.1
-        end
       end
     end
   end

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

@@ -118,9 +118,36 @@ module Shoulda
       #         with_message('State must be open or closed')
       #     end
       #
+      # Use `with_message` with a regexp to perform a partial match:
+      #
+      #     class UserProfile
+      #       include ActiveModel::Model
+      #       attr_accessor :state
+      #
+      #       validates_format_of :state,
+      #         with: /^(open|closed)$/,
+      #         message: 'State must be open or closed'
+      #     end
+      #
+      #     # RSpec
+      #     describe UserProfile do
+      #       it do
+      #         should allow_value('open', 'closed').
+      #           for(:state).
+      #           with_message(/open or closed/)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserProfileTest < ActiveSupport::TestCase
+      #       should allow_value('open', 'closed').
+      #         for(:state).
+      #         with_message(/open or closed/)
+      #     end
+      #
       # Use `with_message` with the `:against` option if the attribute the
       # validation message is stored under is different from the attribute
-      # being validated.
+      # being validated:
       #
       #     class UserProfile
       #       include ActiveModel::Model
@@ -167,9 +194,28 @@ module Shoulda
           AllowValueMatcher.new(*values)
         end
       end
+      alias_method :allow_values, :allow_value
 
       # @private
       class AllowValueMatcher
+        # @private
+        class CouldNotSetAttributeError < Shoulda::Matchers::Error
+          def self.create(model, attribute, expected_value, actual_value)
+            super(
+              model: model,
+              attribute: attribute,
+              expected_value: expected_value,
+              actual_value: actual_value
+            )
+          end
+
+          attr_accessor :model, :attribute, :expected_value, :actual_value
+
+          def message
+            "Expected #{model.class} to be able to set #{attribute} to #{expected_value.inspect}, but got #{actual_value.inspect} instead."
+          end
+        end
+
         include Helpers
 
         attr_accessor :attribute_with_message
@@ -215,14 +261,12 @@ module Shoulda
 
         def matches?(instance)
           self.instance = instance
-          validator.record = instance
+          values_to_match.all? { |value| value_matches?(value) }
+        end
 
-          values_to_match.none? do |value|
-            validator.reset
-            self.value = value
-            set_attribute(value)
-            errors_match? || any_range_error_occurred?
-          end
+        def does_not_match?(instance)
+          self.instance = instance
+          values_to_match.all? { |value| !value_matches?(value) }
         end
 
         def failure_message
@@ -241,15 +285,26 @@ module Shoulda
 
         protected
 
-        attr_reader :attribute_to_check_message_against
-        attr_accessor :values_to_match, :instance, :attribute_to_set, :value,
+        attr_reader :instance, :attribute_to_check_message_against
+        attr_accessor :values_to_match, :attribute_to_set, :value,
           :matched_error, :after_setting_value_callback, :validator
 
+        def instance=(instance)
+          @instance = instance
+          validator.record = instance
+        end
+
         def attribute_to_check_message_against=(attribute)
           @attribute_to_check_message_against = attribute
           validator.attribute = attribute
         end
 
+        def value_matches?(value)
+          self.value = value
+          set_attribute(value)
+          !(errors_match? || any_range_error_occurred?)
+        end
+
         def set_attribute(value)
           set_attribute_ignoring_range_errors(value)
           after_setting_value_callback.call
@@ -257,6 +312,7 @@ module Shoulda
 
         def set_attribute_ignoring_range_errors(value)
           instance.__send__("#{attribute_to_set}=", value)
+          ensure_that_attribute_has_been_changed_to_or_from_nil!(value)
         rescue RangeError => exception
           # Have to reset the attribute so that we don't get a RangeError the
           # next time we attempt to write the attribute (ActiveRecord seems to
@@ -269,6 +325,19 @@ module Shoulda
           instance.send(:raw_write_attribute, attribute_to_set, nil)
         end
 
+        def ensure_that_attribute_has_been_changed_to_or_from_nil!(expected_value)
+          actual_value = instance.__send__(attribute_to_set)
+
+          if expected_value.nil? != actual_value.nil?
+            raise CouldNotSetAttributeError.create(
+              instance.class,
+              attribute_to_set,
+              expected_value,
+              actual_value
+            )
+          end
+        end
+
         def errors_match?
           has_messages? && errors_for_attribute_match?
         end

data/lib/shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher.rb

@@ -17,6 +17,16 @@ module Shoulda
             self
           end
 
+          def strict
+            @disallow_value_matcher.strict
+            self
+          end
+
+          def on(context)
+            @disallow_value_matcher.on(context)
+            self
+          end
+
           def allowed_type
             raise NotImplementedError
           end

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

@@ -23,6 +23,27 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Artillery
+      #       include ActiveModel::Model
+      #       attr_accessor :arms
+      #
+      #       validates_absence_of :arms, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe Artillery do
+      #       it { should validate_absence_of(:arms).on(:create) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class ArtilleryTest < ActiveSupport::TestCase
+      #       should validate_absence_of(:arms).on(:create)
+      #     end
+      #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.

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

@@ -23,6 +23,30 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Registration
+      #       include ActiveModel::Model
+      #       attr_accessor :terms_of_service
+      #
+      #       validates_acceptance_of :terms_of_service, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe Registration do
+      #       it do
+      #         should validate_acceptance_of(:terms_of_service).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class RegistrationTest < ActiveSupport::TestCase
+      #       should validate_acceptance_of(:terms_of_service).on(:create)
+      #     end
+      #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.

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

@@ -23,6 +23,27 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #       attr_accessor :password
+      #
+      #       validates_confirmation_of :password, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should validate_confirmation_of(:password).on(:create) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should validate_confirmation_of(:password).on(:create)
+      #     end
+      #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.
@@ -109,7 +130,7 @@ module Shoulda
 
         def qualify_matcher(matcher)
           matcher.with_message(@message,
-            against: error_attribute,
+            against: confirmation_attribute,
             values: { attribute: attribute }
           )
         end
@@ -120,10 +141,6 @@ module Shoulda
             @subject.__send__(setter, val)
           end
         end
-
-        def error_attribute
-          RailsShim.validates_confirmation_of_error_attribute(self)
-        end
       end
     end
   end

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

@@ -54,6 +54,35 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Game
+      #       include ActiveModel::Model
+      #       attr_accessor :weapon
+      #
+      #       validates_exclusion_of :weapon,
+      #         in: ['pistol', 'paintball gun', 'stick'],
+      #         on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe Game do
+      #       it do
+      #         should validate_exclusion_of(:weapon).
+      #           in_array(['pistol', 'paintball gun', 'stick']).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class GameTest < ActiveSupport::TestCase
+      #       should validate_exclusion_of(:weapon).
+      #         in_array(['pistol', 'paintball gun', 'stick']).
+      #         on(:create)
+      #     end
+      #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.
@@ -89,16 +118,6 @@ module Shoulda
         ValidateExclusionOfMatcher.new(attr)
       end
 
-      # @deprecated Use {#validate_exclusion_of} instead.
-      # @return [ValidateExclusionOfMatcher]
-      def ensure_exclusion_of(attr)
-        Shoulda::Matchers.warn_about_deprecated_method(
-          :ensure_exclusion_of,
-          :validate_exclusion_of
-        )
-        validate_exclusion_of(attr)
-      end
-
       # @private
       class ValidateExclusionOfMatcher < ValidationMatcher
         def initialize(attribute)