shoulda-matchers 4.0.0.rc1 → 4.0.1

data/spec/support/unit/record_builder_with_i18n_validation_message.rb

@@ -1,69 +0,0 @@
-require 'delegate'
-
-module UnitTests
-  class RecordBuilderWithI18nValidationMessage < SimpleDelegator
-    def initialize(builder, options = {})
-      super(builder)
-      @options = default_options.merge(options)
-      builder.message = validation_message_key
-    end
-
-    def validation_message_key
-      options[:validation_message_key]
-    end
-
-    protected
-
-    attr_reader :builder, :options
-
-    private
-
-    def model
-      @_model ||= super.tap do |model|
-        stub_validation_messages
-      end
-    end
-
-    def stub_validation_messages
-      stub_default_validation_message
-      stub_attribute_specific_validation_message
-    end
-
-    def stub_default_validation_message
-      keys = [
-        'activerecord.errors.messages',
-        validation_message_key
-      ]
-
-      I18nFaker.stub_translation(keys, default_message)
-    end
-
-    def stub_attribute_specific_validation_message
-      keys = [
-        'activerecord.errors',
-        "models.#{builder.model_name.to_s.underscore}",
-        "attributes.#{builder.attribute_that_receives_error}",
-        validation_message_key
-      ]
-
-      I18nFaker.stub_translation(
-        keys,
-        message_for_attribute_that_receives_error
-      )
-    end
-
-    def default_message
-      'the wrong message'
-    end
-
-    def message_for_attribute_that_receives_error
-      'the right message'
-    end
-
-    def default_options
-      {
-        validation_message_key: :validation_message_key
-      }
-    end
-  end
-end

data/spec/support/unit/record_validating_confirmation_builder.rb

@@ -1,54 +0,0 @@
-require_relative 'helpers/model_builder'
-
-module UnitTests
-  class RecordValidatingConfirmationBuilder
-    include ModelBuilder
-
-    def initialize(options)
-      @options = options
-    end
-
-    def model
-      @_model ||= create_model
-    end
-
-    def model_name
-      options.fetch(:model_name, 'Example')
-    end
-
-    def record
-      model.new
-    end
-
-    def message=(message)
-      options[:message] = message
-    end
-
-    def attribute_to_confirm
-      options.fetch(:attribute, :attribute_to_confirm)
-    end
-
-    def confirmation_attribute
-      options.fetch(
-        :confirmation_attribute,
-        :"#{attribute_to_confirm}_confirmation"
-      )
-    end
-
-    def attribute_that_receives_error
-      confirmation_attribute
-    end
-
-    protected
-
-    attr_reader :options
-
-    private
-
-    def create_model
-      define_model(model_name, attribute_to_confirm => :string) do |model|
-        model.validates_confirmation_of(attribute_to_confirm, options)
-      end
-    end
-  end
-end

data/spec/support/unit/record_with_different_error_attribute_builder.rb

@@ -1,92 +0,0 @@
-require_relative 'helpers/model_builder'
-
-module UnitTests
-  class RecordWithDifferentErrorAttributeBuilder
-    include ModelBuilder
-
-    def initialize(options)
-      @options = options.reverse_merge(default_options)
-    end
-
-    def attribute_that_receives_error
-      options[:attribute_that_receives_error]
-    end
-
-    def attribute_to_validate
-      options[:attribute_to_validate]
-    end
-
-    def message
-      options[:message]
-    end
-
-    def message=(message)
-      options[:message] = message
-    end
-
-    def model
-      @_model ||= create_model
-    end
-
-    def model_name
-      'Example'
-    end
-
-    def record
-      model.new
-    end
-
-    def valid_value
-      'some value'
-    end
-
-    protected
-
-    attr_reader :options
-
-    private
-
-    def context
-      {
-        validation_method_name: validation_method_name,
-        valid_value: valid_value,
-        attribute_to_validate: attribute_to_validate,
-        attribute_that_receives_error: attribute_that_receives_error,
-        message: message
-      }
-    end
-
-    def create_model
-      _context = context
-
-      define_model model_name, model_columns do
-        validate _context[:validation_method_name]
-
-        define_method(_context[:validation_method_name]) do
-          if self[_context[:attribute_to_validate]] != _context[:valid_value]
-            self.errors.add(_context[:attribute_that_receives_error], _context[:message])
-          end
-        end
-      end
-    end
-
-    def validation_method_name
-      :custom_validation
-    end
-
-    def model_columns
-      {
-        attribute_to_validate => :string,
-        attribute_that_receives_error => :string
-      }
-    end
-
-    def default_options
-      {
-        attribute_that_receives_error: :attribute_that_receives_error,
-        attribute_to_validate: :attribute_to_validate,
-        message: 'some message'
-      }
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-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

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

@@ -1,17 +0,0 @@
-shared_examples 'a numerical submatcher' do
-  it 'implements the with_message method' do
-    expect(subject).to respond_to(:with_message).with(1).arguments
-  end
-
-  it 'implements the matches? method' do
-    expect(subject).to respond_to(:matches?).with(1).arguments
-  end
-
-  it 'implements the failure_message method' do
-    expect(subject).to respond_to(:failure_message).with(0).arguments
-  end
-
-  it 'implements the failure_message_when_negated method' do
-    expect(subject).to respond_to(:failure_message_when_negated).with(0).arguments
-  end
-end

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

