shoulda-matchers 2.5.0 → 2.6.0

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

@@ -5,74 +5,74 @@ describe Shoulda::Matchers::ActionController::RenderTemplateMatcher do
 
   context 'a controller that renders a template' do
     it 'accepts rendering that template' do
-      controller_with_show.should render_template(:show)
+      expect(controller_with_show).to render_template(:show)
     end
 
     it 'rejects rendering a different template' do
-      controller_with_show.should_not render_template(:index)
+      expect(controller_with_show).not_to render_template(:index)
     end
 
     it 'accepts rendering that template in the given context' do
-      controller_with_show.should render_template(:show).in_context(self)
+      expect(controller_with_show).to render_template(:show).in_context(self)
     end
 
     it 'rejects rendering a different template in the given context' do
-      controller_with_show.should_not render_template(:index).in_context(self)
+      expect(controller_with_show).not_to render_template(:index).in_context(self)
     end
 
     def controller_with_show
-      build_response(:action => 'show') { render }
+      build_fake_response(action: 'show') { render }
     end
   end
 
   context 'a controller that renders a partial' do
     it 'accepts rendering that partial' do
-      controller_with_customer_partial.
-        should render_template(:partial => '_customer')
+      expect(controller_with_customer_partial).
+        to render_template(partial: '_customer')
     end
 
     it 'rejects rendering a different template' do
-      controller_with_customer_partial.
-        should_not render_template(:partial => '_client')
+      expect(controller_with_customer_partial).
+        not_to render_template(partial: '_client')
     end
 
     it 'accepts rendering that template in the given context' do
-      controller_with_customer_partial.
-        should render_template(:partial => '_customer').in_context(self)
+      expect(controller_with_customer_partial).
+        to render_template(partial: '_customer').in_context(self)
     end
 
     it 'rejects rendering a different template in the given context' do
-      controller_with_customer_partial.
-        should_not render_template(:partial => '_client').in_context(self)
+      expect(controller_with_customer_partial).
+        not_to render_template(partial: '_client').in_context(self)
     end
 
     def controller_with_customer_partial
-      build_response(:partial => '_customer') { render :partial => 'customer' }
+      build_fake_response(partial: '_customer') { render partial: 'customer' }
     end
   end
 
   context 'a controller that does not render partials' do
     it 'accepts not rendering a partial' do
-      controller = build_response(:action => 'show') { render }
+      controller = build_fake_response(action: 'show') { render }
 
-      controller.should render_template(:partial => false)
+      expect(controller).to render_template(partial: false)
     end
   end
 
   context 'a controller that renders a partial several times' do
     it 'accepts rendering that partial twice' do
-      controller = build_response(:partial => '_customer') do
-        render :partial => 'customer', :collection => [1,2]
+      controller = build_fake_response(partial: '_customer') do
+        render partial: 'customer', collection: [1,2]
       end
 
-      controller.should render_template(:partial => '_customer', :count => 2)
+      expect(controller).to render_template(partial: '_customer', count: 2)
     end
   end
 
   context 'a controller that does not render a template' do
     it 'rejects rendering a template' do
-      build_response { render :nothing => true }.
-        should_not render_template(:show)
+      expect(build_fake_response { render nothing: true }).
+        not_to render_template(:show)
     end
   end
 end

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

@@ -5,37 +5,37 @@ describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher do
 
   context 'a controller that renders with a layout' do
     it 'accepts rendering with any layout' do
-      controller_with_wide_layout.should render_with_layout
+      expect(controller_with_wide_layout).to render_with_layout
     end
 
     it 'accepts rendering with that layout' do
-      controller_with_wide_layout.should render_with_layout(:wide)
+      expect(controller_with_wide_layout).to render_with_layout(:wide)
     end
 
     it 'rejects rendering with another layout' do
-      controller_with_wide_layout.should_not render_with_layout(:other)
+      expect(controller_with_wide_layout).not_to render_with_layout(:other)
     end
 
     def controller_with_wide_layout
       create_view('layouts/wide.html.erb', 'some content, <%= yield %>')
-      build_response { render :layout => 'wide' }
+      build_fake_response { render layout: 'wide' }
     end
   end
 
   context 'a controller that renders without a layout' do
 
     it 'rejects rendering with a layout' do
