shoulda-matchers 2.6.0 → 2.6.1.rc1

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = '2.6.0'.freeze
+    VERSION = '2.6.1.rc1'.freeze
   end
 end

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

@@ -2,52 +2,55 @@ require 'spec_helper'
 
 describe Shoulda::Matchers::ActionController::CallbackMatcher do
   shared_examples 'CallbackMatcher' do |kind, callback_type|
-    let(:matcher) { described_class.new(:authenticate_user!, kind, callback_type) }
-    let(:controller) { define_controller('HookController') }
+    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
 
-    describe '#matches?' do
-      it "matches when a #{kind} hook is in place" do
-        add_callback(kind, callback_type, :authenticate_user!)
+    it "matches when a #{kind} hook is in place" do
+      add_callback(kind, callback_type, method_name)
 
-        expect(matcher.matches?(controller)).to be_true
-      end
+      expect(controller).to match
+    end
 
-      it "does not match when a #{kind} hook is missing" do
-        expect(matcher.matches?(controller)).to be_false
-      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 :authenticate_user! as a #{kind}_#{callback_type}"
+        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 :authenticate_user! as a #{kind}_#{callback_type}"
+        message = "Expected that HookController would have #{method_name.inspect} as a #{kind}_#{callback_type}"
 
         expect {
-          expect(controller).to send("use_#{kind}_#{callback_type}", :authenticate_user!)
+          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, :authenticate_user!)
-        message = "Expected that HookController would not have :authenticate_user! as a #{kind}_#{callback_type}"
+        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 send("use_#{kind}_#{callback_type}", :authenticate_user!)
-        }.to fail_with_message(message)
+        expect { expect(controller).not_to match }.to fail_with_message(message)
       end
     end
 
     private
 
     def add_callback(kind, callback_type, callback)
-      controller.send("#{kind}_#{callback_type}", callback)
+      controller.class.__send__("#{kind}_#{callback_type}", callback)
     end
   end
 

data/spec/shoulda/matchers/action_controller/strong_parameters_matcher_spec.rb

@@ -1,29 +1,29 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActionController do
-  describe "#permit" do
+  describe '#permit' do
     it 'matches when the sent parameter is allowed' do
-      controller_class = controller_for_resource_with_strong_parameters(action: :create) do
+      controller_for_resource_with_strong_parameters(action: :create) do
         params.require(:user).permit(:name)
       end
 
-      expect(controller_class).to permit(:name).for(:create)
+      expect(@controller).to permit(:name).for(:create)
     end
 
     it 'does not match when the sent parameter is not allowed' do
-      controller_class = controller_for_resource_with_strong_parameters(action: :create) do
+      controller_for_resource_with_strong_parameters(action: :create) do
         params.require(:user).permit(:name)
       end
 
-      expect(controller_class).not_to permit(:admin).for(:create)
+      expect(@controller).not_to permit(:admin).for(:create)
     end
 
     it 'matches against multiple attributes' do
-      controller_class = controller_for_resource_with_strong_parameters(action: :create) do
+      controller_for_resource_with_strong_parameters(action: :create) do
         params.require(:user).permit(:name, :age)
       end
 
-      expect(controller_class).to permit(:name, :age).for(:create)
+      expect(@controller).to permit(:name, :age).for(:create)
     end
   end
 end
@@ -56,145 +56,254 @@ describe Shoulda::Matchers::ActionController::StrongParametersMatcher do
     end
   end
 
-  describe "#matches?" do
-    it "is true for a subset of the allowable attributes" do
+  describe '#matches?' do
+    it 'is true for a subset of the allowable attributes' do
       controller_for_resource_with_strong_parameters(action: :create) do
         params.require(:user).permit(:name)
       end
 
       matcher = described_class.new([:name]).in_context(self).for(:create)
-      expect(matcher.matches?).to be_true
+      expect(matcher.matches?(@controller)).to be_true
     end
 
-    it "is true for all the allowable attributes" do
+    it 'is true for all the allowable attributes' do
       controller_for_resource_with_strong_parameters(action: :create) do
         params.require(:user).permit(:name, :age)
       end
 
       matcher = described_class.new([:name, :age]).in_context(self).for(:create)
-      expect(matcher.matches?).to be_true
+      expect(matcher.matches?(@controller)).to be_true
     end
 
-    it "is false when any attributes are not allowed" do
+    it 'is false when any attributes are not allowed' do
       controller_for_resource_with_strong_parameters(action: :create) do
         params.require(:user).permit(:name)
       end
 
       matcher = described_class.new([:name, :admin]).in_context(self).for(:create)
-      expect(matcher.matches?).to be_false
+      expect(matcher.matches?(@controller)).to be_false
     end
 
-    it "is false when permit is not called" do
-      controller_for_resource_with_strong_parameters(action: :create) {}
+    it 'is false when permit is not called' do
+      controller_for_resource_with_strong_parameters(action: :create)
 
       matcher = described_class.new([:name]).in_context(self).for(:create)
