mcmire-shoulda-matchers 2.5.0

data/lib/shoulda/matchers/active_model.rb

@@ -0,0 +1,30 @@
+require 'shoulda/matchers/active_model/helpers'
+require 'shoulda/matchers/active_model/validation_matcher'
+require 'shoulda/matchers/active_model/validation_message_finder'
+require 'shoulda/matchers/active_model/exception_message_finder'
+require 'shoulda/matchers/active_model/allow_value_matcher'
+require 'shoulda/matchers/active_model/disallow_value_matcher'
+require 'shoulda/matchers/active_model/ensure_length_of_matcher'
+require 'shoulda/matchers/active_model/ensure_inclusion_of_matcher'
+require 'shoulda/matchers/active_model/ensure_exclusion_of_matcher'
+require 'shoulda/matchers/active_model/validate_absence_of_matcher'
+require 'shoulda/matchers/active_model/validate_presence_of_matcher'
+require 'shoulda/matchers/active_model/validate_uniqueness_of_matcher'
+require 'shoulda/matchers/active_model/validate_acceptance_of_matcher'
+require 'shoulda/matchers/active_model/validate_confirmation_of_matcher'
+require 'shoulda/matchers/active_model/validate_numericality_of_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/comparison_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/odd_number_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/even_number_matcher'
+require 'shoulda/matchers/active_model/numericality_matchers/only_integer_matcher'
+require 'shoulda/matchers/active_model/allow_mass_assignment_of_matcher'
+require 'shoulda/matchers/active_model/errors'
+require 'shoulda/matchers/active_model/have_secure_password_matcher'
+
+module Shoulda
+  module Matchers
+    module ActiveModel
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `allow_mass_assignment_of` matcher tests usage of Rails 3's
+      # `attr_accessible` and `attr_protected` macros, asserting that an
+      # attribute in your model is contained in either the whitelist or
+      # blacklist and thus can or cannot be set via mass assignment.
+      #
+      #     class Post
+      #       include ActiveModel::Model
+      #
+      #       attr_accessible :title
+      #     end
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       attr_protected :encrypted_password
+      #     end
+      #
+      #     # RSpec
+      #     describe Post do
+      #       it { should allow_mass_assignment_of(:title) }
+      #     end
+      #
+      #     describe User do
+      #       it { should_not allow_mass_assignment_of(:encrypted_password) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostTest < ActiveSupport::TestCase
+      #       should allow_mass_assignment_of(:title)
+      #     end
+      #
+      #     class UserTest < ActiveSupport::TestCase
+      #       should_not allow_mass_assignment_of(:encrypted_password)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### as
+      #
+      # Use `as` if your mass-assignment rules apply only under a certain role
+      # (Rails >= 3.1 only).
+      #
+      #     class Post
+      #       include ActiveModel::Model
+      #
+      #       attr_accessible :title, as: :admin
+      #     end
+      #
+      #     # RSpec
+      #     describe Post do
+      #       it { should allow_mass_assignment_of(:title).as(:admin) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostTest < ActiveSupport::TestCase
+      #       should allow_mass_assignment_of(:title).as(:admin)
+      #     end
+      #
+      # @return [AllowMassAssignmentOfMatcher]
+      #
+      def allow_mass_assignment_of(value)
+        AllowMassAssignmentOfMatcher.new(value)
+      end
+
+      # @private
+      class AllowMassAssignmentOfMatcher
+        attr_reader :failure_message, :failure_message_when_negated
+
+        alias failure_message_for_should failure_message
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def initialize(attribute)
+          @attribute = attribute.to_s
+          @options = {}
+        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
+
+        def matches?(subject)
+          @subject = subject
+          if attr_mass_assignable?
+            if whitelisting?
+              @failure_message_when_negated = "#{@attribute} was made accessible"
+            else
+              if protected_attributes.empty?
+                @failure_message_when_negated = 'no attributes were protected'
+              else
+                @failure_message_when_negated = "#{class_name} is protecting " <<
+                  "#{protected_attributes.to_a.to_sentence}, " <<
+                  "but not #{@attribute}."
+              end
+            end
+            true
+          else
+            if whitelisting?
+              @failure_message = "Expected #{@attribute} to be accessible"
+            else
+              @failure_message = "Did not expect #{@attribute} to be protected"
+            end
+            false
+          end
+        end
+
+        def description
+          [base_description, role_description].compact.join(' ')
+        end
+
+        private
+
+        def base_description
+          "allow mass assignment of #{@attribute}"
+        end
+
+        def role_description
+          if role != :default
+            "as #{role}"
+          end
+        end
+
+        def role
+          @options[:role] || :default
+        end
+
+        def protected_attributes
+          @protected_attributes ||= (@subject.class.protected_attributes || [])
+        end
+
+        def accessible_attributes
+          @accessible_attributes ||= (@subject.class.accessible_attributes || [])
+        end
+
+        def whitelisting?
+          authorizer.kind_of?(::ActiveModel::MassAssignmentSecurity::WhiteList)
+        end
+
+        def attr_mass_assignable?
+          !authorizer.deny?(@attribute)
+        end
+
+        def authorizer
+          if active_model_less_than_3_1?
+            @subject.class.active_authorizer
+          else
+            @subject.class.active_authorizer[role]
+          end
+        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
+end

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

