shoulda-matchers 4.0.0.rc1 → 4.0.1

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

@@ -1,42 +0,0 @@
-require 'unit_spec_helper'
-
-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')
-    end
-
-    it 'rejects redirecting to a different url' do
-      expect(controller_redirecting_to('/some/url')).
-        not_to redirect_to('/some/other/url')
-    end
-
-    it 'accepts redirecting to that url in a block' do
-      expect(controller_redirecting_to('/some/url')).
-        to redirect_to('somewhere') { '/some/url' }
-    end
-
-    it 'rejects redirecting to a different url in a block' do
-      expect(controller_redirecting_to('/some/url')).
-        not_to redirect_to('somewhere else') { '/some/other/url' }
-    end
-
-    def controller_redirecting_to(url)
-      build_fake_response { redirect_to url }
-    end
-  end
-
-  context 'a controller that does not redirect' do
-    it 'rejects redirecting to a url' do
-      controller = build_fake_response { render text: 'hello' }
-
-      expect(controller).not_to redirect_to('/some/url')
-    end
-  end
-
-  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"'
-  end
-end

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

@@ -1,76 +0,0 @@
-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)
-    end
-
-    it 'rejects rendering a different template' do
-      expect(controller_with_show).not_to render_template(:index)
-    end
-
-    it 'accepts rendering that template in the given context' do
-      expect(controller_with_show).to render_template(:show).in_context(self)
-    end
-
-    it 'rejects rendering a different template in the given context' do
-      expect(controller_with_show).not_to render_template(:index).in_context(self)
-    end
-
-    def controller_with_show
-      build_fake_response(action: 'show') { render }
-    end
-  end
-
-  context 'a controller that renders a partial' do
-    it 'accepts rendering that partial' do
-      expect(controller_with_customer_partial).
-        to render_template(partial: '_customer')
-    end
-
-    it 'rejects rendering a different template' do
-      expect(controller_with_customer_partial).
-        not_to render_template(partial: '_client')
-    end
-
-    it 'accepts rendering that template in the given context' do
-      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
-      expect(controller_with_customer_partial).
-        not_to render_template(partial: '_client').in_context(self)
-    end
-
-    def controller_with_customer_partial
-      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_fake_response(action: 'show') { render }
-
-      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_fake_response(partial: '_customer') do
-        render partial: 'customer', collection: [1,2]
-      end
-
-      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
-      expect(build_fake_response { head :ok }).
-        not_to render_template(:show)
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher, type: :controller do
-  include ActionController::TemplateAssertions
-
-  context 'a controller that renders with a layout' do
-    it 'accepts rendering with any layout' do
-      expect(controller_with_wide_layout).to render_with_layout
-    end
-
-    it 'accepts rendering with that layout' do
-      expect(controller_with_wide_layout).to render_with_layout(:wide)
-    end
-
-    it 'rejects rendering with another layout' do
-      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_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_fake_response { render layout: false }
-
-      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_fake_response { render partial: 'partial' }
-
-      expect(controller_with_partial).not_to render_with_layout
-    end
-  end
-
-  context 'given a context with layouts' do
-    it 'accepts that layout in that context' do
-      context = Object.new
-      set_layout_in_context(context, 'happy')
-
-      expect(controller_without_layout).
-        to render_with_layout('happy').
-        in_context(context)
-    end
-
-    def set_layout_in_context(context, layout)
-      layouts = Hash.new(0)
-      layouts[layout] = 1
-      context.instance_variable_set('@_layouts', layouts)
-    end
-
-    def controller_without_layout
-      build_fake_response { render layout: false }
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-require 'unit_spec_helper'
-
-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
-    end
-
-    context 'with a handler method' do
-      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 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 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)
-        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
-        matcher = rescue_from(RuntimeError)
-        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
-      matcher = rescue_from RuntimeError
-      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
-      rescue_from(RuntimeError) {}
-    end
-  end
-
-  def controller_with_rescue_from_and_invalid_method
-    define_controller 'RescueRuntimeErrorWithMethod' do
-      rescue_from RuntimeError, with: :error_method
-    end
-  end
-
-  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/unit/shoulda/matchers/action_controller/respond_with_matcher_spec.rb

