shoulda-matchers 2.5.0 → 2.6.0

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

@@ -20,7 +20,6 @@ module Shoulda # :nodoc:
       end
 
       class ValidatePresenceOfMatcher < ValidationMatcher # :nodoc:
-
         def with_message(message)
           @expected_message = message if message
           self
@@ -30,6 +29,12 @@ module Shoulda # :nodoc:
           super(subject)
           @expected_message ||= :blank
           disallows_value_of(blank_value, @expected_message)
+        rescue Shoulda::Matchers::ActiveModel::CouldNotClearAttribute => error
+          if @attribute == :password
+            raise Shoulda::Matchers::ActiveModel::CouldNotSetPasswordError.create(subject.class)
+          else
+            raise error
+          end
         end
 
         def description

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

@@ -114,17 +114,30 @@ module Shoulda # :nodoc:
           end
 
           @subject.class.new.tap do |instance|
-            instance.send("#{@attribute}=", value)
+            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'
+            end
             instance.save(validate: false)
           end
         end
 
+        def has_secure_password?
+          @subject.class.ancestors.map(&:to_s).include?('ActiveModel::SecurePassword::InstanceMethodsOnActivation')
+        end
+
         def set_scoped_attributes
           if @options[:scopes].present?
             @options[:scopes].all? do |scope|
               setter = :"#{scope}="
               if @subject.respond_to?(setter)
-                @subject.send(setter, existing_record.send(scope))
+                @subject.__send__(setter, existing_record.__send__(scope))
                 true
               else
                 @failure_message = "#{class_name} doesn't seem to have a #{scope} attribute."
@@ -168,10 +181,10 @@ module Shoulda # :nodoc:
                   previous_value.to_s.next
                 end
 
-              @subject.send("#{scope}=", next_value)
+              @subject.__send__("#{scope}=", next_value)
 
               if allows_value_of(existing_value, @expected_message)
-                @subject.send("#{scope}=", previous_value)
+                @subject.__send__("#{scope}=", previous_value)
 
                 @failure_message_when_negated <<
                   " (with different value of #{scope})"
@@ -185,7 +198,7 @@ module Shoulda # :nodoc:
         end
 
         def correct_type_for_column(column)
-          if column.type == :string
+          if column.type == :string || column.type == :binary
             '0'
           elsif column.type == :datetime
             DateTime.now
@@ -201,12 +214,18 @@ module Shoulda # :nodoc:
         end
 
         def existing_value
-          value = existing_record.send(@attribute)
+          value = existing_record.__send__(@attribute)
           if @options[:case_insensitive] && value.respond_to?(:swapcase!)
             value.swapcase!
           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.rb

@@ -1,5 +1,6 @@
 require 'shoulda/matchers/active_record/association_matcher'
 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/active_record/association_matcher.rb

@@ -6,14 +6,17 @@ module Shoulda # :nodoc:
       # Ensure that the belongs_to relationship exists.
       #
       # Options:
-      # * <tt>:class_name</tt> - tests that the association resolves to class_name.
-      # * <tt>:validate</tt> - tests that the association makes use of the validate
+      # * <tt>class_name</tt> - tests that the association resolves to class_name.
+      # * <tt>validate</tt> - tests that the association makes use of the validate
       # option.
-      # * <tt>:touch</tt> - tests that the association makes use of the touch
+      # * <tt>touch</tt> - tests that the association makes use of the touch
       # option.
       #
       # Example:
       #   it { should belong_to(:parent) }
+      #   it { should belong_to(:parent).touch }
+      #   it { should belong_to(:parent).validate }
+      #   it { should belong_to(:parent).class_name("ModelClassName") }
       #
       def belong_to(name)
         AssociationMatcher.new(:belongs_to, name)
@@ -27,14 +30,19 @@ module Shoulda # :nodoc:
       # * <tt>through</tt> - association name for <tt>has_many :through</tt>
       # * <tt>dependent</tt> - tests that the association makes use of the
       #   dependent option.
-      # * <tt>:class_name</tt> - tests that the association resoves to class_name.
-      # * <tt>:validate</tt> - tests that the association makes use of the validate
+      # * <tt>class_name</tt> - tests that the association resoves to class_name.
+      # * <tt>autosave</tt> - tests that the association makes use of the
+      #   autosave option.
+      # * <tt>validate</tt> - tests that the association makes use of the validate
       # option.
       #
       # Example:
       #   it { should have_many(:friends) }
       #   it { should have_many(:enemies).through(:friends) }
       #   it { should have_many(:enemies).dependent(:destroy) }
+      #   it { should have_many(:friends).autosave }
+      #   it { should have_many(:friends).validate }
+      #   it { should have_many(:friends).class_name("Friend") }
       #
       def have_many(name)
         AssociationMatcher.new(:has_many, name)
@@ -45,14 +53,20 @@ module Shoulda # :nodoc:
       # associations.
       #
       # Options:
-      # * <tt>:dependent</tt> - tests that the association makes use of the
+      # * <tt>dependent</tt> - tests that the association makes use of the
       #   dependent option.
-      # * <tt>:class_name</tt> - tests that the association resolves to class_name.
-      # * <tt>:validate</tt> - tests that the association makes use of the validate
+      # * <tt>class_name</tt> - tests that the association resolves to class_name.
+      # * <tt>autosave</tt> - tests that the association makes use of the
+      #   autosave option.
+      # * <tt>validate</tt> - tests that the association makes use of the validate
       # option.
       #
       # Example:
       #   it { should have_one(:god) } # unless hindu
