shoulda-matchers 2.8.0 → 3.0.0.rc1

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

@@ -24,24 +24,25 @@ module Shoulda
             reflection.options[:through]
           end
 
-          def join_table
-            join_table =
+          def join_table_name
+            join_table_name =
               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]
+                reflection.join_table
               end
 
-            join_table.to_s
+            join_table_name.to_s
           end
 
           def association_relation
-            if reflection.respond_to?(:scope)
-              convert_scope_to_relation(reflection.scope)
+            relation = associated_class.all
+
+            if reflection.scope
+              # Source: AR::Associations::AssociationScope#eval_scope
+              relation.instance_exec(subject, &reflection.scope)
             else
-              convert_options_to_relation(reflection.options)
+              relation
             end
           end
 
@@ -68,37 +69,7 @@ module Shoulda
 
           attr_reader :reflection, :subject
 
-          def convert_scope_to_relation(scope)
-            relation = associated_class.all
-
-            if scope
-              # Source: AR::Associations::AssociationScope#eval_scope
-              relation.instance_exec(subject, &scope)
-            else
-              relation
-            end
-          end
-
-          def convert_options_to_relation(options)
-            relation = associated_class.scoped
-            relation = extend_relation_with(relation, :where, options[:conditions])
-            relation = extend_relation_with(relation, :includes, options[:include])
-            relation = extend_relation_with(relation, :order, options[:order])
-            relation = extend_relation_with(relation, :group, options[:group])
-            relation = extend_relation_with(relation, :having, options[:having])
-            relation = extend_relation_with(relation, :limit, options[:limit])
-            relation = extend_relation_with(relation, :offset, options[:offset])
-            relation = extend_relation_with(relation, :select, options[:select])
-            relation
-          end
-
-          def extend_relation_with(relation, method_name, value)
-            if value
-              relation.__send__(method_name, value)
-            else
-              relation
-            end
-          end
+          private
 
           def has_and_belongs_to_many_name
             reflection.options[:through]

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

@@ -4,7 +4,7 @@ module Shoulda
       module AssociationMatchers
         # @private
         class ModelReflector
-          delegate :associated_class, :through?, :join_table,
+          delegate :associated_class, :through?, :join_table_name,
             :association_relation, :polymorphic?, :foreign_key,
             :association_foreign_key, to: :reflection
 

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

@@ -99,16 +99,12 @@ module Shoulda
           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)
+          model.class.send(attribute_name.to_s.pluralize)
         end
 
         def enum_defined?
-          model.class.respond_to?(enum_method)
+          model.defined_enums.include?(attribute_name.to_s)
         end
 
         def enum_values_match?

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

@@ -88,6 +88,22 @@ module Shoulda
       #
       # #### Qualifiers
       #
+      # Use `on` if your validation applies only under a certain context.
+      #
+      #     class Post < ActiveRecord::Base
+      #       validates_uniqueness_of :title, on: :create
+      #     end
+      #
+      #     # RSpec
+      #     describe Post do
+      #       it { should validate_uniqueness_of(:title).on(:create) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostTest < ActiveSupport::TestCase
+      #       should validate_uniqueness_of(:title).on(:create)
+      #     end
+      #
       # ##### with_message
       #
       # Use `with_message` if you are using a custom validation message.
@@ -241,9 +257,12 @@ module Shoulda
           @original_subject = subject
           @subject = subject.class.new
           @expected_message ||= :taken
+          @all_records = @subject.class.all
 
-          set_scoped_attributes &&
+          scopes_match? &&
+            set_scoped_attributes &&
             validate_everything_except_duplicate_nils_or_blanks? &&
+            validate_case_sensitivity? &&
             validate_after_scope_change? &&
             allows_nil? &&
             allows_blank?
@@ -253,6 +272,37 @@ module Shoulda
 
         private
 