-      expect(matcher.matches?).to be_false
+      expect(matcher.matches?(@controller)).to be_false
     end
 
-    it "requires an action" do
+    it 'requires an action' do
+      controller_for_resource_with_strong_parameters
       matcher = described_class.new([:name])
-      expect { matcher.matches? }
-        .to raise_error(Shoulda::Matchers::ActionController::StrongParametersMatcher::ActionNotDefinedError)
+      expect { matcher.matches?(@controller) }.
+        to raise_error(described_class::ActionNotDefinedError)
     end
 
-    it "requires a verb for non-restful action" do
+    it 'requires a verb for non-restful action' do
+      controller_for_resource_with_strong_parameters
       matcher = described_class.new([:name]).for(:authorize)
-      expect { matcher.matches? }
-        .to raise_error(Shoulda::Matchers::ActionController::StrongParametersMatcher::VerbNotDefinedError)
+      expect { matcher.matches?(@controller) }.
+        to raise_error(described_class::VerbNotDefinedError)
+    end
+
+    it 'works with routes that require extra params' do
+      options = {
+        controller_name: 'Posts',
+        action: :show,
+        routes: -> {
+          get '/posts/:slug', to: 'posts#show'
+        }
+      }
+      controller_for_resource_with_strong_parameters(options) do
+        params.require(:user).permit(:name)
+      end
+
+      matcher = described_class.new([:name]).
+        in_context(self).
+        for(:show, verb: :get, params: { slug: 'foo' })
+      expect(matcher.matches?(@controller)).to be_true
+    end
+
+    it 'works with #update specifically' do
+      controller_for_resource_with_strong_parameters(action: :update) do
+        params.require(:user).permit(:name)
+      end
+
+      matcher = described_class.new([:name]).
+        in_context(self).
+        for(:update, params: { id: 1 })
+      expect(matcher.matches?(@controller)).to be_true
+    end
+
+    it 'does not raise an error when #fetch was used instead of #require (issue #495)' do
+      controller_for_resource_with_strong_parameters(action: :create) do
+        params.fetch(:order, {}).permit(:eta, :diner_id)
+      end
+
+      matcher = described_class.new([:eta, :diner_id]).
+        in_context(self).
+        for(:create)
+      expect(matcher.matches?(@controller)).to be_true
+    end
+
+    it 'tracks multiple calls to #permit' do
+      sets_of_attributes = [
+        [:eta, :diner_id],
+        [:phone_number, :address_1, :address_2, :city, :state, :zip]
+      ]
+      controller_for_resource_with_strong_parameters(action: :create) do
+        params.require(:order).permit(sets_of_attributes[0])
+        params.require(:diner).permit(sets_of_attributes[1])
+      end
+
+      matcher = described_class.new(sets_of_attributes[0]).
+        in_context(self).
+        for(:create)
+      expect(matcher.matches?(@controller)).to be_true
+
+      matcher = described_class.new(sets_of_attributes[1]).
+        in_context(self).
+        for(:create)
+      expect(matcher.matches?(@controller)).to be_true
     end
 
-    context 'Stubbing ActionController::Parameters#[]' do
-      it "does not permanently stub []" do
+    context 'stubbing params on the controller' do
+      it 'still allows the original params to be set and accessed' do
+        actual_user_params = nil
+        actual_foo_param = nil
+
         controller_for_resource_with_strong_parameters(action: :create) do
+          params[:foo] = 'bar'
+          actual_foo_param = params[:foo]
+
+          actual_user_params = params[:user]
+
           params.require(:user).permit(:name)
         end
 
-        described_class.new([:name]).in_context(self).for(:create).matches?
+        matcher = described_class.new([:name]).
+          in_context(self).
+          for(:create, params: { user: { some: 'params' } })
+        matcher.matches?(@controller)
+
+        expect(actual_user_params).to eq('some' => 'params')
+        expect(actual_foo_param).to eq 'bar'
+      end
+
+      it 'stubs the params during the controller action' do
+        controller_for_resource_with_strong_parameters(action: :create) do
+          params.require(:user)
+        end
+
+        matcher = described_class.new([:name]).in_context(self).for(:create)
+
+        expect { matcher.matches?(@controller) }.not_to raise_error
+      end
+
+      it 'does not permanently stub params' do
+        controller_for_resource_with_strong_parameters(action: :create)
+
+        matcher = described_class.new([:name]).in_context(self).for(:create)
+        matcher.matches?(@controller)
 
-        param = ActionController::Parameters.new(name: 'Ralph')[:name]
-        expect(param.singleton_class).not_to include(
-          Shoulda::Matchers::ActionController::StrongParametersMatcher::StubbedParameters
-        )
+        expect {
+          @controller.params.require(:user)
+        }.to raise_error(::ActionController::ParameterMissing)
       end
 
-      it 'prevents permanently overwriting [] on error' do
+      it 'prevents permanently stubbing params on error' do
         stub_controller_with_exception
 
         begin
