shoulda-matchers 2.7.0 → 2.8.0.rc1

data/spec/support/{shared_examples → unit/shared_examples}/numerical_type_submatcher.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 shared_examples 'a numerical type submatcher' do
   it 'implements the allowed_type method' do
     expect(subject).to respond_to(:allowed_type).with(0).arguments

data/spec/{shoulda → unit/shoulda}/matchers/action_controller/callback_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController::CallbackMatcher do
+describe Shoulda::Matchers::ActionController::CallbackMatcher, type: :controller do
   shared_examples 'CallbackMatcher' do |kind, callback_type|
     let(:kind) { kind }
     let(:callback_type) { callback_type }

data/spec/{shoulda → unit/shoulda}/matchers/action_controller/filter_param_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController::FilterParamMatcher do
+describe Shoulda::Matchers::ActionController::FilterParamMatcher, type: :controller do
   it 'accepts filtering a filtered parameter' do
     filter(:secret)
 

data/spec/{shoulda → unit/shoulda}/matchers/action_controller/redirect_to_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController::RedirectToMatcher do
+describe Shoulda::Matchers::ActionController::RedirectToMatcher, type: :controller do
   context 'a controller that redirects' do
     it 'accepts redirecting to that url' do
       expect(controller_redirecting_to('/some/url')).to redirect_to('/some/url')
@@ -37,6 +37,6 @@ describe Shoulda::Matchers::ActionController::RedirectToMatcher do
   it 'provides the correct description when provided a block' do
     matcher = redirect_to('somewhere else') { '/some/other/url' }
 
-    expect(matcher.description).to eq 'redirect to somewhere else'
+    expect(matcher.description).to eq 'redirect to "somewhere else"'
   end
 end

data/spec/{shoulda → unit/shoulda}/matchers/action_controller/render_template_matcher_spec.rb

@@ -1,8 +1,6 @@
-require 'spec_helper'
-
-describe Shoulda::Matchers::ActionController::RenderTemplateMatcher do
-  include ActionController::TemplateAssertions
+require 'unit_spec_helper'
 
+describe Shoulda::Matchers::ActionController::RenderTemplateMatcher, type: :controller do
   context 'a controller that renders a template' do
     it 'accepts rendering that template' do
       expect(controller_with_show).to render_template(:show)

data/spec/{shoulda → unit/shoulda}/matchers/action_controller/render_with_layout_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher do
+describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher, type: :controller do
   include ActionController::TemplateAssertions
 
   context 'a controller that renders with a layout' do
@@ -41,15 +41,18 @@ describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher do
 
   context 'given a context with layouts' do
     it 'accepts that layout in that context' do
-      set_in_context_layout('happy')
+      context = Object.new
+      set_layout_in_context(context, 'happy')
 
-      expect(controller_without_layout).to render_with_layout('happy').in_context(self)
+      expect(controller_without_layout).
+        to render_with_layout('happy').
+        in_context(context)
     end
 
-    def set_in_context_layout(layout)
+    def set_layout_in_context(context, layout)
       layouts = Hash.new(0)
       layouts[layout] = 1
-      self.instance_variable_set(layouts_ivar, layouts)
+      context.instance_variable_set(layouts_ivar, layouts)
     end
 
     def layouts_ivar

data/spec/{shoulda → unit/shoulda}/matchers/action_controller/rescue_from_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController::RescueFromMatcher do
+describe Shoulda::Matchers::ActionController::RescueFromMatcher, type: :controller do
   context 'a controller that rescues from RuntimeError' do
     it 'asserts controller is setup with rescue_from' do
       expect(controller_with_rescue_from).to rescue_from RuntimeError

data/spec/{shoulda → unit/shoulda}/matchers/action_controller/respond_with_matcher_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController::RespondWithMatcher do
+describe Shoulda::Matchers::ActionController::RespondWithMatcher, type: :controller do
   statuses = { success: 200, redirect: 301, missing: 404, error: 500,
     not_implemented: 501 }
 

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

