shoulda-matchers 2.6.2 → 2.7.0

data/lib/shoulda/matchers/active_record.rb

@@ -1,19 +1,21 @@
-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'
-require 'shoulda/matchers/active_record/association_matchers/source_matcher'
-require 'shoulda/matchers/active_record/association_matchers/model_reflector'
-require 'shoulda/matchers/active_record/association_matchers/model_reflection'
-require 'shoulda/matchers/active_record/association_matchers/option_verifier'
-require 'shoulda/matchers/active_record/have_db_column_matcher'
-require 'shoulda/matchers/active_record/have_db_index_matcher'
-require 'shoulda/matchers/active_record/have_readonly_attribute_matcher'
-require 'shoulda/matchers/active_record/serialize_matcher'
-require 'shoulda/matchers/active_record/accept_nested_attributes_for_matcher'
+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/join_table_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"
+require "shoulda/matchers/active_record/association_matchers/source_matcher"
+require "shoulda/matchers/active_record/association_matchers/model_reflector"
+require "shoulda/matchers/active_record/association_matchers/model_reflection"
+require "shoulda/matchers/active_record/association_matchers/option_verifier"
+require "shoulda/matchers/active_record/have_db_column_matcher"
+require "shoulda/matchers/active_record/have_db_index_matcher"
+require "shoulda/matchers/active_record/have_readonly_attribute_matcher"
+require "shoulda/matchers/active_record/serialize_matcher"
+require "shoulda/matchers/active_record/accept_nested_attributes_for_matcher"
+require "shoulda/matchers/active_record/define_enum_for_matcher"
 
 module Shoulda
   module Matchers

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

@@ -5,7 +5,7 @@ module Shoulda
       # `accepts_nested_attributes_for` macro.
       #
       #     class Car < ActiveRecord::Base
-      #       accept_nested_attributes_for :doors
+      #       accepts_nested_attributes_for :doors
       #     end
       #
       #     # RSpec
@@ -26,7 +26,7 @@ module Shoulda
       # specified.
       #
       #     class Car < ActiveRecord::Base
-      #       accept_nested_attributes_for :mirrors, allow_destroy: true
+      #       accepts_nested_attributes_for :mirrors, allow_destroy: true
       #     end
       #
       #     # RSpec
@@ -48,7 +48,7 @@ module Shoulda
       # Use `limit` to assert that the `:limit` option was specified.
       #
       #     class Car < ActiveRecord::Base
-      #       accept_nested_attributes_for :windows, limit: 3
+      #       accepts_nested_attributes_for :windows, limit: 3
       #     end
       #
       #     # RSpec
@@ -71,7 +71,7 @@ module Shoulda
       # specified.
       #
       #     class Car < ActiveRecord::Base
-      #       accept_nested_attributes_for :engine, update_only: true
+      #       accepts_nested_attributes_for :engine, update_only: true
       #     end
       #
       #     # RSpec

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

@@ -847,9 +847,9 @@ module Shoulda
             (polymorphic? || class_exists?) &&
             foreign_key_exists? &&
             class_name_correct? &&
+            join_table_correct? &&
             autosave_correct? &&
             conditions_correct? &&
-            join_table_exists? &&
             validate_correct? &&
             touch_correct? &&
             submatchers_match?
@@ -889,7 +889,8 @@ module Shoulda
         end
 
         def missing_options
-          [missing, failing_submatchers.map(&:missing_option)].flatten.join
+          missing_options = [missing, failing_submatchers.map(&:missing_option)]
+          missing_options.flatten.compact.join(', ')
         end
 
         def failing_submatchers
@@ -946,6 +947,20 @@ module Shoulda
           end
         end
 
+        def join_table_correct?
+          if macro != :has_and_belongs_to_many || join_table_matcher.matches?(@subject)
+            true
+          else
+            @missing = join_table_matcher.failure_message
+            false
+          end
+        end
+
+        def join_table_matcher
+          @join_table_matcher ||=
+            AssociationMatchers::JoinTableMatcher.new(self, reflector)
+        end
+
         def class_exists?
           associated_class
           true