@@ -1,360 +0,0 @@
-shared_examples_for 'set session or flash matcher' do
-  context 'without any qualifiers' do
-    it 'produces the right description' do
-      expected_description = "should set any key in #{store_name}"
-      matcher = set_store
-
-      expect(matcher.description).to eq expected_description
-    end
-
-    context 'in the positive' do
-      context 'if the store is not empty' do
-        it 'accepts' do
-          controller = controller_with_store('any key' => 'any value')
-          expect(controller).to set_store
-        end
-      end
-
-      context 'if the store is empty' do
-        it 'rejects' do
-          controller = controller_with_empty_store
-          expect(controller).not_to set_store
-        end
-
-        it 'produces the correct failure message' do
-          controller = controller_with_empty_store
-          expected_message = %<Expected #{controller.class} to set any key in #{store_name}, but it did not>
-
-          expect { expect(controller).to set_store }.
-            to fail_with_message(expected_message)
-        end
-      end
-    end
-
-    context 'in the negative' do
-      context 'if the given key is present in the store' do
-        it 'produces the correct failure message' do
-          controller = controller_with_store('any key' => 'any value')
-          expected_message = %<Expected #{controller.class} not to set any key in #{store_name}, but it did>
-          assertion = proc do
-            expect(controller).not_to set_store
-          end
-
-          expect(&assertion).to fail_with_message(expected_message)
-        end
-      end
-    end
-  end
-
-  context 'with #[]' do
-    it 'produces the right description' do
-      matcher = set_store['the key']
-      expected_description = %<should set #{store_name}["the key"]>
-
-      expect(matcher.description).to eq expected_description
-    end
-
-    context 'in the positive' do
-      context 'if the given key is present in the store' do
-        it 'accepts the param as a string' do
-          controller = controller_with_store('the_key' => 'any value')
-          expect(controller).to set_store['the_key']
-        end
-
-        it 'accepts the param as a symbol' do
-          controller = controller_with_store('the_key' => 'any value')
-          expect(controller).to set_store[:the_key]
-        end
-      end
-
-      context 'if the given key is not present in the store' do
-        it 'rejects' do
-          controller = controller_with_empty_store
-          expect(controller).not_to set_store['the key']
-        end
-
-        it 'produces the correct failure message' do
-          controller = controller_with_empty_store
-          expected_message = %<Expected #{controller.class} to set #{store_name}["the key"], but it did not>
-          assertion = proc do
-            expect(controller).to set_store['the key']
-          end
-
-          expect(&assertion).to fail_with_message(expected_message)
-        end
-      end
-    end
-
-    context 'in the negative' do
-      context 'if the given key is present in the store' do
-        it 'produces the correct failure message' do
-          controller = controller_with_store('the key' => 'any value')
-          expected_message = %<Expected #{controller.class} not to set #{store_name}["the key"], but it did>
-          assertion = proc do
-            expect(controller).not_to set_store['the key']
-          end
-
-          expect(&assertion).to fail_with_message(expected_message)
-        end
-      end
-    end
-  end
-
-  context 'with #to' do
-    context 'given a static value' do
-      it 'produces the right description' do
-        matcher = set_store.to('the value')
-        expected_description = %<should set any key in #{store_name} to "the value">
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      context 'in the positive' do
-        context 'if the given value is present in the store' do
-          it 'accepts' do
-            controller = controller_with_store('any key' => 'the value')
-            expect(controller).to set_store.to('the value')
-          end
-
-          it 'accepts given a value of nil' do
-            controller = controller_with_store('any key' => nil)
-            expect(controller).to set_store.to(nil)
-          end
-
-          it 'accepts given a value of false' do
-            controller = controller_with_store('any key' => false)
-            expect(controller).to set_store.to(false)
-          end
-        end
-
-        context 'if the given value is not present in the store' do
-          it 'rejects' do
-            controller = controller_with_empty_store
-            expect(controller).not_to set_store.to('the value')
-          end
-
-          it 'rejects checking for nil' do
-            controller = controller_with_empty_store
-            expect(controller).not_to set_store.to(nil)
-          end
-
-          it 'produces the correct failure message' do
-            controller = controller_with_empty_store
-            expected_message = %<Expected #{controller.class} to set any key in #{store_name} to "the value", but it did not>
-            assertion = proc do
-              expect(controller).to set_store.to('the value')
-            end
-
-            expect(&assertion).to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the given value is present in the store' do
-          it 'produces the correct failure message' do
-            controller = controller_with_store('any key' => 'the value')
-            expected_message = %<Expected #{controller.class} not to set any key in #{store_name} to "the value", but it did>
-            assertion = proc do
-              expect(controller).not_to set_store.to('the value')
-            end
-
-            expect(&assertion).to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-
-    context 'given a regexp' do
-      it 'produces the right description' do
-        matcher = set_store.to(/value/)
-        expected_description = %<should set any key in #{store_name} to a value matching /value/>
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      context 'in the positive' do
-        context 'if the given value is present in the store' do
-          it 'accepts' do
-            controller = controller_with_store('any key' => 'the value')
-            expect(controller).to set_store.to(/value/)
-          end
-
-          it 'accepts given a value of nil' do
-            controller = controller_with_store('any key' => nil)
-            expect(controller).to set_store.to(nil)
-          end
-
-          it 'accepts given a value of false' do
-            controller = controller_with_store('any key' => false)
-            expect(controller).to set_store.to(false)
-          end
-        end
-
-        context 'if the given value is not present in the store' do
-          it 'rejects' do
-            controller = controller_with_empty_store
-            expect(controller).not_to set_store.to(/value/)
-          end
-
-          it 'produces the correct failure message' do
-            controller = controller_with_empty_store
-            expected_message = %<Expected #{controller.class} to set any key in #{store_name} to a value matching /value/, but it did not>
-            assertion = proc do
-              expect(controller).to set_store.to(/value/)
-            end
-
-            expect(&assertion).to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the given value is present in the store' do
-          it 'produces the correct failure message' do
-            controller = controller_with_store('any key' => 'the value')
-            expected_message = %<Expected #{controller.class} not to set any key in #{store_name} to a value matching /value/, but it did>
-            assertion = proc do
-              expect(controller).not_to set_store.to(/value/)
-            end
-
-            expect(&assertion).to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-  end
-
-  context 'with #[] + #to' do
-    context 'given a static value' do
-      it 'produces the right description' do
-        expected_description = %<should set #{store_name}["the key"] to "the value">
-        matcher = set_store['the key'].to('the value')
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      context 'in the positive' do
-        context 'if the given value is present in the store' do
-          it 'accepts' do
-            controller = controller_with_store('the key' => 'the value')
-            expect(controller).to set_store['the key'].to('the value')
-          end
-        end
-
-        context 'if the given value is not present in the store' do
-          it 'rejects' do
-            controller = controller_with_empty_store
-            expect(controller).not_to set_store['the key'].to('the value')
-          end
-
-          it 'produces the correct failure message' do
-            controller = controller_with_empty_store
-            expected_message = %<Expected #{controller.class} to set #{store_name}["the key"] to "the value", but it did not>
-            assertion = proc do
-              expect(controller).to set_store['the key'].to('the value')
-            end
-
-            expect(&assertion).to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the given value is present in the store' do
-          it 'produces the correct failure message' do
-            controller = controller_with_store('the key' => 'the value')
-            expected_message = %<Expected #{controller.class} not to set #{store_name}["the key"] to "the value", but it did>
-            assertion = proc do
-              expect(controller).not_to set_store['the key'].to('the value')
-            end
-
-            expect(&assertion).to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-
-    context 'given a dynamic value' do
-      it 'produces the right description' do
-        context = double('context', method_in_context: 'the value')
-        matcher = set_store['the key'].
-          in_context(context).
-          to { method_in_context }
-        expected_description = %<should set #{store_name}["the key"] to "the value">
-
-        expect(matcher.description).to eq expected_description
-      end
-
-      context 'in the positive' do
-        context 'if the value evaluated in the context is present in the store' do
-          it 'accepts' do
-            controller = controller_with_store('the key' => 'the value')
-            context = double('context', method_in_context: 'the value')
-
-            expect(controller).to set_store['the key'].
-              in_context(context).
-              to { method_in_context }
-          end
-        end
-
-        context 'if the value evaluated in the context is not present in the store' do
-          it 'rejects' do
-            controller = controller_with_empty_store
-            context = double('context', method_in_context: 'the value')
-
-            expect(controller).not_to set_store['the key'].
-              in_context(context).
-              to { method_in_context }
-          end
-
-          it 'produces the correct failure message' do
-            controller = controller_with_empty_store
-            context = double('context', method_in_context: 'the value')
-            expected_message = %<Expected #{controller.class} to set #{store_name}["the key"] to "the value", but it did not>
-            assertion = proc do
-              expect(controller).to set_store['the key'].
-                in_context(context).
-                to { method_in_context }
-            end
-
-            expect(&assertion).to fail_with_message(expected_message)
-          end
-        end
-      end
-
-      context 'in the negative' do
-        context 'if the value evaluated in the context is present in the store' do
-          it 'produces the correct failure message' do
-            context = double('context', method_in_context: 'the value')
-            controller = controller_with_store('the key' => 'the value')
-            expected_message = %<Expected #{controller.class} not to set #{store_name}["the key"] to "the value", but it did>
-            assertion = proc do
-              expect(controller).not_to set_store['the key'].
-                in_context(context).
-                to { method_in_context }
-            end
-
-            expect(&assertion).to fail_with_message(expected_message)
-          end
-        end
-      end
-    end
-  end
-
-  def controller_with_empty_store
-    build_fake_response
-  end
-
-  def controller_with_store(store_contents)
-    context = self
-
-    build_fake_response do
-      store = context.store_within(self)
-
-      store_contents.each do |key, value|
-        store[key] = value
-      end
-    end
-  end
-end