-          described_class.new([:name]).in_context(self).for(:create).matches?
+          matcher = described_class.new([:name]).in_context(self).for(:create)
+          matcher.matches?(@controller)
         rescue SimulatedError
         end
 
-        param = ActionController::Parameters.new(name: 'Ralph')[:name]
-        expect(param.singleton_class).not_to include(
-          Shoulda::Matchers::ActionController::StrongParametersMatcher::StubbedParameters
-        )
+        expect {
+          @controller.params.require(:user)
+        }.to raise_error(::ActionController::ParameterMissing)
       end
     end
   end
 
-  describe "failure message" do
-    it "includes all missing attributes" do
-      controller_class = controller_for_resource_with_strong_parameters(action: :create) do
+  describe 'failure message' do
+    it 'includes all missing attributes' do
+      controller_for_resource_with_strong_parameters(action: :create) do
         params.require(:user).permit(:name, :age)
       end
 
       expect {
-        expect(controller_class).to permit(:name, :age, :city, :country).for(:create)
-      }.to fail_with_message("Expected controller to permit city and country, but it did not.")
+        expect(@controller).to permit(:name, :age, :city, :country).for(:create)
+      }.to fail_with_message('Expected controller to permit city and country, but it did not.')
     end
 
-    it "includes all attributes that should not have been allowed but were" do
-      controller_class = controller_for_resource_with_strong_parameters(action: :create) do
+    it 'includes all attributes that should not have been allowed but were' do
+      controller_for_resource_with_strong_parameters(action: :create) do
         params.require(:user).permit(:name, :age)
       end
 
       expect {
-        expect(controller_class).not_to permit(:name, :age).for(:create)
-      }.to fail_with_message("Expected controller not to permit name and age, but it did.")
+        expect(@controller).not_to permit(:name, :age).for(:create)
+      }.to fail_with_message('Expected controller not to permit name and age, but it did.')
     end
   end
 
-  describe "#for" do
-    context "when given :create" do
-      it "posts to the controller" do
-        context = stub('context', post: nil)
+  describe '#for' do
+    context 'when given :create' do
+      it 'POSTs to the controller' do
+        controller = ActionController::Base.new
+        context = mock()
+        context.expects(:post).with(:create, {})
         matcher = described_class.new([:name]).in_context(context).for(:create)
 
-        matcher.matches?
-        expect(context).to have_received(:post).with(:create)
+        matcher.matches?(controller)
       end
     end
 
-    context "when given :update" do
-      it "puts to the controller" do
-        context = stub('context', put: nil)
-        matcher = described_class.new([:name]).in_context(context).for(:update)
+    context 'when given :update' do
+      if rails_gte_41?
+        it 'PATCHes to the controller' do
+          controller = ActionController::Base.new
+          context = mock()
+          context.expects(:patch).with(:update, {})
+          matcher = described_class.new([:name]).in_context(context).for(:update)
 
-        matcher.matches?
-        expect(context).to have_received(:put).with(:update)
+          matcher.matches?(controller)
+        end
+      else
+        it 'PUTs to the controller' do
+          controller = ActionController::Base.new
+          context = mock()
+          context.expects(:put).with(:update, {})
+          matcher = described_class.new([:name]).in_context(context).for(:update)
+
+          matcher.matches?(controller)
+        end
       end
     end
 
-    context "when given a custom action and verb" do
-      it "deletes to the controller" do
-        context = stub('context', delete: nil)
-        matcher = described_class.new([:name]).in_context(context).for(:hide, verb: :delete)
+    context 'when given a custom action and verb' do
+      it 'calls the action with the verb' do
+        controller = ActionController::Base.new
+        context = mock()
+        context.expects(:delete).with(:hide, {})
+        matcher = described_class.new([:name]).
+          in_context(context).
+          for(:hide, verb: :delete)
 
-        matcher.matches?
-        expect(context).to have_received(:delete).with(:hide)
+        matcher.matches?(controller)
       end
     end
   end
 
   def stub_controller_with_exception
-    controller = define_controller('Examples') do
+    controller_class = define_controller('Examples') do
       def create
         raise SimulatedError
       end
     end
 
-    setup_rails_controller_test(controller)
+    setup_rails_controller_test(controller_class)
 
     define_routes do
       get 'examples', to: 'examples#create'

data/spec/shoulda/matchers/active_model/allow_value_matcher_spec.rb

@@ -24,6 +24,20 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
     end
   end
 
+  describe '#_after_setting_value' do
+    it 'sets a block which is yielded after each value is set on the attribute' do
+      attribute = :attr
+      record = define_model(:example, attribute => :string).new
+      matcher = described_class.new('a', 'b', 'c').for(attribute)
+      call_count = 0
+
+      matcher._after_setting_value { call_count += 1 }
+      matcher.matches?(record)
+
+      expect(call_count).to eq 3
+    end
+  end
+
   context 'an attribute with a validation' do
     it 'allows a good value' do
       expect(validating_format(with: /abc/)).to allow_value('abcde').for(:attr)