mcmire-shoulda-matchers 2.5.0

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RenderWithLayoutMatcher 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_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 }
+
+      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' }
+
+      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
+      set_in_context_layout('happy')
+
+      expect(controller_without_layout).to render_with_layout('happy').in_context(self)
+    end
+
+    def set_in_context_layout(layout)
+      layouts = Hash.new(0)
+      layouts[layout] = 1
+      self.instance_variable_set(layouts_ivar, layouts)
+    end
+
+    def layouts_ivar
+      Shoulda::Matchers::RailsShim.layouts_ivar
+    end
+
+    def controller_without_layout
+      build_response { render layout: false }
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+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
+      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
+        expect(controller_with_rescue_from_and_method).to rescue_from(RuntimeError).with(:error_method)
+      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 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
+    controller = controller_with_rescue_from_and_invalid_method
+    class << controller
+      def error_method
+        true
+      end
+    end
+    controller
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RespondWithMatcher 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_response do
+      render text: 'text', status: status
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RouteMatcher, type: :controller do
+  context 'given a controller with a defined glob url' do
+    it 'accepts glob route' do
+      controller = define_controller('Examples').new
+
+      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 with a defined route' do
+
+    it 'accepts routing the correct path to the correct parameters' do
+      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
+      expect(Object.new).to route(:get, '/examples/1').
+        to(controller: :examples, action: 'example', id: '1')
+    end
+
+    it 'accepts a symbol action' do
+      expect(route_examples_to_examples).to route(:get, '/examples/1').
+        to(action: :example, id: '1')
+    end
+
+    it 'accepts a non-string parameter' do
+      expect(route_examples_to_examples).to route(:get, '/examples/1').
+        to(action: 'example', id: 1)
+    end
+
+    it 'rejects an undefined route' do
+      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
+      expect(other).not_to route(:get, '/examples/1').
+        to(action: 'example', id: '1')
+    end
+
+    it 'rejects a route for different parameters' do
+      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
+      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'
+      end
+
+      define_controller('Examples').new
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+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
+        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
+        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
+        expect(build_route_params("examples#index").normalize).
+          to eq({ controller: "examples", action: "index"})
+      end
+    end
+  end
+
+  def build_route_params(*params)
+    Shoulda::Matchers::ActionController::RouteParams.new(params)
+  end
+end

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

@@ -0,0 +1,51 @@
+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
+      expect(controller_with_session(var: 'hi')).to set_session(:var)
+    end
+
+    it 'accepts assigning the correct value to that variable' do
+      expect(controller_with_session(var: 'hi')).to set_session(:var).to('hi')
+    end
+
+    it 'rejects assigning another value to that variable' do
+      expect(controller_with_session(var: 'hi')).not_to set_session(:var).to('other')
+    end
+
+    it 'rejects assigning to another variable' do
+      expect(controller_with_session(var: 'hi')).not_to set_session(:other)
+    end
+
+    it 'accepts assigning nil to another variable' do
+      expect(controller_with_session(var: 'hi')).to set_session(:other).to(nil)
+    end
+
+    it 'accepts assigning false to that variable' do
+      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'
+
+      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'
+
+      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
+        session_hash.each do |key, value|
+          session[key] = value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::SetTheFlashMatcher do
+  it 'fails with unmatchable #to' do
+    expect { set_the_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_the_flash
+    end
+
+    it 'accepts setting the exact flash message' do
+      expect(controller_with_flash(notice: 'hi')).to set_the_flash.to('hi')
+    end
+
+    it 'accepts setting a matched flash message' do
+      expect(controller_with_flash(notice: 'hello')).to set_the_flash.to(/he/)
+    end
+
+    it 'rejects setting a different flash message' do
+      expect(controller_with_flash(notice: 'hi')).
+        not_to set_the_flash.to('other')
+    end
+
+    it 'rejects setting a different pattern' do
+      expect(controller_with_flash(notice: 'hi')).
+        not_to set_the_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_the_flash
+    end
+
+    it 'accepts setting any flash.now message' do
+      expect(controller_with_flash_now).to set_the_flash.now
+    end
+
+    it 'accepts setting the exact flash.now message' do
+      expect(controller_with_flash_now(notice: 'hi')).
+        to set_the_flash.now.to('hi')
+    end
+
+    it 'accepts setting a matched flash.now message' do
+      expect(controller_with_flash_now(notice: 'flasher')).
+        to set_the_flash.now.to(/lash/)
+    end
+
+    it 'rejects setting a different flash.now message' do
+      expect(controller_with_flash_now(notice: 'hi')).
+        not_to set_the_flash.now.to('other')
+    end
+
+    it 'rejects setting a different flash.now pattern' do
+      expect(controller_with_flash_now(notice: 'hi')).
+        not_to set_the_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_the_flash[:notice]
+      expect(controller).to set_the_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_the_flash[:warning]
+    end
+
+    it 'accepts exact flash message of notice' do
+      expect(controller_with_flash(notice: 'one', alert: 'two')).
+        to set_the_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_the_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_the_flash[:notice].to('other')
+    end
+
+    it 'rejects setting a different pattern' do
+      expect(controller_with_flash(notice: 'one', alert: 'two')).
+        not_to set_the_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_response do
+        flash.now[:notice] = 'value'
+        flash[:success] = 'great job'
+      end
+
+      expect(controller).to set_the_flash.now
+      expect(controller).to set_the_flash
+    end
+
+    it 'accepts setting a matched flash.now message' do
+      controller = build_response do
+        flash.now[:notice] = 'value'
+        flash[:success] = 'great job'
+      end
+
+      expect(controller).to set_the_flash.now.to(/value/)
+      expect(controller).to set_the_flash.to(/great/)
+    end
+
+    it 'rejects setting a different flash.now message' do
+      controller = build_response do
+        flash.now[:notice] = 'value'
+        flash[:success] = 'great job'
+      end
+
+      expect(controller).not_to set_the_flash.now.to('other')
+      expect(controller).not_to set_the_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_the_flash
+    end
+  end
+
+  def controller_with_no_flashes
+    build_response
+  end
+
+  def controller_with_flash(flash_hash)
+    build_response do
+      flash_hash.each do |key, value|
+        flash[key] = value
+      end
+    end
+  end
+
+  def controller_with_flash_now(flash_hash = { notice: 'hi' })
+    build_response do
+      flash_hash.each do |key, value|
+        flash.now[key] = value
+      end
+    end
+  end
+end