@@ -980,16 +995,6 @@ module Shoulda
           end
         end
 
-        def join_table_exists?
-          if macro != :has_and_belongs_to_many ||
-              model_class.connection.tables.include?(join_table)
-            true
-          else
-            @missing = "join table #{join_table} doesn't exist"
-            false
-          end
-        end
-
         def validate_correct?
           if option_verifier.correct_for_boolean?(:validate, options[:validate])
             true

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

@@ -0,0 +1,86 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class JoinTableMatcher
+          attr_reader :failure_message
+
+          alias :missing_option :failure_message
+
+          delegate :model_class, :join_table, :associated_class,
+            to: :association_matcher
+
+          delegate :connection, to: :model_class
+
+          def initialize(association_matcher, reflector)
+            @association_matcher = association_matcher
+            @reflector = reflector
+          end
+
+          def matches?(subject)
+            join_table_exists? &&
+              join_table_has_correct_columns?
+          end
+
+          def join_table_exists?
+            if connection.tables.include?(join_table)
+              true
+            else
+              @failure_message = missing_table_message
+              false
+            end
+          end
+
+          def join_table_has_correct_columns?
+            if missing_columns.empty?
+              true
+            else
+              @failure_message = missing_columns_message
+              false
+            end
+          end
+
+          protected
+
+          attr_reader :association_matcher, :reflector
+
+          private
+
+          delegate :foreign_key, :association_foreign_key, to: :reflector
+
+          def missing_columns
+            @missing_columns ||= expected_join_table_columns.select do |key|
+              !actual_join_table_columns.include?(key)
+            end
+          end
+
+          def expected_join_table_columns
+            [foreign_key, association_foreign_key]
+          end
+
+          def actual_join_table_columns
+            connection.columns(join_table).map(&:name)
+          end
+
+          def missing_table_message
+            "join table #{join_table} doesn't exist"
+          end
+
+          def missing_columns_message
+            missing = missing_columns.join(', ')
+            "join table #{join_table} missing #{column_label}: #{missing}"
+          end
+
+          def column_label
+            if missing_columns.count > 1
+              'columns'
+            else
+              'column'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -45,6 +45,25 @@ module Shoulda
             end
           end
 
+          def foreign_key
+            if has_and_belongs_to_many_reflection
+              has_and_belongs_to_many_reflection.foreign_key
+            elsif reflection.respond_to?(:primary_key_name)
+              reflection.primary_key_name
+            else
+              reflection.foreign_key
+            end
+          end
+
+          def association_foreign_key
+            if has_and_belongs_to_many_reflection
+              join_model = has_and_belongs_to_many_reflection.options[:class]
+              join_model.right_reflection.foreign_key
+            else
+              reflection.association_foreign_key
+            end
+          end
+
           protected
 
           attr_reader :reflection, :subject

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

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

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

