mcmire-shoulda-matchers 2.5.0

data/lib/shoulda/matchers/action_controller/render_with_layout_matcher.rb

@@ -0,0 +1,117 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `render_with_layout` matcher tests that an action is rendered with
+      # a certain layout.
+      #
+      #     class PostsController < ApplicationController
+      #       def show
+      #         render layout: 'posts'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #show' do
+      #         before { get :show }
+      #
+      #         it { should render_with_layout('posts') }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #show' do
+      #         setup { get :show }
+      #
+      #         should render_with_layout('posts')
+      #       end
+      #     end
+      #
+      # @return [RenderWithLayoutMatcher]
+      #
+      def render_with_layout(expected_layout = nil)
+        RenderWithLayoutMatcher.new(expected_layout).in_context(self)
+      end
+
+      # @private
+      class RenderWithLayoutMatcher
+        def initialize(expected_layout)
+          unless expected_layout.nil?
+            @expected_layout = expected_layout.to_s
+          end
+        end
+
+        # Used to provide access to layouts recorded by
+        # ActionController::TemplateAssertions in Rails 3
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          rendered_with_layout? && rendered_with_expected_layout?
+        end
+
+        def failure_message
+          "Expected #{expectation}, but #{result}"
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}, but #{result}"
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def description
+          description = 'render with '
+          if @expected_layout.nil?
+            description << 'a layout'
+          else
+            description << "the #{@expected_layout.inspect} layout"
+          end
+          description
+        end
+
+        private
+
+        def rendered_with_layout?
+          !rendered_layouts.empty?
+        end
+
+        def rendered_with_expected_layout?
+          if @expected_layout.nil?
+            true
+          else
+            rendered_layouts.include?(@expected_layout)
+          end
+        end
+
+        def rendered_layouts
+          recorded_layouts.keys.compact.map { |layout| layout.sub(%r{^layouts/}, '') }
+        end
+
+        def recorded_layouts
+          if @context
+            @context.instance_variable_get(Shoulda::Matchers::RailsShim.layouts_ivar)
+          else
+            {}
+          end
+        end
+
+        def expectation
+          "to #{description}"
+        end
+
+        def result
+          if rendered_with_layout?
+            'rendered with ' + rendered_layouts.map(&:inspect).join(', ')
+          else
+            'rendered without a layout'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/action_controller/rescue_from_matcher.rb

@@ -0,0 +1,114 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `rescue_from` matcher tests usage of the `rescue_from` macro. It
+      # asserts that an exception and method are present in the list of
+      # exception handlers, and that the handler method exists.
+      #
+      #     class ApplicationController < ActionController::Base
+      #       rescue_from ActiveRecord::RecordNotFound, with: :handle_not_found
+      #
+      #       private
+      #
+      #       def handle_not_found
+      #         # ...
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe ApplicationController do
+      #       it do
+      #         should rescue_from(ActiveRecord::RecordNotFound).
+      #           with(:handle_not_found)
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class ApplicationControllerTest < ActionController::TestCase
+      #       should rescue_from(ActiveRecord::RecordNotFound).
+      #         with(:handle_not_found)
+      #     end
+      #
+      # @return [RescueFromMatcher]
+      #
+      def rescue_from(exception)
+        RescueFromMatcher.new exception
+      end
+
+      # @private
+      class RescueFromMatcher
+        def initialize(exception)
+          @exception = exception
+        end
+
+        def with(method)
+          @expected_method = method
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          rescues_from_exception? && method_name_matches? && handler_exists?
+        end
+
+        def description
+          description = "rescues from #{exception}"
+          description << " with ##{expected_method}" if expected_method
+          description
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}"
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        private
+
+        attr_reader :controller, :exception, :expected_method, :handlers
+
+        def expectation
+          expectation = "#{controller} to rescue from #{exception}"
+
+          if expected_method && !method_name_matches?
+            expectation << " with ##{expected_method}"
+          end
+
+          unless handler_exists?
+            expectation << " but #{controller} does not respond to #{expected_method}"
+          end
+          expectation
+        end
+
+        def rescues_from_exception?
+          @handlers = controller.rescue_handlers.select do |handler|
+            handler.first == exception.to_s
+          end
+          handlers.any?
+        end
+
+        def method_name_matches?
+          if expected_method.present?
+            handlers.any? do |handler|
+              handler.last == expected_method
+            end
+          else
+            true
+          end
+        end
+
+        def handler_exists?
+          if expected_method.present?
+            controller.respond_to? expected_method
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/action_controller/respond_with_matcher.rb

