shoulda-matchers 4.0.0.rc1 → 4.0.1

data/spec/support/unit/validation_matcher_scenario.rb

@@ -1,60 +0,0 @@
-require 'forwardable'
-
-module UnitTests
-  class ValidationMatcherScenario
-    extend Forwardable
-
-    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
-
-  if action_pack_lt_5?
-    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
-  end
-
-  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

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

@@ -1,28 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActionController::FilterParamMatcher, type: :controller do
-  it 'accepts filtering a filtered parameter' do
-    filter(:secret)
-
-    expect(nil).to filter_param(:secret)
-  end
-
-  it 'accepts filtering a parameter matching a filtered regex' do
-    filter(/(?!tip)pin(?!g)/)
-
-    expect(nil).to filter_param(:pin)
-  end
-
-  it 'rejects filtering an unfiltered parameter' do
-    filter(:secret)
-    matcher = filter_param(:other)
-
-    expect(matcher.matches?(nil)).to eq false
-
-    expect(matcher.failure_message).to match(/Expected other to be filtered.*secret/)
-  end
-
-  def filter(param)
-    Rails.application.config.filter_parameters = [param]
-  end
-end

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

@@ -1,629 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActionController::PermitMatcher, type: :controller do
-  shared_examples 'basic tests' do
-    it 'accepts a subset of the permitted attributes' do
-      define_controller_with_strong_parameters(action: :create) do |ctrl|
-        params_with_conditional_require(ctrl.params).permit(:name, :age)
-      end
-
-      expect(controller).to permit_with_conditional_slice_of_params(
-        permit(:name).for(:create)
-      )
-    end
-
-    it 'accepts all of the permitted attributes' do
-      define_controller_with_strong_parameters(action: :create) do |ctrl|
-        params_with_conditional_require(ctrl.params).permit(:name, :age)
-      end
-
-      expect(controller).to permit_with_conditional_slice_of_params(
-        permit(:name, :age).for(:create)
-      )
-    end
-
-    it 'rejects attributes that have not been permitted' do
-      define_controller_with_strong_parameters(action: :create) do |ctrl|
-        params_with_conditional_require(ctrl.params).permit(:name)
-      end
-
-      expect(controller).not_to permit_with_conditional_slice_of_params(
-        permit(:name, :admin).for(:create)
-      )
-    end
-
-    it 'rejects when #permit has not been called' do
-      define_controller_with_strong_parameters(action: :create)
-
-      expect(controller).not_to permit_with_conditional_slice_of_params(
-        permit(:name).for(:create)
-      )
-    end
-
-    it 'tracks multiple calls to #permit for different subparameters' do
-      sets_of_attributes = [
-        [:eta, :diner_id],
-        [:phone_number, :address_1, :address_2, :city, :state, :zip]
-      ]
-
-      define_controller_with_strong_parameters(action: :create) do |ctrl|
-        params_with_conditional_require(ctrl.params, :order).
-          permit(sets_of_attributes[0])
-
-        params_with_conditional_require(ctrl.params, :diner).
-          permit(sets_of_attributes[1])
-      end
-
-      expect(controller).to permit_with_conditional_slice_of_params(
-        permit(*sets_of_attributes[0]).for(:create),
-        all_params: [:order, :diner],
-        selected_param: :order
-      )
-
-      expect(controller).to permit_with_conditional_slice_of_params(
-        permit(*sets_of_attributes[1]).for(:create),
-        all_params: [:order, :diner],
-        selected_param: :diner
-      )
-    end
-  end
-
-  it 'requires an action' do
-    assertion = -> { expect(controller).to permit(:name) }
-
-    define_controller_with_strong_parameters
-
-    expect(&assertion).to raise_error(described_class::ActionNotDefinedError)
-  end
-
-  it 'requires a verb for a non-restful action' do
-    define_controller_with_strong_parameters
-
-    assertion = lambda do
-      expect(controller).to permit(:name).for(:authorize)
-    end
-
-    expect(&assertion).to raise_error(described_class::VerbNotDefinedError)
-  end
-
-  context 'when operating on the entire params hash' do
-    include_context 'basic tests' do
-      def permit_with_conditional_slice_of_params(permit, options = {})
-        permit
-      end
-
-      def params_with_conditional_require(params, *filters)
-        params
-      end
-    end
-  end
-
-  context 'when operating on a slice of the params hash' do
-    include_context 'basic tests' do
-      def permit_with_conditional_slice_of_params(
-        permit,
-        all_params: [:user],
-        selected_param: :user
-      )
-        params = all_params.reduce({}) do |hash, param|
-          hash.merge(param => { any: 'value' })
-        end
-
-        permit.add_params(params).on(selected_param)
-      end
-
-      def params_with_conditional_require(params, *filters)
-        if filters.none?
-          filters = [:user]
-        end
-
-        params.require(*filters)
-      end
-    end
-
-    it 'rejects if asserting that parameters were not permitted, but on the wrong slice' do
-      define_controller_with_strong_parameters(action: :create) do
-        params.require(:order).permit(:eta, :diner_id)
-      end
-
-      expect(controller).
-        not_to permit(:eta, :diner_id).
-        for(:create, params: { order: { some: 'value' } }).
-        on(:something_else)
-    end
-
-    it 'tracks multiple calls to #permit for the same subparameter' do
-      define_controller_with_strong_parameters(action: :create) do
-        params.require(:foo).permit(:bar)
-        params.require(:foo).permit(:baz)
-      end
-
-      params = {
-        foo: {
-          bar: 'some value',
-          baz: 'some value'
-        }
-      }
-      expect(controller).
-        to permit(:bar).
-        on(:foo).
-        for(:create, params: params)
-      expect(controller).
-        to permit(:baz).
-        on(:foo).
-        for(:create, params: params)
-    end
-  end
-
-  it 'can be used more than once in the same test' do
-    define_controller_with_strong_parameters(action: :create) do
-      params.permit(:name)
-    end
-
-    expect(controller).to permit(:name).for(:create)
-    expect(controller).not_to permit(:admin).for(:create)
-  end
-
-  it 'allows extra parameters to be provided if the route requires them' do
-    options = {
-      controller_name: 'Posts',
-      action: :show,
-      routes: -> { get '/posts/:slug', to: 'posts#show' }
-    }
-
-    define_controller_with_strong_parameters(options) do
-      params.permit(:name)
-    end
-
-    expect(controller).
-      to permit(:name).
-      for(:show, verb: :get, params: { slug: 'foo' })
-  end
-
-  it 'works with #update specifically' do
-    define_controller_with_strong_parameters(action: :update) do
-      params.permit(:name)
-    end
-
-    expect(controller).
-      to permit(:name).
-      for(:update, params: { id: 1 })
-  end
-
-  it 'works when multiple ActionController::Parameters were instantiated' do
-    define_controller_with_strong_parameters(action: :create) do
-      params.permit(:name)
-      params.dup
-    end
-
-    expect(controller).to permit(:name).for(:create)
-  end
-
-  describe '#matches?' do
-    it 'does not raise an error when #fetch was used instead of #require (issue #495)' do
-      matcher = permit(:eta, :diner_id).for(:create)
-      matching = -> { matcher.matches?(controller) }
-
-      define_controller_with_strong_parameters(action: :create) do
-        params.fetch(:order, {}).permit(:eta, :diner_id)
-      end
-
-      expect(&matching).not_to raise_error
-    end
-
-    context 'stubbing params on the controller' do
-      it 'still allows the original params hash to be modified and accessed prior to the call to #require' do
-        actual_user_params = nil
-        actual_foo_param = nil
-        matcher = permit(:name).for(
-          :create,
-          params: { user: { some: 'params' } }
-        )
-
-        define_controller_with_strong_parameters(action: :create) do
-          params[:foo] = 'bar'
-          actual_foo_param = params[:foo]
-          actual_user_params = params[:user]
-
-          params.permit(:name)
-        end
-
-        matcher.matches?(controller)
-
-        expect(actual_user_params).to eq('some' => 'params')
-        expect(actual_foo_param).to eq 'bar'
-      end
-
-      it 'still allows #require to return a slice of the params' do
-        expected_user_params = { 'foo' => 'bar' }
-        actual_user_params = nil
-        matcher = permit(:name).for(
-          :update,
-          params: { id: 1, user: expected_user_params }
-        )
-
-        define_controller_with_strong_parameters(action: :update) do
-          actual_user_params = params.require(:user)
-          begin
-            actual_user_params.permit(:name)
-          rescue
-          end
-        end
-
-        matcher.matches?(controller)
-
-        expect(actual_user_params).to eq expected_user_params
-      end
-
-      it 'does not permanently stub the params hash' do
-        matcher = permit(:name).for(:create)
-        params_access = -> { controller.params.require(:user) }
-
-        define_controller_with_strong_parameters(action: :create)
-
-        matcher.matches?(controller)
-
-        expect(&params_access).
-          to raise_error(::ActionController::ParameterMissing)
-      end
-
-      it 'prevents permanently stubbing params on error' do
-        matcher = permit(:name).for(:create)
-        params_access = -> { controller.params.require(:user) }
-
-        define_controller_raising_exception
-
-        begin
-          matcher.matches?(controller)
-        rescue simulated_error_class
-        end
-
-        expect(&params_access).
-          to raise_error(::ActionController::ParameterMissing)
-      end
-    end
-  end
-
-  describe '#description' do
-    it 'returns the correct string' do
-      options = { action: :create, method: :post }
-
-      define_controller_with_strong_parameters(options) do
-        params.permit(:name, :age)
-      end
-
-      matcher = described_class.new([:name, :age, :height]).for(:create)
-      expect(matcher.description).to eq(
-        '(for POST #create) restrict parameters to :name, :age, and :height'
-      )
-    end
-
-    context 'when a verb is specified' do
-      it 'returns the correct string' do
-        options = { action: :some_action }
-
-        define_controller_with_strong_parameters(options) do
-          params.permit(:name, :age)
-        end
-
-        matcher = described_class.
-          new([:name]).
-          for(:some_action, verb: :put)
-        expect(matcher.description).to eq(
-          '(for PUT #some_action) restrict parameters to :name'
-        )
-      end
-    end
-  end
-
-  describe 'positive failure message' do
-    context 'when no parameters were permitted' do
-      it 'returns the correct message' do
-        define_controller_with_strong_parameters(action: :create)
-
-        assertion = lambda do
-          expect(@controller).
-            to permit(:name, :age, :city, :country).
-            for(:create)
-        end
-
-        message =
-          'Expected POST #create to restrict parameters to ' +
-          ":name, :age, :city, and :country,\n" +
-          'but it did not restrict any parameters.'
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-
-    context 'when some, but not all, parameters were permitted' do
-      it 'returns the correct message, including missing attributes' do
-        define_controller_with_strong_parameters(action: :create) do
-          params.permit(:name, :age)
-        end
-
-        assertion = lambda do
-          expect(@controller).
-            to permit(:name, :age, :city, :country).
-            for(:create)
-        end
-
-        message =
-          'Expected POST #create to restrict parameters to ' +
-          ":name, :age, :city, and :country,\n" +
-          'but the restricted parameters were :name and :age instead.'
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-
-    context 'qualified with #on' do
-      context 'when the subparameter was never required' do
-        it 'returns the correct message' do
-          define_controller_with_strong_parameters(action: :create) do
-            params.permit(:name, :age)
-          end
-
-          assertion = lambda do
-            expect(@controller).
-              to permit(:name, :age, :city, :country).
-              for(:create).
-              on(:person)
-          end
-
-          message =
-            'Expected POST #create to restrict parameters on :person to ' +
-            ":name, :age, :city, and :country,\n" +
-            'but it did not restrict any parameters.'
-
-          expect(&assertion).to fail_with_message(message)
-        end
-      end
-
-      context 'when the subparameter was required' do
-        context 'but no parameters were permitted' do
-          it 'returns the correct message' do
-            define_controller_with_strong_parameters(action: :create) do
-              params.require(:person)
-            end
-
-            assertion = lambda do
-              params = {
-                person: {
-                  name: 'some name',
-                  age: 'some age'
-                }
-              }
-              expect(@controller).
-                to permit(:name, :age, :city, :country).
-                for(:create, params: params).
-                on(:person)
-            end
-
-            message =
-              'Expected POST #create to restrict parameters on :person to ' +
-              ":name, :age, :city, and :country,\n" +
-              'but it did not restrict any parameters.'
-
-            expect(&assertion).to fail_with_message(message)
-          end
-        end
-
-        context 'but some, but not all, parameters were permitted' do
-          it 'returns the correct message' do
-            define_controller_with_strong_parameters(action: :create) do
-              params.require(:person).permit(:name, :age)
-            end
-
-            assertion = lambda do
-              params = {
-                person: {
-                  name: 'some name',
-                  age: 'some age'
-                }
-              }
-              expect(@controller).
-                to permit(:name, :age, :city, :country).
-                for(:create, params: params).
-                on(:person)
-            end
-
-            message =
-              'Expected POST #create to restrict parameters on :person to ' +
-              ":name, :age, :city, and :country,\n" +
-              'but the restricted parameters were :name and :age instead.'
-
-            expect(&assertion).to fail_with_message(message)
-          end
-        end
-      end
-    end
-  end
-
-  describe 'negative failure message' do
-    it 'returns the correct message' do
-      define_controller_with_strong_parameters(action: :create) do
-        params.permit(:name, :age, :city, :country)
-      end
-
-      assertion = lambda do
-        expect(@controller).
-          not_to permit(:name, :age, :city, :country).
-          for(:create)
-      end
-
-      message =
-        'Expected POST #create not to restrict parameters to ' +
-        ":name, :age, :city, and :country,\n" +
-        'but it did.'
-
-      expect(&assertion).to fail_with_message(message)
-    end
-
-    context 'qualified with #on' do
-      it 'returns the correct message' do
-        define_controller_with_strong_parameters(action: :create) do
-          params.require(:person).permit(:name, :age)
-        end
-
-        assertion = lambda do
-          params = {
-            person: {
-              name: 'some name',
-              age: 'some age'
-            }
-          }
-          expect(@controller).
-            not_to permit(:name, :age).
-            for(:create, params: params).
-            on(:person)
-        end
-
-        message =
-          'Expected POST #create not to restrict parameters on :person to ' +
-          ":name and :age,\n" +
-          'but it did.'
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-  end
-
-  describe '#for' do
-    context 'when given :create' do
-      it 'POSTs to the controller' do
-        controller = ActionController::Base.new
-        context = build_context
-        matcher = permit(:name).for(:create).in_context(context)
-
-        matcher.matches?(controller)
-
-        expect_to_have_made_controller_request(
-          verb: :post,
-          action: :create,
-          params: {},
-          context: context,
-        )
-      end
-    end
-
-    context 'when given :update' do
-      if rails_gte_4_1?
-        it 'PATCHes to the controller' do
-          controller = ActionController::Base.new
-          context = build_context
-          matcher = permit(:name).for(:update).in_context(context)
-
-          matcher.matches?(controller)
-
-          expect_to_have_made_controller_request(
-            verb: :patch,
-            action: :update,
-            params: {},
-            context: context,
-          )
-        end
-      else
-        it 'PUTs to the controller' do
-          controller = ActionController::Base.new
-          context = build_context
-          matcher = permit(:name).for(:update).in_context(context)
-
-          matcher.matches?(controller)
-
-          expect_to_have_made_controller_request(
-            verb: :put,
-            action: :update,
-            params: {},
-            context: context,
-          )
-        end
-      end
-    end
-
-    context 'when given a custom action and verb' do
-      it 'calls the action with the verb' do
-        controller = ActionController::Base.new
-        context = build_context
-        matcher = permit(:name).
-          for(:hide, verb: :delete).
-          in_context(context)
-
-        matcher.matches?(controller)
-
-        expect_to_have_made_controller_request(
-          verb: :delete,
-          action: :hide,
-          params: {},
-          context: context,
-        )
-      end
-    end
-  end
-
-  let(:simulated_error_class) do
-    Class.new(StandardError)
-  end
-
-  def define_controller_with_strong_parameters(options = {}, &action_body)
-    model_name = options.fetch(:model_name, 'User')
-    controller_name = options.fetch(:controller_name, 'UsersController')
-    collection_name = controller_name.
-      to_s.sub(/Controller$/, '').underscore.
-      to_sym
-    action_name = options.fetch(:action, :some_action)
-    routes = options.fetch(:routes, -> { resources collection_name })
-
-    define_model(model_name)
-
-    controller_class = define_controller(controller_name) do
-      define_method action_name do
-        if action_body
-          if action_body.arity == 0
-            instance_eval(&action_body)
-          else
-            action_body.call(self)
-          end
-        end
-
-        head :ok
-      end
-    end
-
-    setup_rails_controller_test(controller_class)
-
-    define_routes(&routes)
-
-    controller_class
-  end
-
-  def define_controller_raising_exception
-    _simulated_error_class = simulated_error_class
-
-    controller_class = define_controller('Examples') do
-      define_method :create do
-        raise _simulated_error_class
-      end
-    end
-
-    setup_rails_controller_test(controller_class)
-
-    define_routes do
-      get 'examples', to: 'examples#create'
-    end
-
-    controller_class
-  end
-
-  def build_context
-    double('context', post: nil, put: nil, patch: nil, delete: nil)
-  end
-
-  def expect_to_have_made_controller_request(context:, verb:, action:, params:)
-    if action_pack_gte_5?
-      expect(context).to have_received(verb).with(action, params: params)
-    else
-      expect(context).to have_received(verb).with(action, params)
-    end
-  end
-end