@@ -0,0 +1,314 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `allow_value` matcher is used to test that an attribute of a model
+      # can or cannot be set to a particular value or values. It is most
+      # commonly used in conjunction with the `validates_format_of` validation.
+      #
+      # #### should
+      #
+      # In the positive form, `allow_value` asserts that an attribute can be
+      # set to one or more values, succeeding if none of the values cause the
+      # record to be invalid:
+      #
+      #     class UserProfile
+      #       include ActiveModel::Model
+      #
+      #       validates_format_of :website_url, with: URI.regexp
+      #     end
+      #
+      #     # RSpec
+      #     describe UserProfile do
+      #       it { should allow_value('http://foo.com', 'http://bar.com/baz').for(:website_url) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserProfileTest < ActiveSupport::TestCase
+      #       should allow_value('http://foo.com', 'http://bar.com/baz').for(:website_url)
+      #     end
+      #
+      # #### should_not
+      #
+      # In the negative form, `allow_value` asserts that an attribute cannot be
+      # set to one or more values, succeeding if the *first* value causes the
+      # record to be invalid.
+      #
+      # **This can be surprising** so in this case if you need to check that
+      # *all* of the values are invalid, use separate assertions:
+      #
+      #     class UserProfile
+      #       include ActiveModel::Model
+      #
+      #       validates_format_of :website_url, with: URI.regexp
+      #     end
+      #
+      #     describe UserProfile do
+      #       # One assertion: 'buz' and 'bar' will not be tested
+      #       it { should_not allow_value('fiz', 'buz', 'bar').for(:website_url) }
+      #
+      #       # Three assertions, all tested separately
+      #       it { should_not allow_value('fiz').for(:website_url) }
+      #       it { should_not allow_value('buz').for(:website_url) }
+      #       it { should_not allow_value('bar').for(:website_url) }
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### on
+      #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class UserProfile
+      #       include ActiveModel::Model
+      #
+      #       validates_format_of :birthday_as_string,
+      #         with: /^(\d+)-(\d+)-(\d+)$/,
+      #         on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe UserProfile do
+      #       it do
+      #         should allow_value('2013-01-01').
+      #           for(:birthday_as_string).
+      #           on(:create)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserProfileTest < ActiveSupport::TestCase
+      #       should allow_value('2013-01-01').
+      #         for(:birthday_as_string).
+      #         on(:create)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class UserProfile
+      #       include ActiveModel::Model
+      #
+      #       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('State must be open or closed')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserProfileTest < ActiveSupport::TestCase
+      #       should allow_value('open', 'closed').
+      #         for(:state).
+      #         with_message('State must be 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.
+      #
+      #     class UserProfile
+      #       include ActiveModel::Model
+      #
+      #       validate :sports_team_must_be_valid
+      #
+      #       private
+      #
+      #       def sports_team_must_be_valid
+      #         if sports_team !~ /^(Broncos|Titans)$/i
+      #           self.errors.add :chosen_sports_team, 'Must be either a Broncos fan or a Titans fan'
+      #         end
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe UserProfile do
+      #       it do
+      #         should allow_value('Broncos', 'Titans').
+      #           for(:sports_team).
+      #           with_message('Must be either a Broncos or Titans fan',
+      #             against: :chosen_sports_team
+      #           )
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserProfileTest < ActiveSupport::TestCase
+      #       should allow_value('Broncos', 'Titans').
+      #         for(:sports_team).
+      #         with_message('Must be either a Broncos or Titans fan',
+      #           against: :chosen_sports_team
+      #         )
+      #     end
+      #
+      # @return [AllowValueMatcher]
+      #
+      def allow_value(*values)
+        if values.empty?
+          raise ArgumentError, 'need at least one argument'
+        else
+          AllowValueMatcher.new(*values)
+        end
+      end
+
+      # @private
+      class AllowValueMatcher
+        include Helpers
+
+        attr_accessor :attribute_with_message
+        attr_accessor :options
+
+        def initialize(*values)
+          self.values_to_match = values
+          self.message_finder_factory = ValidationMessageFinder
+          self.options = {}
+        end
+
+        def for(attribute)
+          self.attribute_to_set = attribute
+          self.attribute_to_check_message_against = attribute
+          self
+        end
+
+        def on(context)
+          @context = context
+          self
+        end
+
+        def with_message(message, options={})
+          self.options[:expected_message] = message
+          if options.key?(:against)
+            self.attribute_to_check_message_against = options[:against]
+          end
+          self
+        end
+
+        def strict
+          self.message_finder_factory = ExceptionMessageFinder
+          self
+        end
+
+        def matches?(instance)
+          self.instance = instance
+
+          values_to_match.none? do |value|
+            self.value = value
+            instance.__send__("#{attribute_to_set}=", value)
+            errors_match?
+          end
+        end
+
+        def failure_message
+          "Did not expect #{expectation}, got error: #{matched_error}"
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          "Expected #{expectation}, got #{error_description}"
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def description
+          message_finder.allow_description(allowed_values)
+        end
+
+        private
+
+        attr_accessor :values_to_match, :message_finder_factory,
+          :instance, :attribute_to_set, :attribute_to_check_message_against,
+          :context, :value, :matched_error
+
+        def errors_match?
+          has_messages? && errors_for_attribute_match?
+        end
+
+        def has_messages?
+          message_finder.has_messages?
+        end
+
+        def errors_for_attribute_match?
+          if expected_message
+            self.matched_error = errors_match_regexp? || errors_match_string?
+          else
+            errors_for_attribute.compact.any?
+          end
+        end
+
+        def errors_for_attribute
+          message_finder.messages
+        end
+
+        def errors_match_regexp?
+          if Regexp === expected_message
+            errors_for_attribute.detect { |e| e =~ expected_message }
+          end
+        end
+
+        def errors_match_string?
+          if errors_for_attribute.include?(expected_message)
+            expected_message
+          end
+        end
+
+        def expectation
+          includes_expected_message = expected_message ? "to include #{expected_message.inspect}" : ''
+          [error_source, includes_expected_message, "when #{attribute_to_set} is set to #{value.inspect}"].join(' ')
+        end
+
+        def error_source
+          message_finder.source_description
+        end
+
+        def error_description
+          message_finder.messages_description
+        end
+
+        def allowed_values
+          if values_to_match.length > 1
+            "any of [#{values_to_match.map(&:inspect).join(', ')}]"
+          else
+            values_to_match.first.inspect
+          end
+        end
+
+        def expected_message
+          if options.key?(:expected_message)
+            if Symbol === options[:expected_message]
+              default_expected_message
+            else
+              options[:expected_message]
+            end
+          end
+        end
+
+        def default_expected_message
+          message_finder.expected_message_from(default_attribute_message)
+        end
+
+        def default_attribute_message
+          default_error_message(
+            options[:expected_message],
+            model_name: model_name,
+            instance: instance,
+            attribute: attribute_to_set
+          )
+        end
+
+        def model_name
+          instance.class.to_s.underscore
+        end
+
+        def message_finder
+          message_finder_factory.new(instance, attribute_to_check_message_against, context)
+        end
+      end
+    end
+  end
+end