+      #   it { should have_one(:god).dependent }
+      #   it { should have_one(:god).autosave }
+      #   it { should have_one(:god).validate }
+      #   it { should have_one(:god).class_name("JHVH1") }
       #
       def have_one(name)
         AssociationMatcher.new(:has_one, name)
@@ -62,12 +76,14 @@ module Shoulda # :nodoc:
       # the join table is in place.
       #
       # Options:
-      # * <tt>:class_name</tt> - tests that the association resolves to class_name.
-      # * <tt>:validate</tt> - tests that the association makes use of the validate
+      # * <tt>class_name</tt> - tests that the association resolves to class_name.
+      # * <tt>validate</tt> - tests that the association makes use of the validate
       # option.
       #
       # Example:
       #   it { should have_and_belong_to_many(:posts) }
+      #   it { should have_and_belong_to_many(:posts).validate }
+      #   it { should have_and_belong_to_many(:posts).class_name("Post") }
       #
       def have_and_belong_to_many(name)
         AssociationMatcher.new(:has_and_belongs_to_many, name)
@@ -75,7 +91,7 @@ module Shoulda # :nodoc:
 
       class AssociationMatcher # :nodoc:
         delegate :reflection, :model_class, :associated_class, :through?,
-          :join_table, to: :reflector
+          :join_table, :polymorphic?, to: :reflector
 
         def initialize(macro, name)
           @macro = macro
@@ -109,6 +125,13 @@ module Shoulda # :nodoc:
           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)
@@ -120,6 +143,11 @@ module Shoulda # :nodoc:
           self
         end
 
+        def autosave(autosave)
+          @options[:autosave] = autosave
+          self
+        end
+
         def class_name(class_name)
           @options[:class_name] = class_name
           self
@@ -160,8 +188,10 @@ module Shoulda # :nodoc:
           @subject = subject
           association_exists? &&
             macro_correct? &&
+            (polymorphic? || class_exists?) &&
             foreign_key_exists? &&
             class_name_correct? &&
+            autosave_correct? &&
             conditions_correct? &&
             join_table_exists? &&
             validate_correct? &&
@@ -224,6 +254,9 @@ module Shoulda # :nodoc:
         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
@@ -257,6 +290,27 @@ module Shoulda # :nodoc:
           end
         end
 
+        def class_exists?
+          associated_class
+          true
+        rescue NameError
+          @missing = "#{reflection.class_name} does not exist"
+          false
+        end
+
+        def autosave_correct?
+          if options.key?(:autosave)
+            if option_verifier.correct_for_boolean?(:autosave, options[:autosave])
+              true
+            else
+              @missing = "#{name} should have autosave set to #{options[:autosave]}"
+              false
+            end
+          else
+            true
+          end
+        end
+
         def conditions_correct?
           if options.key?(:conditions)
             if option_verifier.correct_for_relation_clause?(:conditions, options[:conditions])
@@ -284,7 +338,7 @@ module Shoulda # :nodoc:
           if option_verifier.correct_for_boolean?(:validate, options[:validate])
             true
           else
-            @missing = "#{name} should have :validate => #{options[:validate]}"
+            @missing = "#{name} should have validate: #{options[:validate]}"
             false
           end
         end
@@ -293,7 +347,7 @@ module Shoulda # :nodoc:
           if option_verifier.correct_for_boolean?(:touch, options[:touch])
             true
           else
-            @missing = "#{name} should have :touch => #{options[:touch]}"
+            @missing = "#{name} should have touch: #{options[:touch]}"
             false
           end
         end

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

@@ -0,0 +1,40 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+      module AssociationMatchers
+        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

@@ -15,13 +15,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]
@@ -73,6 +79,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

@@ -4,7 +4,7 @@ module Shoulda # :nodoc:
       module AssociationMatchers
         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_column_matcher.rb

@@ -13,7 +13,7 @@ module Shoulda # :nodoc:
       #   it { should_not have_db_column(:admin).of_type(:boolean) }
       #   it { should have_db_column(:salary).
       #                 of_type(:decimal).
-      #                 with_options(:precision => 10, :scale => 2) }
+      #                 with_options(precision: 10, scale: 2) }
       #
       def have_db_column(column)
         HaveDbColumnMatcher.new(column)

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

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

data/lib/shoulda/matchers/assertion_error.rb

@@ -7,8 +7,13 @@ module Shoulda
       # Test::Unit has been loaded already, so we use it
       AssertionError = Test::Unit::AssertionFailedError
     elsif Gem.ruby_version >= Gem::Version.new("1.9")
-      require 'minitest/unit'
-      AssertionError = MiniTest::Assertion
+      begin
+        require 'minitest'
+      rescue LoadError
+        require 'minitest/unit'
+      ensure
+        AssertionError = MiniTest::Assertion
+      end
     else
       raise 'No unit test library available'
     end

data/lib/shoulda/matchers/error.rb

@@ -0,0 +1,24 @@
+module Shoulda
+  module Matchers
+    class Error < StandardError
+      def self.create(attributes)
+        allocate.tap do |error|
+          attributes.each do |name, value|
+            error.__send__("#{name}=", value)
+          end
+
+          error.__send__(:initialize)
+        end
+      end
+
+      def initialize(*args)
+        super
+        @message = message
+      end
+
+      def message
+        ""
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/independent.rb

@@ -0,0 +1,10 @@
+require 'shoulda/matchers/independent/delegate_matcher'
+require 'shoulda/matchers/independent/delegate_matcher/stubbed_target'
+
+module Shoulda
+  module Matchers
+    # Matchers for non-Rails-dependent code.
+    module Independent
+    end
+  end
+end