mcmire-shoulda-matchers 2.5.0 → 2.6.1.docs.1

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

@@ -4,7 +4,9 @@ module Shoulda
       # The `validate_numericality_of` matcher tests usage of the
       # `validates_numericality_of` validation.
       #
-      #     class Person < ActiveRecord::Base
+      #     class Person
+      #       include ActiveModel::Model
+      #
       #       validates_numericality_of :gpa
       #     end
       #
@@ -57,7 +59,10 @@ module Shoulda
       #
       #     # RSpec
       #     describe Person do
-      #       it { should validate_numericality_of(:number_of_cars).is_less_than(2) }
+      #       it do
+      #         should validate_numericality_of(:number_of_cars).
+      #           is_less_than(2)
+      #       end
       #     end
       #
       #     # Test::Unit
@@ -80,12 +85,16 @@ module Shoulda
       #
       #     # RSpec
       #     describe Person do
-      #       it { should validate_numericality_of(:birth_year).is_less_than_or_equal_to(1987) }
+      #       it do
+      #         should validate_numericality_of(:birth_year).
+      #           is_less_than_or_equal_to(1987)
+      #       end
       #     end
       #
       #     # Test::Unit
       #     class PersonTest < ActiveSupport::TestCase
-      #       should validate_numericality_of(:birth_year).is_less_than_or_equal_to(1987)
+      #       should validate_numericality_of(:birth_year).
+      #         is_less_than_or_equal_to(1987)
       #     end
       #
       # ##### is_equal_to
@@ -125,12 +134,16 @@ module Shoulda
       #
       #     # RSpec
       #     describe Person do
-      #       it { should validate_numericality_of(:height).is_greater_than_or_equal_to(55) }
+      #       it do
+      #         should validate_numericality_of(:height).
+      #           is_greater_than_or_equal_to(55)
+      #       end
       #     end
       #
       #     # Test::Unit
       #     class PersonTest < ActiveSupport::TestCase
-      #       should validate_numericality_of(:height).is_greater_than_or_equal_to(55)
+      #       should validate_numericality_of(:height).
+      #         is_greater_than_or_equal_to(55)
       #     end
       #
       # ##### is_greater_than
@@ -147,12 +160,16 @@ module Shoulda
       #
       #     # RSpec
       #     describe Person do
-      #       it { should validate_numericality_of(:legal_age).is_greater_than(21) }
+      #       it do
+      #         should validate_numericality_of(:legal_age).
+      #           is_greater_than(21)
+      #       end
       #     end
       #
       #     # Test::Unit
       #     class PersonTest < ActiveSupport::TestCase
-      #       should validate_numericality_of(:legal_age).is_greater_than(21)
+      #       should validate_numericality_of(:legal_age).
+      #         is_greater_than(21)
       #     end
       #
       # ##### even
@@ -198,49 +215,49 @@ module Shoulda
       #       should validate_numericality_of(:birth_day).odd
       #     end
       #
-      # ##### allow_nil
+      # ##### with_message
       #
-      # Use `allow_nil` to assert that the attribute allows nil.
+      # Use `with_message` if you are using a custom validation message.
       #
       #     class Person
       #       include ActiveModel::Model
       #
-      #       validate_numericality_of :rank, allow_nil: true
+      #       validates_numericality_of :number_of_dependents,
+      #         message: 'Number of dependents must be a number'
       #     end
       #
       #     # RSpec
       #     describe Person do
-      #       it { should validate_numericality_of(:rank).allow_nil }
+      #       it do
+      #         should validate_numericality_of(:number_of_dependents).
+      #           with_message('Number of dependents must be a number')
+      #       end
       #     end
       #
       #     # Test::Unit
       #     class PersonTest < ActiveSupport::TestCase
-      #       should validate_uniqueness_of(:rank).allow_nil
+      #       should validate_numericality_of(:number_of_dependents).
+      #         with_message('Number of dependents must be a number')
       #     end
       #