@@ -0,0 +1,126 @@
+require 'unit_spec_helper'
+
+describe 'Shoulda::Matchers::ActionController::RouteMatcher', type: :controller do
+  shared_examples_for 'a controller with a defined route' do
+    context 'when controller and action are specified as explicit options' do
+      it 'accepts' do
+        expect(controller_with_defined_routes).
+          to route(:get, "/#{controller_path}").
+          to(action: 'index')
+      end
+
+      it 'accepts a symbol controller' do
+        expect(controller_with_defined_routes).
+          to route(:get, "/#{controller_path}").
+          to(controller: controller_path.to_sym, action: 'index')
+      end
+
+      it 'accepts a symbol action' do
+        expect(controller_with_defined_routes).
+          to route(:get, "/#{controller_path}").
+          to(action: :index)
+      end
+
+      it 'rejects an undefined route' do
+        expect(controller_with_defined_routes).
+          not_to route(:get, '/non_existent_route').
+          to(action: 'non_existent')
+      end
+
+      it 'rejects a route for another controller' do
+        define_controller_with_defined_routes
+        other_controller = define_controller('Other').new
+        expect(other_controller).
+          not_to route(:get, "/#{controller_path}").
+          to(action: 'index')
+      end
+
+      context 'when route has parameters' do
+        it 'accepts a non-string parameter' do
+          expect(controller_with_defined_routes).
+            to route(:get, "/#{controller_path}/1").
+            to(action: 'show', id: 1)
+        end
+
+        it 'rejects a route for different parameters' do
+          expect(controller_with_defined_routes).
+            not_to route(:get, "/#{controller_path}/1").
+            to(action: 'show', some: 'other', params: 'here')
+        end
+      end
+    end
+
+    context 'when controller and action are specified as a joined string' do
+      it 'accepts' do
+        expect(controller_with_defined_routes).
+          to route(:get, "/#{controller_path}").
+          to("#{controller_path}#index")
+      end
+
+      context 'when route has parameters' do
+        it 'accepts a non-string parameter' do
+          expect(controller_with_defined_routes).
+            to route(:get, "/#{controller_path}/1").
+            to("#{controller_path}#show", id: 1)
+        end
+      end
+    end
+
+    def controller_with_defined_routes
+      @_controller_with_defined_routes ||= begin
+        controller_class = define_controller(controller_name)
+        _controller_path = controller_path
+
+        setup_rails_controller_test(controller_class)
+
+        define_routes do
+          get "/#{_controller_path}", to: "#{_controller_path}#index"
+          get "/#{_controller_path}/:id", to: "#{_controller_path}#show"
+        end
+
+        controller
+      end
+    end
+
+    def controller_path
+      controller_name.sub(/Controller$/, '').underscore
+    end
+
+    alias_method :define_controller_with_defined_routes,
+      :controller_with_defined_routes
+  end
+
+  context 'given a controller with a defined glob url' do
+    it 'accepts glob route' do
+      controller_class = define_controller('Examples')
+      setup_rails_controller_test(controller_class)
+
+      define_routes do
+        get '/examples/*id', to: 'examples#example'
+      end
+
+      expect(controller).to route(:get, '/examples/foo/bar').
+        to(action: 'example', id: 'foo/bar')
+    end
+  end
+
+  context 'given a controller that is not namespaced' do
+    it_behaves_like 'a controller with a defined route' do
+      def controller_name
+        'ExamplesController'
+      end
+    end
+  end
+
+  context 'given a controller that is namespaced' do
+    it_behaves_like 'a controller with a defined route' do
+      before do
+        define_module('Admin')
+      end
+
+      def controller_name
+        'Admin::ExamplesController'
+      end
+    end
+  end
+end

data/spec/{shoulda → unit/shoulda}/matchers/action_controller/route_params_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActionController::RouteParams do
+describe Shoulda::Matchers::ActionController::RouteParams, type: :controller do
   describe "#normalize" do
     context "when the route parameters is a hash" do
       it "stringifies the values in the hash" do

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

