shoulda-matchers 3.0.1 → 3.1.0

data/spec/support/unit/model_creators.rb

@@ -0,0 +1,19 @@
+module UnitTests
+  module ModelCreators
+    class << self
+      def register(name, klass)
+        registrations[name] = klass
+      end
+
+      def retrieve(name)
+        registrations[name]
+      end
+
+      private
+
+      def registrations
+        @_registrations ||= {}
+      end
+    end
+  end
+end

data/spec/support/unit/model_creators/active_model.rb

@@ -0,0 +1,39 @@
+require_relative '../model_creators'
+require 'forwardable'
+
+module UnitTests
+  module ModelCreators
+    class ActiveModel
+      def self.call(args)
+        new(args).call
+      end
+
+      extend Forwardable
+
+      def_delegators(
+        :arguments,
+        :attribute_name,
+        :attribute_default_values_by_name,
+      )
+
+      def initialize(args)
+        @arguments = CreateModelArguments::Basic.wrap(
+          args.merge(
+            model_creation_strategy: UnitTests::ModelCreationStrategies::ActiveModel
+          )
+        )
+        @model_creator = Basic.new(arguments)
+      end
+
+      def call
+        model_creator.call
+      end
+
+      protected
+
+      attr_reader :arguments, :model_creator
+    end
+
+    register(:active_model, ActiveModel)
+  end
+end

data/spec/support/unit/model_creators/active_record.rb

@@ -0,0 +1,43 @@
+require_relative '../model_creators'
+require 'forwardable'
+
+module UnitTests
+  module ModelCreators
+    class ActiveRecord
+      def self.call(args)
+        new(args).call
+      end
+
+      extend Forwardable
+
+      def_delegators(
+        :arguments,
+        :attribute_default_values_by_name,
+        :attribute_name,
+        :customize_model,
+        :model_name,
+      )
+
+      def_delegators :model_creator, :customize_model
+
+      def initialize(args)
+        @arguments = CreateModelArguments::Basic.wrap(
+          args.merge(
+            model_creation_strategy: UnitTests::ModelCreationStrategies::ActiveRecord
+          )
+        )
+        @model_creator = Basic.new(arguments)
+      end
+
+      def call
+        model_creator.call
+      end
+
+      protected
+
+      attr_reader :arguments, :model_creator
+    end
+
+    register(:active_record, ActiveRecord)
+  end
+end

data/spec/support/unit/model_creators/active_record/has_and_belongs_to_many.rb

@@ -0,0 +1,95 @@
+require_relative '../../model_creators'
+require 'forwardable'
+
+module UnitTests
+  module ModelCreators
+    class ActiveRecord
+      class HasAndBelongsToMany
+        def self.call(args)
+          new(args).call
+        end
+
+        extend Forwardable
+
+        def_delegators(
+          :arguments,
+          :attribute_name,
+          :attribute_default_values_by_name,
+        )
+
+        def initialize(args)
+          @arguments = CreateModelArguments::HasMany.wrap(args)
+        end
+
+        def call
+          parent_child_table_creator.call
+          child_model_creator.call
+          parent_model_creator.call
+        end
+
+        protected
+
+        attr_reader :arguments
+
+        private
+
+        alias_method :association_name, :attribute_name
+        alias_method :parent_model_creator_arguments, :arguments
+
+        def parent_child_table_creator
+          @_parent_child_table_creator ||=
+            UnitTests::ActiveRecord::CreateTable.new(
+              parent_child_table_name,
+              foreign_key_for_child_model => :integer,
+              foreign_key_for_parent_model => :integer,
+              :id => false
+            )
+        end
+
+        def child_model_creator
+          @_child_model_creator ||=
+            UnitTests::ModelCreationStrategies::ActiveRecord.new(
+              child_model_name
+            )
+        end
+
+        def parent_model_creator
+          @_parent_model_creator ||= begin
+            model_creator = UnitTests::ModelCreators::ActiveRecord.new(
+              parent_model_creator_arguments
+            )
+
+            # TODO: doesn't this need to be a has_many :through?
+            model_creator.customize_model do |model|
+              model.has_many(association_name)
+            end
+
+            model_creator
+          end
+        end
+
+        def foreign_key_for_child_model
+          child_model_name.foreign_key
+        end
+
+        def foreign_key_for_parent_model
+          parent_model_name.foreign_key
+        end
+
+        def parent_child_table_name
+          "#{child_model_name.pluralize}#{parent_model_name}".tableize
+        end
+
+        def parent_model_name
+          parent_model_creator.model_name
+        end
+
+        def child_model_name
+          association_name.to_s.classify
+        end
+      end
+    end
+
+    register(:"active_record/habtm", ActiveRecord::HasAndBelongsToMany)
+  end
+end