-      controller_without_layout = build_response { render :layout => false }
+      controller_without_layout = build_fake_response { render layout: false }
 
-      controller_without_layout.should_not render_with_layout
+      expect(controller_without_layout).not_to render_with_layout
     end
   end
 
   context 'a controller that renders a partial' do
     it 'rejects rendering with a layout' do
-      controller_with_partial = build_response { render :partial => 'partial' }
+      controller_with_partial = build_fake_response { render partial: 'partial' }
 
-      controller_with_partial.should_not render_with_layout
+      expect(controller_with_partial).not_to render_with_layout
     end
   end
 
@@ -43,7 +43,7 @@ describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher do
     it 'accepts that layout in that context' do
       set_in_context_layout('happy')
 
-      controller_without_layout.should render_with_layout('happy').in_context(self)
+      expect(controller_without_layout).to render_with_layout('happy').in_context(self)
     end
 
     def set_in_context_layout(layout)
@@ -57,7 +57,7 @@ describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher do
     end
 
     def controller_without_layout
-      build_response { render :layout => false }
+      build_fake_response { render layout: false }
     end
   end
 end

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

@@ -2,62 +2,89 @@ require 'spec_helper'
 
 describe Shoulda::Matchers::ActionController::RescueFromMatcher do
   context 'a controller that rescues from RuntimeError' do
-    it "asserts controller is setup with rescue_from" do
-      controller_with_rescue_from.should rescue_from RuntimeError
+    it 'asserts controller is setup with rescue_from' do
+      expect(controller_with_rescue_from).to rescue_from RuntimeError
     end
 
     context 'with a handler method' do
-      it "asserts rescue_from was set up with handler method" do
-        controller_with_rescue_from_and_method.should rescue_from(RuntimeError).with(:error_method)
+      it 'asserts rescue_from can find the handler when it is public' do
+        controller = controller_with_rescue_from_and_method(:public)
+        check_rescue_with_method_for(controller)
       end
 
-      it "asserts rescue_from was not set up with incorrect handler method" do
-        controller_with_rescue_from_and_method.should_not rescue_from(RuntimeError).with(:other_method)
+      it 'asserts rescue_from can find the handler when it is protected' do
+        controller = controller_with_rescue_from_and_method(:protected)
+        check_rescue_with_method_for(controller)
       end
 
-      it "asserts the controller responds to the handler method" do
+      it 'asserts rescue_from can find the handler when it is private' do
+        controller = controller_with_rescue_from_and_method(:private)
+        check_rescue_with_method_for(controller)
+      end
+
+      it 'asserts rescue_from was not set up with incorrect handler method' do
+        expect(controller_with_rescue_from_and_method).not_to rescue_from(RuntimeError).with(:other_method)
+      end
+
+      it 'asserts the controller responds to the handler method' do
         matcher = rescue_from(RuntimeError).with(:error_method)
-        matcher.matches?(controller_with_rescue_from_and_invalid_method).should be_false
-        matcher.failure_message.should =~ /does not respond to/
+        expect(matcher.matches?(controller_with_rescue_from_and_invalid_method)).to eq false
+        expect(matcher.failure_message).to match(/does not respond to/)
       end
     end
 
     context 'without a handler method' do
-      it "the handler method is not included in the description" do
+      it 'the handler method is not included in the description' do
         matcher = rescue_from(RuntimeError)