@@ -0,0 +1,138 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `define_enum_for` matcher is used to test that the `enum` macro has
+      # been used to decorate an attribute with enum methods.
+      #
+      #     class Process < ActiveRecord::Base
+      #       enum status: [:running, :stopped, :suspended]
+      #     end
+      #
+      #     # RSpec
+      #     describe Process do
+      #       it { should define_enum_for(:status) }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### with
+      #
+      # Use `with` to test that the enum has been defined with a certain set of
+      # known values.
+      #
+      #     class Process < ActiveRecord::Base
+      #       enum status: [:running, :stopped, :suspended]
+      #     end
+      #
+      #     # RSpec
+      #     describe Process do
+      #       it do
+      #         should define_enum_for(:status).
+      #           with([:running, :stopped, :suspended])
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         with([:running, :stopped, :suspended])
+      #     end
+      #
+      # @return [DefineEnumForMatcher]
+      #
+      def define_enum_for(attribute_name)
+        DefineEnumForMatcher.new(attribute_name)
+      end
+
+      # @private
+      class DefineEnumForMatcher
+        def initialize(attribute_name)
+          @attribute_name = attribute_name
+          @options = {}
+        end
+
+        def with(expected_enum_values)
+          options[:expected_enum_values] = expected_enum_values
+          self
+        end
+
+        def matches?(subject)
+          @model = subject
+          enum_defined? && enum_values_match?
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+        alias :failure_message_for_should :failure_message
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}"
+        end
+        alias :failure_message_for_should_not :failure_message_when_negated
+
+        def description
+          desc = "define :#{attribute_name} as an enum"
+
+          if options[:expected_enum_values]
+            desc << " with #{options[:expected_enum_values]}"
+          end
+
+          desc
+        end
+
+        protected
+
+        attr_reader :model, :attribute_name, :options
+
+        def expectation
+          "#{model.class.name} to #{description}"
+        end
+
+        def expected_enum_values
+          hashify(options[:expected_enum_values]).with_indifferent_access
+        end
+
+        def enum_method
+          attribute_name.to_s.pluralize
+        end
+
+        def actual_enum_values
+          model.class.send(enum_method)
+        end
+
+        def enum_defined?
+          model.class.respond_to?(enum_method)
+        end
+
+        def enum_values_match?
+          expected_enum_values.empty? || actual_enum_values == expected_enum_values
+        end
+
+        def hashify(value)
+          if value.nil?
+            return {}
+          end
+
+          if value.is_a?(Array)
+            new_value = {}
+
+            value.each_with_index do |v, i|
+              new_value[v] = i
+            end
+
+            new_value
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/independent.rb

@@ -1,5 +1,6 @@
-require 'shoulda/matchers/independent/delegate_matcher'
-require 'shoulda/matchers/independent/delegate_matcher/stubbed_target'
+require 'shoulda/matchers/independent/delegate_method_matcher'
+require 'shoulda/matchers/independent/delegate_method_matcher/stubbed_target'
+require 'shoulda/matchers/independent/delegate_method_matcher/target_not_defined_error'
 
 module Shoulda
   module Matchers

data/lib/shoulda/matchers/independent/{delegate_matcher.rb → delegate_method_matcher.rb}

@@ -70,10 +70,12 @@ module Shoulda
       # ##### with_arguments
       #
       # Use `with_arguments` to assert that the delegate method is called with
-      # certain arguments.
+      # certain arguments. Note that this qualifier can only be used when the
+      # delegating method takes no arguments; it does not support delegating
+      # or delegate methods that take arbitrary arguments.
       #
-      # Here, when Courier#deliver calls PostOffice#ship, it adds an options
-      # hash:
+      # Here, when Courier#deliver_package calls PostOffice#deliver_package, it
+      # adds an options hash:
       #
       #     class Courier
       #       attr_reader :post_office
@@ -82,39 +84,39 @@ module Shoulda
       #         @post_office = PostOffice.new
       #       end
       #
-      #       def deliver(package)
-      #         post_office.ship(package, expedited: true)
+      #       def deliver_package
+      #         post_office.deliver_package(expedited: true)
       #       end
       #     end
       #
       #     # RSpec
       #     describe Courier do
       #       it do
-      #         should delegate_method(:deliver).
+      #         should delegate_method(:deliver_package).
       #           to(:post_office).
-      #           as(:ship).
       #           with_arguments(expedited: true)
       #       end
       #     end
       #
       #     # Test::Unit
       #     class CourierTest < Test::Unit::TestCase
-      #       should delegate_method(:deliver).
+      #       should delegate_method(:deliver_package).
       #         to(:post_office).
-      #         as(:ship).
       #         with_arguments(expedited: true)
       #     end
       #
-      # @return [DelegateMatcher]
+      # @return [DelegateMethodMatcher]
       #
       def delegate_method(delegating_method)
-        DelegateMatcher.new(delegating_method)
+        DelegateMethodMatcher.new(delegating_method, self)
       end
 
       # @private
-      class DelegateMatcher
-        def initialize(delegating_method)
+      class DelegateMethodMatcher
+        def initialize(delegating_method, context)
           @delegating_method = delegating_method
+          @context = context
+
           @method_on_target = @delegating_method
           @target_double = Doublespeak::ObjectDouble.new
 