@@ -1,31 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActionController::RespondWithMatcher, type: :controller do
-  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
-        expect(controller_with_status(numeric_code)).to respond_with(numeric_code)
-      end
-
-      it 'accepts responding with a symbol response code' do
-        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
-
-        expect(controller_with_status(numeric_code)).
-          not_to respond_with(another_status)
-      end
-    end
-  end
-
-  def controller_with_status(status)
-    build_fake_response do
-      render text: 'text', status: status
-    end
-  end
-end

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

@@ -1,330 +0,0 @@
-require 'unit_spec_helper'
-
-describe 'Shoulda::Matchers::ActionController::RouteMatcher', type: :controller do
-  shared_examples_for 'tests involving expected route parts' do |args|
-    include_controller_in_expected_route_options =
-      args.fetch(:include_controller_in_expected_route_options)
-
-    context 'when all parts of the expected route match an existing route' do
-      it 'accepts' do
-        define_route :get, '/', action: 'index'
-
-        assert_accepts add_target_to(
-          route(:get, '/'),
-          build_expected_route_options(
-            include_controller_in_expected_route_options,
-            action: 'index'
-          )
-        )
-      end
-
-      if include_controller_in_expected_route_options
-        context 'and the expected controller is specified as a symbol' do
-          it 'accepts' do
-            define_route :get, '/', action: 'index'
-
-            assert_accepts add_target_to(
-              route(:get, '/'),
-              build_expected_route_options(
-                include_controller_in_expected_route_options,
-                action: 'index'
-              )
-            )
-          end
-        end
-      end
-
-      context 'and the expected action is specified as a symbol' do
-        it 'accepts' do
-          define_route :get, '/', action: 'index'
-
-          assert_accepts add_target_to(
-            route(:get, '/'),
-            build_expected_route_options(
-              include_controller_in_expected_route_options,
-              action: :index
-            )
-          )
-        end
-      end
-    end
-
-    context 'when no parts of the expected route match an existing route' do
-      it 'rejects' do
-        assert_rejects add_target_to(
-          route(:get, '/non_existent_route'),
-          controller: 'no_controller',
-          action: 'no_action'
-        )
-      end
-    end
-
-    context 'when all parts of the expected route but the method match an existing route' do
-      it 'rejects' do
-        define_route :post, '/', action: 'index'
-
-        assert_rejects add_target_to(
-          route(:get, '/'),
-          build_expected_route_options(
-            include_controller_in_expected_route_options,
-            action: 'index'
-          )
-        )
-      end
-    end
-
-    context 'when all parts of the expected route but the path match an existing route' do
-      it 'rejects' do
-        define_route :get, '/', action: 'index'
-
-        assert_rejects add_target_to(
-          route(:get, '/different_path'),
-          build_expected_route_options(
-            include_controller_in_expected_route_options,
-            action: 'index'
-          )
-        )
-      end
-    end
-
-    if include_controller_in_expected_route_options
-      context 'when all parts of the expected route but the controller match an existing route' do
-        it 'rejects' do
-          define_route :get, '/', controller: 'another_controller', action: 'index'
-
-          assert_rejects add_target_to(
-            route(:get, '/'),
-            build_expected_route_options(
-              include_controller_in_expected_route_options,
-              action: 'index'
-            )
-          )
-        end
-      end
-    end
-
-    context 'when all parts of the expected route but the action match an existing route' do
-      it 'rejects' do
-        define_route :get, '/', action: 'index'
-
-        assert_rejects add_target_to(
-          route(:get, '/'),
-          build_expected_route_options(
-            include_controller_in_expected_route_options,
-            action: 'another_action'
-          )
-        )
-      end
-    end
-  end
-
-  shared_examples_for 'tests involving params' do
-    context 'when the actual route has a param' do
-      context 'and the expected params include that param' do
-        it 'accepts' do
-          define_route :get, "/#{controller_name}/:id", action: 'show'
-
-          assert_accepts add_target_to(
-            route(:get, "/#{controller_name}/1"),
-            controller: controller_name,
-            action: 'show',
-            id: '1'
-          )
-        end
-
-        context 'but its value was not specified as a string' do
-          it 'accepts, treating it as a string' do
-            define_route :get, "/#{controller_name}/:id", action: 'show'
-
-            assert_accepts add_target_to(
-              route(:get, "/#{controller_name}/1"),
-              controller: controller_name,
-              action: 'show',
-              id: 1
-            )
-          end
-        end
-      end
-
-      context 'and the expected params do not match the actual params' do
-        it 'rejects' do
-          define_route :get, "/#{controller_name}/:id", action: 'show'
-
-          params = {
-            controller: controller_name,
-            action: 'show',
-            some: 'other',
-            params: 'here'
-          }
-          assert_rejects add_target_to(
-            route(:get, "/#{controller_name}/:id"),
-            params
-          )
-        end
-      end
-    end
-
-    context 'when the actual route has a default param whose value is a symbol' do
-      context 'and the expected params include a value for it' do
-        context 'as a symbol' do
-          it 'accepts' do
-            define_route :post, "/#{controller_name}/(.:format)",
-              action: 'create',
-              defaults: { format: :json }
-
-            assert_accepts add_target_to(
-              route(:post, "/#{controller_name}"),
-              controller: controller_name,
-              action: 'create',
-              format: :json
-            )
-          end
-        end
-
-        context 'as a string' do
-          it 'accepts' do
-            define_route :post, "/#{controller_name}/(.:format)",
-              action: 'create',
-              defaults: { format: :json }
-
-            assert_accepts add_target_to(
-              route(:post, "/#{controller_name}"),
-              controller: controller_name,
-              action: 'create',
-              format: 'json'
-            )
-          end
-        end
-      end
-    end
-
-    context 'when the existing route has a glob segment' do
-      context 'and a param is given which represents the segment' do
-        it 'accepts' do
-          define_route :get, "/#{controller_name}/*id", action: 'whatever'
-
-          assert_accepts add_target_to(
-            route(:get, "/#{controller_name}/foo/bar"),
-            controller: controller_name,
-            action: 'whatever',
-            id: 'foo/bar'
-          )
-        end
-      end
-
-      context 'and no param is given which represents the segment' do
-        it 'rejects' do
-          define_route :get, "/#{controller_name}/*id", action: 'whatever'
-
-          assert_rejects add_target_to(
-            route(:get, "/#{controller_name}"),
-            controller: controller_name,
-            action: 'whatever'
-          )
-        end
-      end
-    end
-  end
-
-  shared_examples_for 'core tests' do
-    context 'given a controller and action specified as individual options' do
-      include_examples 'tests involving expected route parts',
-        include_controller_in_expected_route_options: true
-
-      include_examples 'tests involving params'
-
-      def add_target_to(route_matcher, params)
-        route_matcher.to(params)
-      end
-    end
-
-    context 'given a controller and action joined together in a string' do
-      include_examples 'tests involving expected route parts',
-        include_controller_in_expected_route_options: true
-
-      include_examples 'tests involving params'
-
-      def add_target_to(route_matcher, args)
-        controller = args.fetch(:controller)
-        action = args.fetch(:action)
-        route_matcher.to("#{controller}##{action}", args)
-      end
-    end
-
-    context 'given just an action' do
-      include_examples 'tests involving expected route parts',
-        include_controller_in_expected_route_options: false
-
-      include_examples 'tests involving params'
-
-      def add_target_to(route_matcher, params)
-        route_matcher.to(params)
-      end
-    end
-  end
-
-  before do
-    setup_rails_controller_test(controller_class)
-  end
-
-  context 'given a controller that is not namespaced' do
-    include_examples 'core tests'
-
-    def controller_class_name
-      'ExamplesController'
-    end
-  end
-
-  context 'given a controller that is namespaced' do
-    def define_controller_under_test
-      define_module('Admin')
-      super
-    end
-
-    include_examples 'core tests'
-
-    def controller_class_name
-      'Admin::ExamplesController'
-    end
-  end
-
-  let(:controller_class) do
-    define_controller_under_test
-  end
-
-  def define_controller_under_test
-    define_controller(controller_class_name)
-  end
-
-  def controller_name
-    controller_class_name.sub(/Controller$/, '').underscore
-  end
-
-  def define_route(method, path, args)
-    action = args.fetch(:action)
-    controller = args.fetch(:controller) { controller_name }
-    define_routes do
-      public_send(
-        method,
-        path,
-        args.merge(controller: controller, action: action)
-      )
-    end
-  end
-
-  def build_expected_route_options(include_controller_in_expected_route_options, default_options)
-    default_options.dup.tap do |options|
-      if include_controller_in_expected_route_options
-        options[:controller] = controller_name
-      end
-    end
-  end
-
-  def assert_accepts(matcher)
-    expect(controller).to matcher
-  end
-
-  def assert_rejects(matcher)
-    expect(controller).not_to matcher
-  end
-end