-        matcher.matches?(controller_with_rescue_from).should be_true
-        matcher.description.should_not =~ /with #/
+        expect(matcher.matches?(controller_with_rescue_from)).to eq true
+        expect(matcher.description).not_to match(/with #/)
       end
     end
   end
 
   context 'a controller that does not rescue from RuntimeError' do
-    it "asserts controller is not setup with rescue_from" do
+    it 'asserts controller is not setup with rescue_from' do
       matcher = rescue_from RuntimeError
-      define_controller("RandomController").should_not matcher
-      matcher.failure_message_when_negated.should =~ /Did not expect \w+ to rescue from/
+      expect(define_controller('RandomController')).not_to matcher
+      expect(matcher.failure_message_when_negated).to match(/Did not expect \w+ to rescue from/)
     end
   end
 
+  def check_rescue_with_method_for(controller)
+    expect(controller).to rescue_from(RuntimeError).with(:error_method)
+  end
+
   def controller_with_rescue_from
-    define_controller "RescueRuntimeError" do
+    define_controller 'RescueRuntimeError' do
       rescue_from(RuntimeError) {}
     end
   end
 
   def controller_with_rescue_from_and_invalid_method
-    define_controller "RescueRuntimeErrorWithMethod" do
+    define_controller 'RescueRuntimeErrorWithMethod' do
       rescue_from RuntimeError, with: :error_method
     end
   end
 
-  def controller_with_rescue_from_and_method
+  def controller_with_rescue_from_and_method(access = :public)
     controller = controller_with_rescue_from_and_invalid_method
     class << controller
       def error_method
         true
       end
     end
+
+    case access
+    when :protected
+      class << controller
+        protected :error_method
+      end
+    when :private
+      class << controller
+        private :error_method
+      end
+    end
+
     controller
   end
 end

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

@@ -1,31 +1,31 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActionController::RespondWithMatcher do
-  statuses = { :success => 200, :redirect => 301, :missing => 404, :error => 500,
-    :not_implemented => 501 }
+  statuses = { success: 200, redirect: 301, missing: 404, error: 500,
+    not_implemented: 501 }
 
   statuses.each do |human_name, numeric_code|
     context "a controller responding with #{human_name}" do
       it 'accepts responding with a numeric response code' do
-        controller_with_status(numeric_code).should respond_with(numeric_code)
+        expect(controller_with_status(numeric_code)).to respond_with(numeric_code)
       end
 
       it 'accepts responding with a symbol response code' do
-        controller_with_status(numeric_code).should respond_with(human_name)
+        expect(controller_with_status(numeric_code)).to respond_with(human_name)
       end
 
       it 'rejects responding with another status' do
         another_status = statuses.except(human_name).keys.first
 
-        controller_with_status(numeric_code).
-          should_not respond_with(another_status)
+        expect(controller_with_status(numeric_code)).
+          not_to respond_with(another_status)
       end
     end
   end
 
   def controller_with_status(status)
-    build_response do
-      render :text => 'text', :status => status
+    build_fake_response do
+      render text: 'text', status: status
     end
   end
 end

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

@@ -6,62 +6,62 @@ describe Shoulda::Matchers::ActionController::RouteMatcher, type: :controller do
       controller = define_controller('Examples').new
 
       define_routes do
-        get 'examples/*id', :to => 'examples#example'
+        get 'examples/*id', to: 'examples#example'
       end
 
-      controller.should route(:get, '/examples/foo/bar').
-        to(:action => 'example', :id => 'foo/bar')
+      expect(controller).to route(:get, '/examples/foo/bar').
+        to(action: 'example', id: 'foo/bar')
     end
   end
 
   context 'given a controller with a defined route' do
 
     it 'accepts routing the correct path to the correct parameters' do
-      route_examples_to_examples.should route(:get, '/examples/1').
-        to(:action => 'example', :id => '1')
+      expect(route_examples_to_examples).to route(:get, '/examples/1').
+        to(action: 'example', id: '1')
     end
 
     it 'accepts a symbol controller' do
       route_examples_to_examples
-      Object.new.should route(:get, '/examples/1').
-        to(:controller => :examples, :action => 'example', :id => '1')
+      expect(Object.new).to route(:get, '/examples/1').
+        to(controller: :examples, action: 'example', id: '1')
     end
 
     it 'accepts a symbol action' do
-      route_examples_to_examples.should route(:get, '/examples/1').
-        to(:action => :example, :id => '1')
+      expect(route_examples_to_examples).to route(:get, '/examples/1').
+        to(action: :example, id: '1')
     end
 
     it 'accepts a non-string parameter' do
-      route_examples_to_examples.should route(:get, '/examples/1').
-        to(:action => 'example', :id => 1)
+      expect(route_examples_to_examples).to route(:get, '/examples/1').
+        to(action: 'example', id: 1)
     end
 
     it 'rejects an undefined route' do
-      route_examples_to_examples.
-        should_not route(:get, '/bad_route').to(:var => 'value')
+      expect(route_examples_to_examples).
+        not_to route(:get, '/bad_route').to(var: 'value')
     end
 
     it 'rejects a route for another controller' do
       route_examples_to_examples
       other = define_controller('Other').new
-      other.should_not route(:get, '/examples/1').
-        to(:action => 'example', :id => '1')
+      expect(other).not_to route(:get, '/examples/1').
+        to(action: 'example', id: '1')
     end
 
     it 'rejects a route for different parameters' do
-      route_examples_to_examples.should_not route(:get, '/examples/1').
-        to(:action => 'other', :id => '1')
+      expect(route_examples_to_examples).not_to route(:get, '/examples/1').
+        to(action: 'other', id: '1')
     end
 
     it "accepts a string as first parameter" do
-      route_examples_to_examples.should route(:get, '/examples/1').
+      expect(route_examples_to_examples).to route(:get, '/examples/1').
         to("examples#example", id: '1')
     end
 
     def route_examples_to_examples
       define_routes do
-        get 'examples/:id', :to => 'examples#example'
+        get 'examples/:id', to: 'examples#example'
       end
 
       define_controller('Examples').new

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

@@ -4,22 +4,22 @@ describe Shoulda::Matchers::ActionController::RouteParams do
   describe "#normalize" do
     context "when the route parameters is a hash" do
       it "stringifies the values in the hash" do
-        build_route_params(:controller => :examples, :action => 'example', :id => '1').normalize.
-          should eq({ :controller => "examples", :action => "example", :id => "1" })
+        expect(build_route_params(controller: :examples, action: 'example', id: '1').normalize).
+          to eq({ controller: "examples", action: "example", id: "1" })
       end
     end
 
     context "when the route parameters is a string and a hash" do
       it "produces a hash of route parameters" do
-        build_route_params("examples#example", id: '1').normalize.
-          should eq({ :controller => "examples", :action => "example", :id => "1" })
+        expect(build_route_params("examples#example", id: '1').normalize).
+          to eq({ controller: "examples", action: "example", id: "1" })
       end
     end
 
     context "when the route params is a string" do
       it "produces a hash of route params" do
-        build_route_params("examples#index").normalize.
-          should eq({ :controller => "examples", :action => "index"})
+        expect(build_route_params("examples#index").normalize).
+          to eq({ controller: "examples", action: "index"})
       end
     end
   end

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

@@ -3,45 +3,45 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActionController::SetSessionMatcher do
   context 'a controller that sets a session variable' do
     it 'accepts assigning to that variable' do
-      controller_with_session(:var => 'hi').should set_session(:var)
+      expect(controller_with_session(var: 'hi')).to set_session(:var)
     end
 
     it 'accepts assigning the correct value to that variable' do
-      controller_with_session(:var => 'hi').should set_session(:var).to('hi')
+      expect(controller_with_session(var: 'hi')).to set_session(:var).to('hi')
     end
 
     it 'rejects assigning another value to that variable' do
-      controller_with_session(:var => 'hi').should_not set_session(:var).to('other')
+      expect(controller_with_session(var: 'hi')).not_to set_session(:var).to('other')
     end
 
     it 'rejects assigning to another variable' do
-      controller_with_session(:var => 'hi').should_not set_session(:other)
+      expect(controller_with_session(var: 'hi')).not_to set_session(:other)
     end
 
     it 'accepts assigning nil to another variable' do
-      controller_with_session(:var => 'hi').should set_session(:other).to(nil)
+      expect(controller_with_session(var: 'hi')).to set_session(:other).to(nil)
     end
 
     it 'accepts assigning false to that variable' do
-      controller_with_session(:var => false).should set_session(:var).to(false)
+      expect(controller_with_session(var: false)).to set_session(:var).to(false)
     end
 
     it 'accepts assigning to the same value in the test context' do
       expected = 'value'
 
-      controller_with_session(:var => expected).
-        should set_session(:var).in_context(self).to { expected }
+      expect(controller_with_session(var: expected)).
+        to set_session(:var).in_context(self).to { expected }
     end
 
     it 'rejects assigning to the another value in the test context' do
       expected = 'other'
 
-      controller_with_session(:var => 'unexpected').
-        should_not set_session(:var).in_context(self).to { expected }
+      expect(controller_with_session(var: 'unexpected')).
+        not_to set_session(:var).in_context(self).to { expected }
     end
 
     def controller_with_session(session_hash)
-      build_response do
+      build_fake_response do
         session_hash.each do |key, value|
           session[key] = value
         end