-      # ##### with_message
+      # ##### allow_nil
       #
-      # Use `with_message` if you are using a custom validation message.
+      # Use `allow_nil` to assert that the attribute allows nil.
       #
-      #     class Person
+      #     class Post
       #       include ActiveModel::Model
       #
-      #       validates_numericality_of :number_of_dependents,
-      #         message: 'Number of dependents must be a number'
+      #       validates_uniqueness_of :author_id, allow_nil: true
       #     end
       #
       #     # RSpec
-      #     describe Person do
-      #       it do
-      #         should validate_numericality_of(:number_of_dependents).
-      #           with_message('Number of dependents must be a number')
-      #       end
+      #     describe Post do
+      #       it { should validate_uniqueness_of(:author_id).allow_nil }
       #     end
       #
       #     # Test::Unit
-      #     class PersonTest < ActiveSupport::TestCase
-      #       should validate_numericality_of(:number_of_dependents).
-      #         with_message('Number of dependents must be a number')
+      #     class PostTest < ActiveSupport::TestCase
+      #       should validate_uniqueness_of(:author_id).allow_nil
       #     end
       #
       # @return [ValidateNumericalityOfMatcher]
@@ -253,53 +270,69 @@ module Shoulda
       class ValidateNumericalityOfMatcher
         NUMERIC_NAME = 'numbers'
         NON_NUMERIC_VALUE = 'abcd'
+        DEFAULT_DIFF_TO_COMPARE = 1
+
+        attr_reader :diff_to_compare
 
         def initialize(attribute)
           @attribute = attribute
           @submatchers = []
-
+          @diff_to_compare = DEFAULT_DIFF_TO_COMPARE
           add_disallow_value_matcher
         end
 
         def only_integer
-          add_submatcher(NumericalityMatchers::OnlyIntegerMatcher.new(@attribute))
+          prepare_submatcher(
+            NumericalityMatchers::OnlyIntegerMatcher.new(@attribute)
+          )
           self
         end
 
-        def is_greater_than(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :>).for(@attribute))
+        def allow_nil
+          prepare_submatcher(
+            AllowValueMatcher.new(nil)
+              .for(@attribute)
+              .with_message(:not_a_number)
+          )
           self
         end
 
-        def is_greater_than_or_equal_to(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :>=).for(@attribute))
+        def odd
+          prepare_submatcher(
+            NumericalityMatchers::OddNumberMatcher.new(@attribute)
+          )
           self
         end
 
-        def is_equal_to(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :==).for(@attribute))
+        def even
+          prepare_submatcher(
+            NumericalityMatchers::EvenNumberMatcher.new(@attribute)
+          )
           self
         end
 
-        def is_less_than(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :<).for(@attribute))
+        def is_greater_than(value)
+          prepare_submatcher(comparison_matcher_for(value, :>).for(@attribute))
           self
         end
 
-        def is_less_than_or_equal_to(value)
-          add_submatcher(NumericalityMatchers::ComparisonMatcher.new(value, :<=).for(@attribute))
+        def is_greater_than_or_equal_to(value)
+          prepare_submatcher(comparison_matcher_for(value, :>=).for(@attribute))
           self
         end
 
-        def odd
-          odd_number_matcher = NumericalityMatchers::OddNumberMatcher.new(@attribute)
-          add_submatcher(odd_number_matcher)
+        def is_equal_to(value)
+          prepare_submatcher(comparison_matcher_for(value, :==).for(@attribute))
           self
         end
 
-        def even
-          even_number_matcher = NumericalityMatchers::EvenNumberMatcher.new(@attribute)
-          add_submatcher(even_number_matcher)
+        def is_less_than(value)
+          prepare_submatcher(comparison_matcher_for(value, :<).for(@attribute))
+          self
+        end
+
+        def is_less_than_or_equal_to(value)
+          prepare_submatcher(comparison_matcher_for(value, :<=).for(@attribute))
           self
         end
 