@@ -0,0 +1,154 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `respond_with` matcher tests that an action responds with a certain
+      # status code.
+      #
+      # You can specify that the status should be a number:
+      #
+      #     class PostsController < ApplicationController
+      #       def index
+      #         render status: 403
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #index' do
+      #         before { get :index }
+      #
+      #         it { should respond_with(403) }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #index' do
+      #         setup { get :index }
+      #
+      #         should respond_with(403)
+      #       end
+      #     end
+      #
+      # You can specify that the status should be within a range of numbers:
+      #
+      #     class PostsController < ApplicationController
+      #       def destroy
+      #         render status: 508
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'DELETE #destroy' do
+      #         before { delete :destroy }
+      #
+      #         it { should respond_with(500..600) }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'DELETE #destroy' do
+      #         setup { delete :destroy }
+      #
+      #         should respond_with(500..600)
+      #       end
+      #     end
+      #
+      # Finally, you can specify that the status should be a symbol:
+      #
+      #     class PostsController < ApplicationController
+      #       def show
+      #         render status: :locked
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       describe 'GET #show' do
+      #         before { get :show }
+      #
+      #         it { should respond_with(:locked) }
+      #       end
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       context 'GET #show' do
+      #         setup { get :show }
+      #
+      #         should respond_with(:locked)
+      #       end
+      #     end
+      #
+      # @return [RespondWithMatcher]
+      #
+      def respond_with(status)
+        RespondWithMatcher.new(status)
+      end
+
+      # @private
+      class RespondWithMatcher
+        def initialize(status)
+          @status = symbol_to_status_code(status)
+        end
+
+        def matches?(controller)
+          @controller = controller
+          correct_status_code? || correct_status_code_range?
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}"
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def description
+          "respond with #{@status}"
+        end
+
+        protected
+
+        def correct_status_code?
+          response_code == @status
+        end
+
+        def correct_status_code_range?
+          @status.is_a?(Range) &&
+            @status.include?(response_code)
+        end
+
+        def response_code
+          @controller.response.response_code
+        end
+
+        def symbol_to_status_code(potential_symbol)
+          case potential_symbol
+          when :success  then 200
+          when :redirect then 300..399
+          when :missing  then 404
+          when :error    then 500..599
+          when Symbol
+            if defined?(::Rack::Utils::SYMBOL_TO_STATUS_CODE)
+              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[potential_symbol]
+            else
+              ::ActionController::Base::SYMBOL_TO_STATUS_CODE[potential_symbol]
+            end
+          else
+            potential_symbol
+          end
+        end
+
+        def expectation
+          "response to be a #{@status}, but was #{response_code}"
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/action_controller/route_matcher.rb

@@ -0,0 +1,116 @@
+module Shoulda
+  module Matchers
+    module ActionController
+      # The `route` matcher tests that a route resolves to a controller,
+      # action, and params; and that the controller, action, and params
+      # generates the same route. For an RSpec suite, this is like using a
+      # combination of `route_to` and `be_routable`. For a Test::Unit suite, it
+      # provides a more expressive syntax over `assert_routing`.
+      #
+      # Given these routes:
+      #
+      #     My::Application.routes.draw do
+      #       get '/posts', controller: 'posts', action: 'index'
+      #       get '/posts/:id' => 'posts#show'
+      #     end
+      #
+      # You can choose to keep your routing tests under the test file for one
+      # controller:
+      #
+      #     class PostsController < ApplicationController
+      #       # ...
+      #     end
+      #
+      #     # RSpec
+      #     describe PostsController do
+      #       it { should route(:get, '/posts').to(action: :index) }
+      #       it { should route(:get, '/posts/1').to(action: :show, id: 1) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class PostsControllerTest < ActionController::TestCase
+      #       should route(:get, '/posts').to(action: 'index')
+      #       should route(:get, '/posts/1').to(action: :show, id: 1)
+      #     end
+      #
+      # Or if you like, you can keep all of your routing tests in one file.
+      # Just be sure to always specify a controller as `route` won't be able to
+      # figure it out otherwise:
+      #
+      #     # RSpec
+      #     describe 'Routing' do
+      #       it { should route(:get, '/posts').to(controller: :posts, action: :index) }
+      #       it { should route(:get, '/posts/1').to('posts#show', id: 1) }
+      #     end
+      #
+      #     # Test::Unit
+      #     class RoutesTest < ActionController::IntegrationTest
+      #       should route(:get, '/posts').to(controller: :posts, action: :index)
+      #       should route(:get, '/posts/1').to('posts#show', id: 1)
+      #     end
+      #
+      # @return [RouteMatcher]
+      #
+      def route(method, path)
+        RouteMatcher.new(method, path, self)
+      end
+
+      # @private
+      class RouteMatcher
+        def initialize(method, path, context)
+          @method  = method
+          @path    = path
+          @context = context
+        end
+
+        attr_reader :failure_message, :failure_message_when_negated
+
+        alias failure_message_for_should failure_message
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def to(*args)
+          @params = RouteParams.new(args).normalize
+          self
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def matches?(controller)
+          guess_controller!(controller)
+          route_recognized?
+        end
+
+        def description
+          "route #{@method.to_s.upcase} #{@path} to/from #{@params.inspect}"
+        end
+
+        private
+
+        def guess_controller!(controller)
+          @params[:controller] ||= controller.controller_path
+        end
+
+
+        def route_recognized?
+          begin
+            @context.__send__(:assert_routing,
+                          { method: @method, path: @path },
+                          @params)
+
+            @failure_message_when_negated = "Didn't expect to #{description}"
+            true
+          rescue ::ActionController::RoutingError => error
+            @failure_message = error.message
+            false
+          rescue Shoulda::Matchers::AssertionError => error
+            @failure_message = error.message
+            false
+          end
+        end
+      end
+    end
+  end
+end