mcmire-shoulda-matchers 2.5.0

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

@@ -0,0 +1,337 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `ensure_length_of` matcher tests usage of the `validates_length_of`
+      # matcher. Note that this matcher is intended to be used against string
+      # columns and not integer columns.
+      #
+      # #### Qualifiers
+      #
+      # One of `is_equal_to`, `is_at_least`, or `is_at_most` must be used.
+      #
+      # ##### is_at_least
+      #
+      # Use `is_at_least` to test usage of the `:minimum` option. This asserts
+      # that the attribute can take a string which is equal to or longer than
+      # the given length and cannot take a string which is shorter.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_length_of :bio, minimum: 15
+      #     end
+      #
+      #     # RSpec
+      #
+      #     describe User do
+      #       it { should ensure_length_of(:bio).is_at_least(15) }
+      #     end
+      #
+      #     # Test::Unit
+      #
+      #     class UserTest < ActiveSupport::TestCase
+      #       should ensure_length_of(:bio).is_at_least(15)
+      #     end
+      #
+      # ##### is_at_most
+      #
+      # Use `is_at_most` to test usage of the `:maximum` option. This asserts
+      # that the attribute can take a string which is equal to or shorter than
+      # the given length and cannot take a string which is longer.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_length_of :status_update, maximum: 140
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should ensure_length_of(:status_update).is_at_most(140) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should ensure_length_of(:status_update).is_at_most(140)
+      #     end
+      #
+      # ##### is_equal_to
+      #
+      # Use `is_at_equal` to test usage of the `:is` option. This asserts that
+      # the attribute can take a string which is exactly equal to the given
+      # length and cannot take a string which is shorter or longer.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_length_of :favorite_superhero, is: 6
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should ensure_length_of(:favorite_superhero).is_equal_to(6) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should ensure_length_of(:favorite_superhero).is_equal_to(6)
+      #     end
+      #
+      # ##### is_at_least + is_at_most
+      #
+      # Use `is_at_least` and `is_at_most` to test usage of the `:in` option.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_length_of :password, in: 5..30
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should ensure_length_of(:password).is_at_least(5).is_at_most(30) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should ensure_length_of(:password).is_at_least(5).is_at_most(30)
+      #     end
+      #
+      # ##### with_message
+      #
+      # Use `with_message` if you are using a custom validation message.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_length_of :api_token,
+      #         minimum: 10,
+      #         message: "Password isn't long enough"
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it do
+      #         should ensure_length_of(:password).
+      #           is_at_least(10).
+      #           with_message("Password isn't long enough")
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should ensure_length_of(:password).
+      #         is_at_least(10).
+      #         with_message("Password isn't long enough")
+      #     end
+      #
+      # ##### with_short_message
+      #
+      # Use `with_short_message` if you are using a custom "too short" message.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_length_of :secret_key,
+      #         in: 15..100,
+      #         too_short: 'Secret key must be more than 15 characters'
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it do
+      #         should ensure_length_of(:secret_key).
+      #           is_at_least(15).
+      #           with_short_message('Secret key must be more than 15 characters')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should ensure_length_of(:secret_key).
+      #         is_at_least(15).
+      #         with_short_message('Secret key must be more than 15 characters')
+      #     end
+      #
+      # ##### with_long_message
+      #
+      # Use `with_long_message` if you are using a custom "too long" message.
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       validates_length_of :secret_key,
+      #         in: 15..100,
+      #         too_long: 'Secret key must be less than 100 characters'
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it do
+      #         should ensure_length_of(:secret_key).
+      #           is_at_most(100).
+      #           with_long_message('Secret key must be less than 100 characters')
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should ensure_length_of(:secret_key).
+      #         is_at_most(100).
+      #         with_long_message('Secret key must be less than 100 characters')
+      #     end
+      #
+      # @return [EnsureLengthOfMatcher]
+      #
+      def ensure_length_of(attr)
+        EnsureLengthOfMatcher.new(attr)
+      end
+
+      # @private
+      class EnsureLengthOfMatcher < ValidationMatcher
+        include Helpers
+
+        def initialize(attribute)
+          super(attribute)
+          @options = {}
+        end
+
+        def is_at_least(length)
+          @options[:minimum] = length
+          @short_message ||= :too_short
+          self
+        end
+
+        def is_at_most(length)
+          @options[:maximum] = length
+          @long_message ||= :too_long
+          self
+        end
+
+        def is_equal_to(length)
+          @options[:minimum] = length
+          @options[:maximum] = length
+          @short_message ||= :wrong_length
+          @long_message ||= :wrong_length
+          self
+        end
+
+        def with_short_message(message)
+          if message
+            @short_message = message
+          end
+          self
+        end
+
+        def with_long_message(message)
+          if message
+            @long_message = message
+          end
+          self
+        end
+
+        def with_message(message)
+          if message
+            @short_message = message
+            @long_message = message
+          end
+          self
+        end
+
+        def description
+          description =  "ensure #{@attribute} has a length "
+          if @options.key?(:minimum) && @options.key?(:maximum)
+            if @options[:minimum] == @options[:maximum]
+              description << "of exactly #{@options[:minimum]}"
+            else
+              description << "between #{@options[:minimum]} and #{@options[:maximum]}"
+            end
+          else
+            description << "of at least #{@options[:minimum]}" if @options[:minimum]
+            description << "of at most #{@options[:maximum]}" if @options[:maximum]
+          end
+          description
+        end
+
+        def matches?(subject)
+          super(subject)
+          translate_messages!
+          lower_bound_matches? && upper_bound_matches?
+        end
+
+        private
+
+        def translate_messages!
+          if Symbol === @short_message
+            @short_message = default_error_message(@short_message,
+                                                   model_name: @subject.class.to_s.underscore,
+                                                   instance: @subject,
+                                                   attribute: @attribute,
+                                                   count: @options[:minimum])
+          end
+
+          if Symbol === @long_message
+            @long_message = default_error_message(@long_message,
+                                                  model_name: @subject.class.to_s.underscore,
+                                                  instance: @subject,
+                                                  attribute: @attribute,
+                                                  count: @options[:maximum])
+          end
+        end
+
+        def lower_bound_matches?
+          disallows_lower_length? && allows_minimum_length?
+        end
+
+        def upper_bound_matches?
+          disallows_higher_length? && allows_maximum_length?
+        end
+
+        def disallows_lower_length?
+          if @options.key?(:minimum)
+            @options[:minimum] == 0 ||
+              disallows_length_of?(@options[:minimum] - 1, @short_message)
+          else
+            true
+          end
+        end
+
+        def disallows_higher_length?
+          if @options.key?(:maximum)
+            disallows_length_of?(@options[:maximum] + 1, @long_message)
+          else
+            true
+          end
+        end
+
+        def allows_minimum_length?
+          if @options.key?(:minimum)
+            allows_length_of?(@options[:minimum], @short_message)
+          else
+            true
+          end
+        end
+
+        def allows_maximum_length?
+          if @options.key?(:maximum)
+            allows_length_of?(@options[:maximum], @long_message)
+          else
+            true
+          end
+        end
+
+        def allows_length_of?(length, message)
+          allows_value_of(string_of_length(length), message)
+        end
+
+        def disallows_length_of?(length, message)
+          disallows_value_of(string_of_length(length), message)
+        end
+
+        def string_of_length(length)
+          'x' * length
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class CouldNotDetermineValueOutsideOfArray < RuntimeError; end
+      # @private
+      class NonNullableBooleanError < Shoulda::Matchers::Error; end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # @private
+      class ExceptionMessageFinder
+        def initialize(instance, attribute, context=nil)
+          @instance = instance
+          @attribute = attribute
+          @context = context
+        end
+
+        def allow_description(allowed_values)
+          "doesn't raise when #{@attribute} is set to #{allowed_values}"
+        end
+
+        def messages_description
+          if has_messages?
+            messages.join
+          else
+            'no exception'
+          end
+        end
+
+        def has_messages?
+          messages.any?
+        end
+
+        def messages
+          @messages ||= validate_and_rescue
+        end
+
+        def source_description
+          'exception'
+        end
+
+        def expected_message_from(attribute_message)
+          "#{human_attribute_name} #{attribute_message}"
+        end
+
+        private
+
+        def validate_and_rescue
+          @instance.valid?(@context)
+          []
+        rescue ::ActiveModel::StrictValidationFailed => exception
+          [exception.message]
+        end
+
+        def human_attribute_name
+          @instance.class.human_attribute_name(@attribute)
+        end
+      end
+
+    end
+  end
+end
+
+

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