@@ -337,10 +370,27 @@ module Shoulda
           add_submatcher(disallow_value_matcher)
         end
 
+        def prepare_submatcher(submatcher)
+          add_submatcher(submatcher)
+          if submatcher.respond_to?(:diff_to_compare)
+            update_diff_to_compare(submatcher)
+          end
+        end
+
+        def comparison_matcher_for(value, operator)
+          NumericalityMatchers::ComparisonMatcher
+            .new(self, value, operator)
+            .for(@attribute)
+        end
+
         def add_submatcher(submatcher)
           @submatchers << submatcher
         end
 
+        def update_diff_to_compare(matcher)
+          @diff_to_compare = [@diff_to_compare, matcher.diff_to_compare].max
+        end
+
         def submatchers_match?
           failing_submatchers.empty?
         end
@@ -372,7 +422,12 @@ module Shoulda
         end
 
         def submatcher_comparison_descriptions
-          @submatchers.inject([]){|m, s| m << s.comparison_description if s.respond_to?(:comparison_description); m }
+          @submatchers.inject([]) do |arr, submatcher|
+            if submatcher.respond_to? :comparison_description
+              arr << submatcher.comparison_description
+            end
+            arr
+          end
         end
       end
     end

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

@@ -4,7 +4,9 @@ module Shoulda
       # The `validate_presence_of` matcher tests usage of the
       # `validates_presence_of` validation.
       #
-      #     class Robot < ActiveRecord::Base
+      #     class Robot
+      #       include ActiveModel::Model
+      #
       #       validates_presence_of :arms
       #     end
       #
@@ -24,18 +26,24 @@ module Shoulda
       #
       # Use `with_message` if you are using a custom validation message.
       #
-      #     class Robot < ActiveRecord::Base
+      #     class Robot
+      #       include ActiveModel::Model
+      #
       #       validates_presence_of :legs, message: 'Robot has no legs'
       #     end
       #
       #     # RSpec
       #     describe Robot do
-      #       it { should validate_presence_of(:legs).with_message('Robot has no legs') }
+      #       it do
+      #         should validate_presence_of(:legs).
+      #           with_message('Robot has no legs')
+      #       end
       #     end
       #
       #     # Test::Unit
       #     class RobotTest < ActiveSupport::TestCase
-      #       should validate_presence_of(:legs).with_message('Robot has no legs')
+      #       should validate_presence_of(:legs).
+      #         with_message('Robot has no legs')
       #     end
       #
       # @return [ValidatePresenceOfMatcher]
@@ -54,7 +62,12 @@ module Shoulda
         def matches?(subject)
           super(subject)
           @expected_message ||= :blank
-          disallows_value_of(blank_value, @expected_message)
+
+          if secure_password_being_validated?
+            disallows_and_double_checks_value_of!(blank_value, @expected_message)
+          else
+            disallows_value_of(blank_value, @expected_message)
+          end
         end
 
         def description
@@ -63,6 +76,26 @@ module Shoulda
 
         private
 
+        def secure_password_being_validated?
+          defined?(::ActiveModel::SecurePassword) &&
+            @subject.class.ancestors.include?(::ActiveModel::SecurePassword::InstanceMethodsOnActivation) &&
+            @attribute == :password
+        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
+        end
+
         def blank_value
           if collection?
             []

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

@@ -9,7 +9,9 @@ module Shoulda
       # values which are the same as those of the pre-existing record (thereby
       # failing the uniqueness check).
       #
-      #     class Post < ActiveRecord::Base
+      #     class Post
+      #       include ActiveModel::Model
+      #
       #       validates_uniqueness_of :permalink
       #     end
       #
@@ -43,7 +45,9 @@ module Shoulda
       #       end
       #     end
       #
-      #     class Post < ActiveRecord::Base
+      #     class Post
+      #       include ActiveModel::Model
+      #
       #       validates :title, uniqueness: true
       #     end
       #