+        def validation
+          @subject.class._validators[@attribute].detect do |validator|
+            validator.is_a?(::ActiveRecord::Validations::UniquenessValidator)
+          end
+        end
+
+        def scopes_match?
+          expected_scopes = Array.wrap(@options[:scopes])
+
+          if validation
+            actual_scopes = Array.wrap(validation.options[:scope])
+          else
+            actual_scopes = []
+          end
+
+          if expected_scopes == actual_scopes
+            true
+          else
+            @failure_message = "Expected validation to be scoped to " +
+              "#{expected_scopes}"
+
+            if actual_scopes.present?
+              @failure_message << ", but it was scoped to #{actual_scopes}."
+            else
+              @failure_message << ", but it was not scoped to anything."
+            end
+
+            false
+          end
+        end
+
         def allows_nil?
           if @options[:allow_nil]
             ensure_nil_record_in_database
@@ -353,6 +403,22 @@ module Shoulda
           disallows_value_of(existing_value, @expected_message)
         end
 
+        def validate_case_sensitivity?
+          value = existing_value
+
+          if value.respond_to?(:swapcase)
+            swapcased_value = value.swapcase
+
+            if @options[:case_insensitive]
+              disallows_value_of(swapcased_value, @expected_message)
+            else
+              allows_value_of(swapcased_value, @expected_message)
+            end
+          else
+            true
+          end
+        end
+
         def create_record_with_value
           @existing_record = create_record_in_database
         end
@@ -364,17 +430,18 @@ module Shoulda
         end
 
         def validate_after_scope_change?
-          if @options[:scopes].blank?
+          if @options[:scopes].blank? || all_scopes_are_booleans?
             true
           else
-            all_records = @subject.class.all
             @options[:scopes].all? do |scope|
-              previous_value = all_records.map(&scope).max
-
-              # Assume the scope is a foreign key if the field is nil
-              previous_value ||= correct_type_for_column(@subject.class.columns_hash[scope.to_s])
+              previous_value = @all_records.map(&scope).compact.max
 
-              next_value = next_value_for(scope, previous_value)
+              next_value =
+                if previous_value.blank?
+                  dummy_value_for(scope)
+                else
+                  next_value_for(scope, previous_value)
+                end
 
               @subject.__send__("#{scope}=", next_value)
 
@@ -392,49 +459,97 @@ module Shoulda
           end
         end
 
-        def correct_type_for_column(column)
-          if column.type == :string
-            '0'
-          elsif column.type == :datetime
+        def dummy_value_for(scope)
+          column = column_for(scope)
+
+          if column.respond_to?(:array) && column.array
+            [ dummy_scalar_value_for(column) ]
+          else
+            dummy_scalar_value_for(column)
+          end
+        end
+
+        def dummy_scalar_value_for(column)
+          case column.type
+          when :integer
+            0
+          when :date
+            Date.today
+          when :datetime
             DateTime.now
-          elsif column.type == :uuid
+          when :uuid
             SecureRandom.uuid
+          when :boolean
+            true
           else
-            0
+            'dummy value'
           end
         end
 
         def next_value_for(scope, previous_value)
-          if @subject.class.respond_to?(:defined_enums) && @subject.defined_enums[scope.to_s]
+          if previous_value.is_a?(Array)
+            [ next_scalar_value_for(scope, previous_value[0]) ]
+          else
+            next_scalar_value_for(scope, previous_value)
+          end
+        end
+
+        def next_scalar_value_for(scope, previous_value)
+          column = column_for(scope)
+
+          if column.type == :uuid
+            SecureRandom.uuid
+          elsif defined_as_enum?(scope)
             available_values = available_enum_values_for(scope, previous_value)
             available_values.keys.last
-          elsif scope.to_s =~ /_type$/ && model_class?(previous_value)
+          elsif polymorphic_type_attribute?(scope, previous_value)
             Uniqueness::TestModels.create(previous_value).to_s
           elsif previous_value.respond_to?(:next)
             previous_value.next
           elsif previous_value.respond_to?(:to_datetime)
             previous_value.to_datetime.next
+          elsif boolean_value?(previous_value)
+            !previous_value
           else
             previous_value.to_s.next
           end
         end
 
+        def all_scopes_are_booleans?
+          @options[:scopes].all? do |scope|
+            @all_records.map(&scope).all? { |s| boolean_value?(s) }
+          end
+        end
+
+        def boolean_value?(value)
+          value.in?([true, false])
+        end
+
+        def defined_as_enum?(scope)
+          @subject.class.respond_to?(:defined_enums) &&
+            @subject.defined_enums[scope.to_s]
+        end
+
+        def polymorphic_type_attribute?(scope, previous_value)
+          scope.to_s =~ /_type$/ && model_class?(previous_value)
+        end
+
         def available_enum_values_for(scope, previous_value)
           @subject.defined_enums[scope.to_s].reject do |key, _|
             key == previous_value
           end
         end
 