data/spec/support/unit/model_creators/active_record/has_many.rb

@@ -0,0 +1,67 @@
+require_relative '../../model_creators'
+require 'forwardable'
+
+module UnitTests
+  module ModelCreators
+    class ActiveRecord
+      class HasMany
+        def self.call(args)
+          new(args).call
+        end
+
+        extend Forwardable
+
+        def_delegators(
+          :arguments,
+          :attribute_name,
+          :attribute_default_values_by_name,
+        )
+
+        def initialize(args)
+          @arguments = CreateModelArguments::HasMany.wrap(args)
+        end
+
+        def call
+          child_model_creator.call
+          parent_model_creator.call
+        end
+
+        protected
+
+        attr_reader :arguments
+
+        private
+
+        alias_method :association_name, :attribute_name
+        alias_method :parent_model_creator_arguments, :arguments
+
+        def child_model_creator
+          @_child_model_creator ||=
+            UnitTests::ModelCreationStrategies::ActiveRecord.new(
+              child_model_name
+            )
+        end
+
+        def parent_model_creator
+          @_parent_model_creator ||= begin
+            model_creator = UnitTests::ModelCreators::ActiveRecord.new(
+              parent_model_creator_arguments
+            )
+
+            model_creator.customize_model do |model|
+              model.has_many(association_name)
+            end
+
+            model_creator
+          end
+        end
+
+        def child_model_name
+          association_name.to_s.classify
+        end
+      end
+    end
+
+    register(:"active_record/has_many", ActiveRecord::HasMany)
+  end
+end

data/spec/support/unit/model_creators/active_record/uniqueness_matcher.rb

@@ -0,0 +1,42 @@
+require_relative '../../model_creators'
+require 'forwardable'
+
+module UnitTests
+  module ModelCreators
+    class ActiveRecord
+      class UniquenessMatcher
+        def self.call(args)
+          new(args).call
+        end
+
+        extend Forwardable
+
+        def_delegators(
+          :arguments,
+          :attribute_name,
+          :attribute_default_values_by_name,
+        )
+
+        def initialize(args)
+          @arguments = CreateModelArguments::UniquenessMatcher.wrap(args)
+          @model_creator = UnitTests::ModelCreators::ActiveRecord.new(
+            arguments
+          )
+        end
+
+        def call
+          model_creator.call
+        end
+
+        protected
+
+        attr_reader :arguments, :model_creator
+      end
+    end
+
+    register(
+      :"active_record/uniqueness_matcher",
+      ActiveRecord::UniquenessMatcher
+    )
+  end
+end

data/spec/support/unit/model_creators/basic.rb

@@ -0,0 +1,97 @@
+require 'forwardable'
+
+module UnitTests
+  module ModelCreators
+    class Basic
+      def self.call(args)
+        new(args).call
+      end
+
+      extend Forwardable
+
+      def_delegators :arguments, :attribute_name, :model_name
+      def_delegators :model_creator, :customize_model
+
+      def initialize(arguments)
+        @arguments = arguments
+        @model_creator = build_model_creator
+      end
+
+      def call
+        model_creator.call
+      end
+
+      protected
+
+      attr_reader :arguments, :model_creator
+
+      private
+
+      def_delegators(
+        :arguments,
+        :additional_model_creation_strategy_args,
+        :all_attribute_overrides,
+        :columns,
+        :custom_validation?,
+        :model_creation_strategy,
+        :validation_name,
+        :validation_options,
+        :column_type,
+      )
+
+      def build_model_creator
+        model_creator = model_creation_strategy.new(
+          model_name,
+          columns,
+          arguments
+        )
+
+        model_creator.customize_model do |model|
+          add_validation_to(model)
+          possibly_override_attribute_writer_method_for(model)
+        end
+
+        model_creator
+      end
+
+      def add_validation_to(model)
+        if custom_validation?
+          _attribute_name = attribute_name
+
+          model.send(:define_method, :custom_validation) do
+            custom_validation.call(self, _attribute_name)
+          end
+
+          model.validate(:custom_validation)
+        else
+          model.public_send(validation_name, attribute_name, validation_options)
+        end
+      end
+
+      def possibly_override_attribute_writer_method_for(model)
+        all_attribute_overrides.each do |attribute_name, overrides|
+          if overrides.key?(:changing_values_with)
+            _change_value = method(:change_value)
+
+            model.send(:define_method, "#{attribute_name}=") do |value|
+              new_value = _change_value.call(
+                value,
+                overrides[:changing_values_with]
+              )
+
+              if respond_to?(:write_attribute)
+                write_attribute(new_value)
+              else
+                super(new_value)
+              end
+            end
+          end
+        end
+      end
+
+      def change_value(value, value_changer)
+        UnitTests::ChangeValue.call(column_type, value, value_changer)
+      end
+    end
+  end
+end