@@ -88,8 +92,11 @@ module Shoulda
       #
       # Use `with_message` if you are using a custom validation message.
       #
-      #     class Post < ActiveRecord::Base
-      #       validates_uniqueness_of :title, message: 'Please choose another title'
+      #     class Post
+      #       include ActiveModel::Model
+      #
+      #       validates_uniqueness_of :title,
+      #         message: 'Please choose another title'
       #     end
       #
       #     # RSpec
@@ -112,7 +119,9 @@ module Shoulda
       # a new record fails validation if not only the primary attribute is not
       # unique, but the scoped attributes are not unique either.
       #
-      #     class Post < ActiveRecord::Base
+      #     class Post
+      #       include ActiveModel::Model
+      #
       #       validates_uniqueness_of :slug, scope: :user_id
       #     end
       #
@@ -133,7 +142,9 @@ module Shoulda
       # validation even if their values are a different case than corresponding
       # attributes in the pre-existing record.
       #
-      #     class Post < ActiveRecord::Base
+      #     class Post
+      #       include ActiveModel::Model
+      #
       #       validates_uniqueness_of :key, case_sensitive: false
       #     end
       #
@@ -151,7 +162,9 @@ module Shoulda
       #
       # Use `allow_nil` to assert that the attribute allows nil.
       #
-      #     class Post < ActiveRecord::Base
+      #     class Post
+      #       include ActiveModel::Model
+      #
       #       validates_uniqueness_of :author_id, allow_nil: true
       #     end
       #
@@ -255,11 +268,6 @@ module Shoulda
 
           @subject.class.new.tap do |instance|
             instance.__send__("#{@attribute}=", value)
-            
-            other_non_nullable_columns.each do |non_nullable_column|
-              instance.__send__("#{non_nullable_column.name}=", correct_type_for_column(non_nullable_column))
-            end
-            
             if has_secure_password?
               instance.password = 'password'
               instance.password_confirmation = 'password'
@@ -313,7 +321,12 @@ module Shoulda
               previous_value ||= correct_type_for_column(@subject.class.columns_hash[scope.to_s])
 
               next_value =
-                if previous_value.respond_to?(:next)
+                if @subject.class.respond_to?(:defined_enums) && @subject.defined_enums[scope.to_s]
+                  available_values = @subject.defined_enums[scope.to_s].reject do |key, _|
+                    key == previous_value
+                  end
+                  available_values.keys.last
+                elsif previous_value.respond_to?(:next)
                   previous_value.next
                 elsif previous_value.respond_to?(:to_datetime)
                   previous_value.to_datetime.next
@@ -338,7 +351,7 @@ module Shoulda
         end
 
         def correct_type_for_column(column)
-          if column.type == :string || column.type == :binary
+          if column.type == :string
             '0'
           elsif column.type == :datetime
             DateTime.now
@@ -360,12 +373,6 @@ module Shoulda
           end
           value
         end
-
-        def other_non_nullable_columns
-          @subject.class.columns.select do |column|
-            column.name != @attribute && !column.null && !column.primary
-          end
-        end
       end
     end
   end

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

@@ -610,7 +610,7 @@ module Shoulda
       # @private
       class AssociationMatcher
         delegate :reflection, :model_class, :associated_class, :through?,
-          :join_table, to: :reflector
+          :join_table, :polymorphic?, to: :reflector
 
         def initialize(macro, name)
           @macro = macro
@@ -644,6 +644,13 @@ module Shoulda
           self
         end
 
+        def inverse_of(inverse_of)
+          inverse_of_matcher =
+            AssociationMatchers::InverseOfMatcher.new(inverse_of, name)
+          add_submatcher(inverse_of_matcher)
+          self
+        end
+
         def source(source)
           source_matcher = AssociationMatchers::SourceMatcher.new(source, name)
           add_submatcher(source_matcher)