@@ -0,0 +1,167 @@
+require 'unit_spec_helper'
+
+describe Shoulda::Matchers::ActionController, type: :controller do
+  describe '#set_the_flash' do
+    it 'is deprecated in favor of #set_flash' do
+      expect { set_the_flash }.to deprecate(:set_the_flash, :set_flash)
+    end
+
+    it 'still works regardless' do
+      silence_warnings do
+        expect(controller_with_flash(notice: 'hi')).to set_the_flash
+      end
+    end
+  end
+
+  describe '#set_flash' do
+    it 'fails with unmatchable #to' do
+      expect { set_flash.to(1) }.to raise_error('cannot match against 1')
+    end
+
+    context 'a controller that sets a flash message' do
+      it 'accepts setting any flash message' do
+        expect(controller_with_flash(notice: 'hi')).to set_flash
+      end
+
+      it 'accepts setting the exact flash message' do
+        expect(controller_with_flash(notice: 'hi')).to set_flash.to('hi')
+      end
+
+      it 'accepts setting a matched flash message' do
+        expect(controller_with_flash(notice: 'hello')).to set_flash.to(/he/)
+      end
+
+      it 'rejects setting a different flash message' do
+        expect(controller_with_flash(notice: 'hi')).
+          not_to set_flash.to('other')
+      end
+
+      it 'rejects setting a different pattern' do
+        expect(controller_with_flash(notice: 'hi')).
+          not_to set_flash.to(/other/)
+      end
+    end
+
+    context 'a controller that sets a flash.now message' do
+      it 'rejects setting any flash message' do
+        expect(controller_with_flash_now).not_to set_flash
+      end
+
+      it 'accepts setting any flash.now message' do
+        expect(controller_with_flash_now).to set_flash.now
+      end
+
+      it 'accepts setting the exact flash.now message' do
+        expect(controller_with_flash_now(notice: 'hi')).
+          to set_flash.now.to('hi')
+      end
+
+      it 'accepts setting a matched flash.now message' do
+        expect(controller_with_flash_now(notice: 'flasher')).
+          to set_flash.now.to(/lash/)
+      end
+
+      it 'rejects setting a different flash.now message' do
+        expect(controller_with_flash_now(notice: 'hi')).
+          not_to set_flash.now.to('other')
+      end
+
+      it 'rejects setting a different flash.now pattern' do
+        expect(controller_with_flash_now(notice: 'hi')).
+          not_to set_flash.now.to(/other/)
+      end
+    end
+
+    context 'a controller that sets flash messages for multiple keys' do
+      it 'accepts flash message for either key' do
+        controller = controller_with_flash(notice: 'one', alert: 'two')
+
+        expect(controller).to set_flash[:notice]
+        expect(controller).to set_flash[:alert]
+      end
+
+      it 'rejects a flash message that is not one of the set keys' do
+        expect(controller_with_flash(notice: 'one', alert: 'two')).
+          not_to set_flash[:warning]
+      end
+
+      it 'accepts exact flash message of notice' do
+        expect(controller_with_flash(notice: 'one', alert: 'two')).
+          to set_flash[:notice].to('one')
+      end
+
+      it 'accepts setting a matched flash message of notice' do
+        expect(controller_with_flash(notice: 'one', alert: 'two')).
+          to set_flash[:notice].to(/on/)
+      end
+
+      it 'rejects setting a different flash message of notice' do
+        expect(controller_with_flash(notice: 'one', alert: 'two')).
+          not_to set_flash[:notice].to('other')
+      end
+
+      it 'rejects setting a different pattern' do
+        expect(controller_with_flash(notice: 'one', alert: 'two')).
+          not_to set_flash[:notice].to(/other/)
+      end
+    end
+
+    context 'a controller that sets flash and flash.now' do
+      it 'accepts setting any flash.now message' do
+        controller = build_fake_response do
+          flash.now[:notice] = 'value'
+          flash[:success] = 'great job'
+        end
+
+        expect(controller).to set_flash.now
+        expect(controller).to set_flash
+      end
+
+      it 'accepts setting a matched flash.now message' do
+        controller = build_fake_response do
+          flash.now[:notice] = 'value'
+          flash[:success] = 'great job'
+        end
+
+        expect(controller).to set_flash.now.to(/value/)
+        expect(controller).to set_flash.to(/great/)
+      end
+
+      it 'rejects setting a different flash.now message' do
+        controller = build_fake_response do
+          flash.now[:notice] = 'value'
+          flash[:success] = 'great job'
+        end
+
+        expect(controller).not_to set_flash.now.to('other')
+        expect(controller).not_to set_flash.to('other')
+      end
+    end
+
+    context 'a controller that does not set a flash message' do
+      it 'rejects setting any flash message' do
+        expect(controller_with_no_flashes).not_to set_flash
+      end
+    end
+  end
+
+  def controller_with_no_flashes
+    build_fake_response
+  end
+
+  def controller_with_flash(flash_hash)
+    build_fake_response do
+      flash_hash.each do |key, value|
+        flash[key] = value
+      end
+    end
+  end
+
+  def controller_with_flash_now(flash_hash = { notice: 'hi' })
+    build_fake_response do
+      flash_hash.each do |key, value|
+        flash.now[key] = value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,294 @@
+require 'unit_spec_helper'
+
+describe Shoulda::Matchers::ActionController, '#set_session', type: :controller do
+  context 'passing an argument to the initializer' do
+    it 'is deprecated in favor of using #[]' do
+      expectation = proc { set_session(:foo) }
+
+      expect(&expectation).to print_warning_including(
+        'Passing a key to set_session is deprecated'
+      )
+    end
+
+    it 'still works regardless' do
+      silence_warnings do
+        expect(controller_with_session(var: 'hi')).to set_session(:var)
+      end
+    end
+  end
+
+  context 'a controller that sets a session variable' do
+    context 'without any qualifiers' do
+      it 'accepts' do
+        expect(controller_with_session(var: 'hi')).to set_session
+      end
+    end
+
+    context 'with #to' do
+      context 'given a static value' do
+        context 'when any key in session has the given value' do
+          it 'accepts' do
+            expect(controller_with_session(var: 'hi')).
+              to set_session.to('hi')
+          end
+
+          it 'accepts given nil' do
+            silence_warnings do
+              expect(controller_with_session(var: nil)).
+                to set_session.to(nil)
+            end
+          end
+
+          it 'accepts given false' do
+            expect(controller_with_session(var: false)).
+              to set_session.to(false)
+          end
+        end
+
+        context 'when no key in session has the given value' do
+          it 'rejects' do
+            expect(controller_with_session(var: 'hi')).
+              not_to set_session.to('different')
+          end
+        end
+      end
+
+      context 'given a dynamic value' do
+        context 'when any key in session has the given value' do
+          it 'accepts' do
+            context = double(expected: 'hi')
+            expect(controller_with_session(var: 'hi')).
+              to set_session.in_context(context).to { expected }
+          end
+
+          it 'accepts given nil' do
+            silence_warnings do
+              context = double(expected: nil)
+              expect(controller_with_session(var: nil)).
+                to set_session.in_context(context).to { expected }
+            end
+          end
+
+          it 'accepts given false' do
+            context = double(expected: false)
+            expect(controller_with_session(var: false)).
+              to set_session.in_context(context).to { expected }
+          end
+        end
+
+        context 'when no key in session has the given value' do
+          it 'rejects' do
+            context = double(expected: 'different')
+            expect(controller_with_session(var: 'hi')).
+              not_to set_session.in_context(context).to { expected }
+          end
+        end
+      end
+
+      context 'given a regexp' do
+        context 'when any value in session matches the regexp' do
+          it 'accepts' do
+            expect(controller_with_session(var: 'hello')).
+              to set_session.to(/ello/)
+          end
+        end
+
+        context 'when no value in session matches the regexp' do
+          it 'rejects' do
+            expect(controller_with_session(var: 'hello')).
+              not_to set_session.to(/different/)
+          end
+        end
+      end
+    end
+
+    context 'with #[]' do
+      context 'when the given key is present in session' do
+        it 'accepts' do
+          expect(controller_with_session(var: 'hi')).to set_session[:var]
+        end
+
+        it 'accepts when expected key is a string' do
+          expect(controller_with_session(var: 'hi')).to set_session['var']
+        end
+      end
+
+      context 'when the given key is not present in session' do
+        it 'rejects' do
+          expect(controller_with_session(var: 'hi')).not_to set_session[:other]
+        end
+      end
+    end
+
+    context 'with #[] + #to' do
+      context 'given a static value' do
+        context 'when the given key and value are present in session' do
+          it 'accepts' do
+            expect(controller_with_session(var: 'hi')).
+              to set_session[:var].to('hi')
+          end
+
+          it 'accepts given nil' do
+            silence_warnings do
+              expect(controller_with_session(var: nil)).
+                to set_session[:var].to(nil)
+            end
+          end
+
+          it 'accepts given false' do
+            expect(controller_with_session(var: false)).
+              to set_session[:var].to(false)
+          end
+        end
+
+        context 'when the given key is present in session but not the given value' do
+          it 'rejects' do
+            expect(controller_with_session(var: 'hi')).
+              not_to set_session[:var].to('other')
+          end
+
+          it 'rejects given nil' do
+            expect(controller_with_session(var: 'hi')).
+              not_to set_session[:var].to(nil)
+          end
+        end
+
+        context 'when the given key is not present in session' do
+          it 'accepts given nil' do
+            silence_warnings do
+              expect(controller_with_session(var: 'hi')).
+                to set_session[:other].to(nil)
+            end
+          end
+
+          it 'rejects given false' do
+            expect(controller_with_session(var: false)).
+              not_to set_session[:other].to(false)
+          end
+        end
+      end
+
+      context 'given a dynamic value' do
+        context 'when the given key and value are present in session' do
+          it 'accepts' do
+            context = double(expected: 'value')
+
+            expect(controller_with_session(var: 'value')).
+              to set_session[:var].in_context(context).to { expected }
+          end
+
+          it 'accepts given nil' do
+            silence_warnings do
+              context = double(expected: nil)
+
+              expect(controller_with_session(var: nil)).
+                to set_session[:var].in_context(context).to { expected }
+            end
+          end
+
+          it 'accepts given false' do
+            context = double(expected: false)
+
+            expect(controller_with_session(var: false)).
+              to set_session[:var].in_context(context).to { expected }
+          end
+        end
+
+        context 'when the given key is present in session but not the given value' do
+          it 'rejects given nil' do
+            context = double(expected: nil)
+
+            expect(controller_with_session(var: 'hi')).
+              not_to set_session[:var].in_context(context).to { expected }
+          end
+
+          it 'rejects given false' do
+            context = double(expected: false)
+
+            expect(controller_with_session(var: 'hi')).
+              not_to set_session[:var].in_context(context).to { expected }
+          end
+        end
+
+        context 'when the given key is not present in session' do
+          it 'rejects' do
+            context = double(expected: 'other')
+
+            expect(controller_with_session(var: 'unexpected')).
+              not_to set_session[:var].in_context(context).to { expected }
+          end
+
+          it 'accepts given nil' do
+            silence_warnings do
+              context = double(expected: nil)
+
+              expect(controller_with_session(var: 'hi')).
+                to set_session[:other].in_context(context).to { expected }
+            end
+          end
+
+          it 'rejects given false' do
+            context = double(expected: false)
+
+            expect(controller_with_session(var: false)).
+              not_to set_session[:other].in_context(context).to { expected }
+          end
+        end
+      end
+    end
+  end
+
+  context 'a controller that does not set any session variables' do
+    context 'without any qualifiers' do
+      it 'rejects' do
+        expect(controller_without_session).not_to set_session
+      end
+    end
+
+    context 'with #[]' do
+      it 'rejects' do
+        expect(controller_without_session).
+          not_to set_session['any key']
+      end
+    end
+
+    context 'with #to' do
+      it 'rejects' do
+        expect(controller_without_session).
+          not_to set_session.to('any value')
+      end
+    end
+
+    context 'with #[] + #to' do
+      it 'rejects' do
+        expect(controller_without_session).
+          not_to set_session['any key'].to('any value')
+      end
+
+      it 'prints a warning when using .to(nil) to assert that a variable is unset' do
+        expectation = proc do
+          expect(controller_without_session).to set_session['any key'].to(nil)
+        end
+
+        expected_warning = <<EOT
+  Using `should set_session[...].to(nil)` to assert that a variable is unset is deprecated.
+  Please use `should_not set_session[...]` instead.
+EOT
+
+        expect(&expectation).to print_warning_including(expected_warning)
+      end
+    end
+  end
+
+  def controller_without_session
+    build_fake_response
+  end
+
+  def controller_with_session(session_hash)
+    build_fake_response do
+      session_hash.each do |key, value|
+        session[key] = value
+      end
+    end
+  end
+end