data/spec/support/unit/rails_application.rb

@@ -78,7 +78,7 @@ module UnitTests
     end
 
     def rails_new
-      run_command! %W(rails new #{fs.project_directory} --skip-bundle)
+      run_command! %W(rails new #{fs.project_directory} --skip-bundle --no-rc)
     end
 
     def fix_available_locales_warning

data/spec/support/unit/record_validating_confirmation_builder.rb

@@ -25,9 +25,8 @@ module UnitTests
     end
 
     def attribute_to_confirm
-      :attribute_to_confirm
+      options.fetch(:attribute, :attribute_to_confirm)
     end
-    alias_method :attribute, :attribute_to_confirm
 
     def confirmation_attribute
       :"#{attribute_to_confirm}_confirmation"
@@ -44,11 +43,8 @@ module UnitTests
     private
 
     def create_model
-      _attribute = attribute_to_confirm
-      _options = options
-
-      define_model(model_name, _attribute => :string) do
-        validates_confirmation_of(_attribute, _options)
+      define_model(model_name, attribute_to_confirm => :string) do |model|
+        model.validates_confirmation_of(attribute_to_confirm, options)
       end
     end
   end

data/spec/support/unit/shared_examples/ignoring_interference_by_writer.rb

@@ -0,0 +1,79 @@
+shared_examples_for 'ignoring_interference_by_writer' do |common_config|
+  valid_tests = [
+    :accept_if_qualified_but_changing_value_does_not_interfere,
+    :reject_if_qualified_but_changing_value_interferes
+  ]
+  tests = common_config.fetch(:tests)
+  tests.assert_valid_keys(valid_tests)
+
+  define_method(:common_config) { common_config }
+
+  context 'when the writer method for the attribute changes incoming values' do
+    context 'and the value change does not cause a test failure' do
+      config_for_test = tests[:accept_if_qualified_but_changing_value_does_not_interfere]
+
+      if config_for_test
+        it 'accepts (and does not raise an error)' do
+          args = build_args(config_for_test)
+          scenario = build_scenario_for_validation_matcher(args)
+          matcher = matcher_from(scenario)
+
+          expect(scenario.record).to matcher
+        end
+      end
+    end
+
+    context 'and the value change causes a test failure' do
+      config_for_test = tests[:reject_if_qualified_but_changing_value_interferes]
+
+      if config_for_test
+        it 'lists how the value got changed in the failure message' do
+          args = build_args(config_for_test)
+          scenario = build_scenario_for_validation_matcher(args)
+          matcher = matcher_from(scenario)
+
+          assertion = lambda do
+            expect(scenario.record).to matcher
+          end
+
+          if config_for_test.key?(:expected_message_includes)
+            message = config_for_test[:expected_message_includes]
+            expect(&assertion).to fail_with_message_including(message)
+          else
+            message = config_for_test.fetch(:expected_message)
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
+      end
+    end
+  end
+
+  def build_args(config_for_test)
+    args_from_common_config.merge(args_from_config_for_test(config_for_test))
+  end
+
+  def args_from_common_config
+    common_config.slice(
+      :column_type,
+      :model_creator,
+    )
+  end
+
+  def args_from_config_for_test(config)
+    config.slice(
+      :attribute_name,
+      :attribute_overrides,
+      :changing_values_with,
+      :default_value,
+      :model_name,
+    )
+  end
+
+  def matcher_from(scenario)
+    scenario.matcher.tap do |matcher|
+      if respond_to?(:configure_validation_matcher)
+        configure_validation_matcher(matcher)
+      end
+    end
+  end
+end