@@ -0,0 +1,92 @@
+module Shoulda
+  module Matchers
+    module ActiveModel
+      # The `have_secure_password` matcher tests usage of the
+      # `has_secure_password` macro.
+      #
+      # #### Example
+      #
+      #     class User
+      #       include ActiveModel::Model
+      #
+      #       has_secure_password
+      #     end
+      #
+      #     # RSpec
+      #     describe User do
+      #       it { should have_secure_password }
+      #     end
+      #
+      #     # Test::Unit
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_secure_password
+      #     end
+      #
+      # @return [HaveSecurePasswordMatcher]
+      #
+      def have_secure_password
+        HaveSecurePasswordMatcher.new
+      end
+
+      # @private
+      class HaveSecurePasswordMatcher
+        attr_reader :failure_message
+
+        alias failure_message_for_should failure_message
+
+        CORRECT_PASSWORD = "aBcDe12345"
+        INCORRECT_PASSWORD = "password"
+
+        EXPECTED_METHODS = [
+          :authenticate,
+          :password=,
+          :password_confirmation=,
+          :password_digest,
+          :password_digest=,
+        ]
+
+        MESSAGES = {
+          authenticated_incorrect_password: "expected %{subject} to not authenticate an incorrect password",
+          did_not_authenticate_correct_password: "expected %{subject} to authenticate the correct password",
+          method_not_found: "expected %{subject} to respond to %{methods}"
+        }
+
+        def description
+          "have a secure password"
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          if failure = validate
+            key, params = failure
+            @failure_message = MESSAGES[key] % { subject: subject.class }.merge(params)
+          end
+
+          failure.nil?
+        end
+
+        private
+
+        attr_reader :subject
+
+        def validate
+          missing_methods = EXPECTED_METHODS.select {|m| !subject.respond_to?(m) }
+
+          if missing_methods.present?
+            [:method_not_found, { methods: missing_methods.to_sentence }]
+          else
+            subject.password = CORRECT_PASSWORD
+            subject.password_confirmation = CORRECT_PASSWORD
+
+            if not subject.authenticate(CORRECT_PASSWORD)
+              [:did_not_authenticate_correct_password, {}]
+            elsif subject.authenticate(INCORRECT_PASSWORD)
+              [:authenticated_incorrect_password, {}]
+            end
+          end
+        end
+      end
+    end
+  end
+end