@@ -135,9 +137,18 @@ module Shoulda
         end
 
         def description
-          add_clarifications_to(
-            "delegate method ##{delegating_method} to :#{target_method}"
-          )
+          string = "delegate #{formatted_delegating_method_name} to " +
+            "#{formatted_target_method_name} object"
+
+          if delegated_arguments.any?
+            string << " passing arguments #{delegated_arguments.inspect}"
+          end
+
+          if method_on_target != delegating_method
+            string << " as #{formatted_method_on_target}"
+          end
+
+          string
         end
 
         def to(target_method)
@@ -156,58 +167,73 @@ module Shoulda
         end
 
         def failure_message
-          base = "Expected #{formatted_delegating_method_name} to delegate to #{formatted_target_method_name}"
-          add_clarifications_to(base)
-          base << "\nCalls on #{formatted_target_method_name}:"
-          base << formatted_calls_on_target
-          base.strip
+          "Expected #{class_under_test} to #{description}\n" +
+            "Method calls sent to " +
+            "#{formatted_target_method_name(include_module: true)}:" +
+            formatted_calls_on_target
         end
         alias failure_message_for_should failure_message
 
         def failure_message_when_negated
-          base = "Expected #{formatted_delegating_method_name} not to delegate to #{formatted_target_method_name}"
-          add_clarifications_to(base)
-          base << ', but it did'
+          "Expected #{class_under_test} not to #{description}, but it did"
         end
         alias failure_message_for_should_not failure_message_when_negated
 
         protected
 
         attr_reader \
+          :context,
           :delegated_arguments,
           :delegating_method,
           :method,
           :method_on_target,
-          :subject,
           :subject_double_collection,
           :target_double,
           :target_method
 
-        def add_clarifications_to(message)
-          if delegated_arguments.any?
-            message << " with arguments: #{delegated_arguments.inspect}"
-          end
+        def subject
+          @subject || context.subject
+        end
 
-          if method_on_target != delegating_method
-            message << " as ##{method_on_target}"
+        def class_under_test
+          if subject.is_a?(Class)
+            subject
+          else
+            subject.class
           end
+        end
 
-          message
+        def formatted_method_on_target(options = {})
+          formatted_method_name_for(method_on_target, options)
         end
 
-        def formatted_delegating_method_name
-          formatted_method_name_for(delegating_method)
+        def formatted_delegating_method_name(options = {})
+          formatted_method_name_for(delegating_method, options)
         end
 
-        def formatted_target_method_name
-          formatted_method_name_for(target_method)
+        def formatted_target_method_name(options = {})
+          formatted_method_name_for(target_method, options)
         end
 
-        def formatted_method_name_for(method_name)
+        def formatted_method_name_for(method_name, options)
+          possible_class_under_test(options) +
+            class_or_instance_method_indicator +
+            method_name.to_s
+        end
+
+        def possible_class_under_test(options)
+          if options[:include_module]
+            class_under_test.to_s
+          else
+            ""
+          end
+        end
+
+        def class_or_instance_method_indicator
           if subject.is_a?(Class)
-            subject.name + '.' + method_name.to_s
+            '.'
           else
-            subject.class.name + '#' + method_name.to_s
+            '#'
           end
         end
 
@@ -226,11 +252,11 @@ module Shoulda
         end
 
         def subject_has_target_method?
-          subject.respond_to?(target_method)
+          subject.respond_to?(target_method, true)
         end
 
         def ensure_target_method_is_present!
-          if target_method.blank?
+          if target_method.to_s.empty?
             raise TargetNotDefinedError
           end
         end
@@ -280,15 +306,9 @@ module Shoulda
             string << " (none)"
           end
 
-          string
-        end
+          string.rstrip!
 
-        # @private
-        class TargetNotDefinedError < StandardError
-          def message
-            'Delegation needs a target. Use the #to method to define one, e.g.
-            `post_office.should delegate(:deliver_mail).to(:mailman)`'.squish
-          end
+          string
         end
       end
     end