+        def existing_value
+          existing_record.__send__(@attribute)
+        end
+
         def class_name
           @subject.class.name
         end
 
-        def existing_value
-          value = existing_record.__send__(@attribute)
-          if @options[:case_insensitive] && value.respond_to?(:swapcase!)
-            value.swapcase!
-          end
-          value
+        def column_for(scope)
+          @subject.class.columns_hash[scope.to_s]
         end
       end
     end

data/lib/shoulda/matchers/configuration.rb

@@ -0,0 +1,20 @@
+module Shoulda
+  module Matchers
+    # @private
+    def self.configure
+      yield configuration
+    end
+
+    # @private
+    def self.configuration
+      @_configuration ||= Configuration.new
+    end
+
+    # @private
+    class Configuration
+      def integrate(&block)
+        Integrations::Configuration.apply(self, &block)
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/doublespeak.rb

@@ -13,6 +13,16 @@ module Shoulda
         def world
           @_world ||= World.new
         end
+
+        def debugging_enabled?
+          ENV['DEBUG_DOUBLESPEAK'] == '1'
+        end
+
+        def debug(&block)
+          if debugging_enabled?
+            puts block.call
+          end
+        end
       end
     end
   end
@@ -21,8 +31,8 @@ end
 require 'shoulda/matchers/doublespeak/double'
 require 'shoulda/matchers/doublespeak/double_collection'
 require 'shoulda/matchers/doublespeak/double_implementation_registry'
+require 'shoulda/matchers/doublespeak/method_call'
 require 'shoulda/matchers/doublespeak/object_double'
 require 'shoulda/matchers/doublespeak/proxy_implementation'
-require 'shoulda/matchers/doublespeak/structs'
 require 'shoulda/matchers/doublespeak/stub_implementation'
 require 'shoulda/matchers/doublespeak/world'

data/lib/shoulda/matchers/doublespeak/double.rb

@@ -5,7 +5,8 @@ module Shoulda
       class Double
         attr_reader :calls
 
-        def initialize(klass, method_name, implementation)
+        def initialize(world, klass, method_name, implementation)
+          @world = world
           @klass = klass
           @method_name = method_name
           @implementation = implementation
@@ -36,36 +37,53 @@ module Shoulda
           end
         end
 
-        def record_call(args, block)
-          calls << MethodCall.new(args, block)
+        def record_call(call)
+          calls << call
         end
 
-        def call_original_method(object, args, block)
-          if original_method
-            original_method.bind(object).call(*args, &block)
+        def call_original_method(call)
+          unbound_method = world.original_method_for(klass, call.method_name)
+
+          if unbound_method
+            unbound_method.bind(call.object).call(*call.args, &call.block)
           end
         end
 
         protected
 
-        attr_reader :klass, :method_name, :implementation, :original_method
+        attr_reader :world, :klass, :method_name, :implementation,
+          :original_method
 
         def store_original_method
-          @original_method = klass.instance_method(method_name)
+          world.store_original_method_for(klass, method_name)
         end
 
         def replace_method_with_double
-          implementation = @implementation
           double = self
+          implementation = @implementation
+          _method_name = method_name
+
+          if klass.instance_methods(false).include?(method_name)
+            klass.__send__(:remove_method, method_name)
+          end
 
           klass.__send__(:define_method, method_name) do |*args, &block|
-            implementation.call(double, self, args, block)
+            call = MethodCall.new(
+              double: double,
+              object: self,
+              method_name: _method_name,
+              args: args,
+              block: block
+            )
+            implementation.call(call)
           end
         end
 
         def restore_original_method
-          original_method = @original_method
+          original_method = world.original_method_for(klass, method_name)
+
           klass.__send__(:remove_method, method_name)
+
           klass.__send__(:define_method, method_name) do |*args, &block|
             original_method.bind(self).call(*args, &block)
           end