@@ -700,7 +707,7 @@ module Shoulda
           @subject = subject
           association_exists? &&
             macro_correct? &&
-            class_exists? &&
+            (polymorphic? || class_exists?) &&
             foreign_key_exists? &&
             class_name_correct? &&
             autosave_correct? &&
@@ -766,6 +773,9 @@ module Shoulda
         def macro_correct?
           if reflection.macro == macro
             true
+          elsif reflection.macro == :has_many
+            macro == :has_and_belongs_to_many &&
+              reflection.name == @name
           else
             @missing = "actual association type was #{reflection.macro}"
             false

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

@@ -0,0 +1,41 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class InverseOfMatcher
+          attr_accessor :missing_option
+
+          def initialize(inverse_of, name)
+            @inverse_of = inverse_of
+            @name = name
+            @missing_option = ''
+          end
+
+          def description
+            "inverse_of => #{inverse_of}"
+          end
+
+          def matches?(subject)
+            self.subject = ModelReflector.new(subject, name)
+
+            if option_verifier.correct_for_string?(:inverse_of, inverse_of)
+              true
+            else
+              self.missing_option = "#{name} should have #{description}"
+              false
+            end
+          end
+
+          private
+
+          attr_accessor :subject, :inverse_of, :name
+
+          def option_verifier
+            @option_verifier ||= OptionVerifier.new(subject)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,13 +16,19 @@ module Shoulda
             reflection.klass
           end
 
+          def polymorphic?
+            reflection.options[:polymorphic]
+          end
+
           def through?
             reflection.options[:through]
           end
 
           def join_table
             join_table =
-              if reflection.respond_to?(:join_table)
+              if has_and_belongs_to_many_name_table_name
+                has_and_belongs_to_many_name_table_name
+              elsif reflection.respond_to?(:join_table)
                 reflection.join_table
               else
                 reflection.options[:join_table]
@@ -74,6 +80,23 @@ module Shoulda
               relation
             end
           end
+
+          def has_and_belongs_to_many_name
+            reflection.options[:through]
+          end
+
+          def has_and_belongs_to_many_name_table_name
+            if has_and_belongs_to_many_reflection
+              has_and_belongs_to_many_reflection.table_name
+            end
+          end
+
+          def has_and_belongs_to_many_reflection
+            @_has_and_belongs_to_many_reflection ||=
+              if has_and_belongs_to_many_name
+                @subject.reflect_on_association(has_and_belongs_to_many_name)
+              end
+          end
         end
       end
     end

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

@@ -5,7 +5,7 @@ module Shoulda
         # @private
         class ModelReflector
           delegate :associated_class, :through?, :join_table,
-            :association_relation, to: :reflection
+            :association_relation, :polymorphic?, to: :reflection
 
           def initialize(subject, name)
             @subject = subject

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

@@ -63,7 +63,7 @@ module Shoulda
           @options = {}
         end
 
-        def unique(unique)
+        def unique(unique = true)
           @options[:unique] = unique
           self
         end

data/lib/shoulda/matchers/active_record.rb

@@ -1,6 +1,7 @@
 require 'shoulda/matchers/active_record/association_matcher'
 require 'shoulda/matchers/active_record/association_matchers'
 require 'shoulda/matchers/active_record/association_matchers/counter_cache_matcher'
+require 'shoulda/matchers/active_record/association_matchers/inverse_of_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'

data/lib/shoulda/matchers/assertion_error.rb

@@ -9,9 +9,14 @@ module Shoulda
       # @private
       AssertionError = Test::Unit::AssertionFailedError
     elsif Gem.ruby_version >= Gem::Version.new("1.9")
-      require 'minitest/unit'
-      # @private
-      AssertionError = MiniTest::Assertion
+      begin
+        require 'minitest'
+      rescue LoadError
+        require 'minitest/unit'
+      ensure
+        # @private
+        AssertionError = MiniTest::Assertion
+      end
     else
       raise 'No unit test library available'
     end