shoulda-matchers 3.1.0 → 5.2.0

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

data/spec/support/unit/validation_matcher_scenario.rb

@@ -1,62 +0,0 @@
-require 'forwardable'
-
-module UnitTests
-  class ValidationMatcherScenario
-    extend Forwardable
-
-    attr_reader :matcher
-
-    def initialize(arguments)
-      @arguments = arguments.dup
-      @matcher_proc = @arguments.delete(:matcher_proc)
-
-      @specified_model_creator = @arguments.delete(:model_creator) do
-        raise KeyError.new(<<-MESSAGE)
-:model_creator is missing. You can either provide it as an option or as
-a method.
-        MESSAGE
-      end
-
-      @model_creator = model_creator_class.new(@arguments)
-    end
-
-    def record
-      @_record ||= model.new.tap do |record|
-        attribute_default_values_by_name.each do |attribute_name, default_value|
-          record.public_send("#{attribute_name}=", default_value)
-        end
-      end
-    end
-
-    def model
-      @_model ||= model_creator.call
-    end
-
-    def matcher
-      @_matcher ||= matcher_proc.call(attribute_name)
-    end
-
-    protected
-
-    attr_reader(
-      :arguments,
-      :existing_value,
-      :matcher_proc,
-      :model_creator,
-      :specified_model_creator,
-    )
-
-    private
-
-    def_delegators(
-      :model_creator,
-      :attribute_name,
-      :attribute_default_values_by_name,
-    )
-
-    def model_creator_class
-      UnitTests::ModelCreators.retrieve(specified_model_creator) ||
-        specified_model_creator
-    end
-  end
-end

data/spec/unit/shoulda/matchers/action_controller/callback_matcher_spec.rb

@@ -1,82 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActionController::CallbackMatcher, type: :controller do
-  shared_examples 'CallbackMatcher' do |kind, callback_type|
-    let(:kind) { kind }
-    let(:callback_type) { callback_type }
-    let(:method_name) { :authenticate_user! }
-    let(:matcher) { described_class.new(method_name, kind, callback_type) }
-    let(:controller) { define_controller('HookController').new }
-
-    def match
-      __send__("use_#{kind}_#{callback_type}", method_name)
-    end
-
-    it "matches when a #{kind} hook is in place" do
-      add_callback(kind, callback_type, method_name)
-
-      expect(controller).to match
-    end
-
-    it "does not match when a #{kind} hook is missing" do
-      expect(controller).not_to match
-    end
-
-    describe 'description' do
-      it 'includes the filter kind and name' do
-        expect(matcher.description).to eq "have #{method_name.inspect} as a #{kind}_#{callback_type}"
-      end
-    end
-
-    describe 'failure message' do
-      it 'includes the filter kind and name that was expected' do
-        message = "Expected that HookController would have #{method_name.inspect} as a #{kind}_#{callback_type}"
-
-        expect {
-          expect(controller).to send("use_#{kind}_#{callback_type}", method_name)
-        }.to fail_with_message(message)
-      end
-    end
-
-    describe 'failure message when negated' do
-      it 'includes the filter kind and name that was expected' do
-        add_callback(kind, callback_type, method_name)
-        message = "Expected that HookController would not have #{method_name.inspect} as a #{kind}_#{callback_type}"
-
-        expect { expect(controller).not_to match }.to fail_with_message(message)
-      end
-    end
-
-    private
-
-    def add_callback(kind, callback_type, callback)
-      controller.class.__send__("#{kind}_#{callback_type}", callback)
-    end
-  end
-
-  describe '#use_before_filter' do
-    it_behaves_like 'CallbackMatcher', :before, :filter
-  end
-
-  describe '#use_after_filter' do
-    it_behaves_like 'CallbackMatcher', :after, :filter
-  end
-
-  describe '#use_around_filter' do
-    it_behaves_like 'CallbackMatcher', :around, :filter
-  end
-
-  if rails_4_x?
-    describe '#use_before_action' do
-      it_behaves_like 'CallbackMatcher', :before, :action
-    end
-
-    describe '#use_after_action' do
-      it_behaves_like 'CallbackMatcher', :after, :action
-    end
-
-    describe '#use_around_action' do
-      it_behaves_like 'CallbackMatcher', :around, :action
-    end
-  end
-end