nimboids-shoulda 2.11.3

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

@@ -0,0 +1,74 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that filter_parameter_logging is set for the specified key.
+      #
+      # Example:
+      #
+      #   it { should filter_param(:password) }
+      def filter_param(key)
+        FilterParamMatcher.new(key)
+      end
+
+      class FilterParamMatcher # :nodoc:
+
+        def initialize(key)
+          @key = key.to_s
+        end
+
+        def matches?(controller)
+          @controller = controller
+          filters_params? && filters_key?
+        end
+
+        def failure_message
+          "Expected #{@key} to be filtered"
+        end
+
+        def negative_failure_message
+          "Did not expect #{@key} to be filtered"
+        end
+
+        def description
+          "filter #{@key}"
+        end
+
+        private
+
+        def filters_params?
+          @controller.respond_to?(:filter_parameters) ||
+            request.respond_to?(:filtered_parameters)
+        end
+
+        def filters_key?
+          filtered_value == '[FILTERED]'
+        end
+
+        def filtered_value
+          if request.respond_to?(:filtered_parameters)
+            filtered_request_value
+          else
+            filtered_controller_value
+          end
+        end
+
+        def filtered_controller_value
+          filtered = @controller.send(:filter_parameters,
+                                      @key.to_s => @key.to_s)
+          filtered[@key.to_s]
+        end
+
+        def filtered_request_value
+          request.env['action_dispatch.request.parameters'] = { @key.to_s => 'value' }
+          request.filtered_parameters[@key.to_s]
+        end
+
+        def request
+          @request ||= ::ActionController::TestRequest.new
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures a controller redirected to the given url.
+      #
+      # Example:
+      #
+      #   it { should redirect_to('http://somewhere.com')  }
+      #   it { should redirect_to(users_path)  }
+      def redirect_to(url_or_description, &block)
+        RedirectToMatcher.new(url_or_description, self, &block)
+      end
+
+      class RedirectToMatcher # :nodoc:
+
+        def initialize(url_or_description, context, &block)
+          if block
+            @url_block = block
+            @location = @url_or_description
+          else
+            @url = url_or_description
+            @location = @url
+          end
+          @context = context
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          redirects_to_url?
+        end
+
+        attr_reader :failure_message, :negative_failure_message
+
+        def description
+          "redirect to #{@location}"
+        end
+
+        private
+
+        def redirects_to_url?
+          @url = @context.instance_eval(&@url_block) if @url_block
+          begin
+            @context.send(:assert_redirected_to, @url)
+            @negative_failure_message = "Didn't expect to redirect to #{@url}"
+            true
+          rescue Test::Unit::AssertionFailedError => error
+            @failure_message = error.message
+            false
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures a controller rendered the given template.
+      #
+      # Example:
+      #
+      #   it { should render_template(:show)  }
+      def render_template(template)
+        RenderTemplateMatcher.new(template, self)
+      end
+
+      class RenderTemplateMatcher # :nodoc:
+
+        def initialize(template, context)
+          @template = template.to_s
+          @context  = context
+        end
+
+        def matches?(controller)
+          @controller = controller
+          renders_template?
+        end
+
+        attr_reader :failure_message, :negative_failure_message
+
+        def description
+          "render template #{@template}"
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        private
+
+        def renders_template?
+          begin
+            @context.send(:assert_template, @template)
+            @negative_failure_message = "Didn't expect to render #{@template}"
+            true
+          rescue Test::Unit::AssertionFailedError => error
+            @failure_message = error.message
+            false
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that the controller rendered with the given layout.
+      #
+      # Example:
+      #
+      #   it { should render_with_layout }
+      #   it { should render_with_layout(:special) }
+      #   it { should_not render_with_layout }
+      def render_with_layout(expected_layout = nil)
+        RenderWithLayout.new(expected_layout)
+      end
+
+      class RenderWithLayout # :nodoc:
+
+        def initialize(expected_layout)
+          @expected_layout = expected_layout.to_s unless expected_layout.nil?
+        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
+
+        def negative_failure_message
+          "Did not expect #{expectation}, but #{result}"
+        end
+
+        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?
+          return true if @expected_layout.nil?
+          rendered_layouts.include?(@expected_layout)
+        end
+
+        def rendered_layouts
+          if recorded_layouts
+            recorded_layouts.keys.compact.map { |layout| layout.sub(%r{^layouts/}, '') }
+          else
+            layout = @controller.response.layout
+            if layout.nil?
+              []
+            else
+              [layout.split('/').last]
+            end
+          end
+        end
+
+        def recorded_layouts
+          if @context
+            @context.instance_variable_get('@layouts')
+          end
+        end
+
+        def expectation
+          "to #{description}"
+        end
+
+        def result
+          if rendered_with_layout?
+            "rendered with " <<
+              rendered_layouts.map { |layout| layout.inspect }.join(", ")
+          else
+            "rendered without a layout"
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures a controller responded with expected 'response' content type.
+      #
+      # You can pass an explicit content type such as 'application/rss+xml'
+      # or its symbolic equivalent :rss
+      # or a regular expression such as /rss/
+      #
+      # Example:
+      #
+      #   it { should respond_with_content_type(:xml)  }
+      #   it { should respond_with_content_type(:csv)  }
+      #   it { should respond_with_content_type(:atom) }
+      #   it { should respond_with_content_type(:yaml) }
+      #   it { should respond_with_content_type(:text) }
+      #   it { should respond_with_content_type('application/rss+xml')  }
+      #   it { should respond_with_content_type(/json/) }
+      def respond_with_content_type(content_type)
+        RespondWithContentTypeMatcher.new(content_type)
+      end
+
+      class RespondWithContentTypeMatcher # :nodoc:
+
+        def initialize(content_type)
+          @content_type = if content_type.is_a?(Symbol)
+            lookup_by_extension(content_type)
+          else
+            content_type
+          end
+        end
+
+        def description
+          "respond with content type of #{@content_type}"
+        end
+
+        def matches?(controller)
+          @controller = controller
+          if @content_type.is_a?(Regexp)
+            response_content_type =~ @content_type
+          else
+            response_content_type == @content_type
+          end
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        protected
+
+        def response_content_type
+          @controller.response.content_type.to_s
+        end
+
+        def lookup_by_extension(extension)
+          Mime::Type.lookup_by_extension(extension.to_s).to_s
+        end
+
+        def expectation
+          "content type to be #{@content_type}, " <<
+          "but was #{response_content_type}"
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures a controller responded with expected 'response' status code.
+      #
+      # You can pass an explicit status number like 200, 301, 404, 500
+      # or its symbolic equivalent :success, :redirect, :missing, :error.
+      # See ActionController::StatusCodes for a full list.
+      #
+      # Example:
+      #
+      #   it { should respond_with(:success)  }
+      #   it { should respond_with(:redirect) }
+      #   it { should respond_with(:missing)  }
+      #   it { should respond_with(:error)    }
+      #   it { should respond_with(501)       }
+      def respond_with(status)
+        RespondWithMatcher.new(status)
+      end
+
+      class RespondWithMatcher # :nodoc:
+
+        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
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        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/action_controller/matchers/route_matcher.rb

@@ -0,0 +1,93 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that requesting +path+ using +method+ routes to +options+.
+      #
+      # If you don't specify a controller, it will use the controller from the
+      # example group.
+      #
+      # +to_param+ is called on the +options+ given.
+      #
+      # Examples:
+      #
+      #   it { should route(:get, "/posts").
+      #                 to(:controller => :posts, :action => :index) }
+      #   it { should route(:get, "/posts/new").to(:action => :new) }
+      #   it { should route(:post, "/posts").to(:action => :create) }
+      #   it { should route(:get, "/posts/1").to(:action => :show, :id => 1) }
+      #   it { should route(:edit, "/posts/1").to(:action => :show, :id => 1) }
+      #   it { should route(:put, "/posts/1").to(:action => :update, :id => 1) }
+      #   it { should route(:delete, "/posts/1").
+      #                 to(:action => :destroy, :id => 1) }
+      #   it { should route(:get, "/users/1/posts/1").
+      #                 to(:action => :show, :id => 1, :user_id => 1) }
+      def route(method, path)
+        RouteMatcher.new(method, path, self)
+      end
+
+      class RouteMatcher # :nodoc:
+
+        def initialize(method, path, context)
+          @method  = method
+          @path    = path
+          @context = context
+        end
+
+        def to(params)
+          @params = params
+          stringify_params!
+          self
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          guess_controller!
+          route_recognized?
+        end
+
+        attr_reader :failure_message, :negative_failure_message
+
+        def description
+          "route #{@method.to_s.upcase} #{@path} to/from #{@params.inspect}"
+        end
+
+        private
+
+        def guess_controller!
+          @params[:controller] ||= @controller.controller_path
+        end
+
+        def stringify_params!
+          @params.each do |key, value|
+            @params[key] = value.is_a?(Array) ? value.collect {|v| v.to_param } : value.to_param
+          end
+        end
+
+        def route_recognized?
+          begin
+            @context.send(:assert_routing,
+                          { :method => @method, :path => @path },
+                          @params)
+
+            @negative_failure_message = "Didn't expect to #{description}"
+            true
+          rescue ::ActionController::RoutingError => error
+            @failure_message = error.message
+            false
+          rescue Test::Unit::AssertionFailedError => error
+            @failure_message = error.message
+            false
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Shoulda # :nodoc:
+  module ActionController # :nodoc:
+    module Matchers
+
+      # Ensures that a session key was set to the expected value.
+      #
+      # Example:
+      #
+      #   it { should set_session(:message) }
+      #   it { should set_session(:user_id).to(@user.id) }
+      #   it { should_not set_session(:user_id) }
+      def set_session(key)
+        SetSessionMatcher.new(key)
+      end
+
+      class SetSessionMatcher # :nodoc:
+
+        def initialize(key)
+          @key = key.to_s
+        end
+
+        def to(value = nil, &block)
+          @value = value
+          @value_block = block
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          @value = @context.instance_eval(&@value_block) if @value_block
+          (assigned_value? && assigned_correct_value?) || cleared_value?
+        end
+
+        def failure_message
+          "Expected #{expectation}, but #{result}"
+        end
+
+        def negative_failure_message
+          "Didn't expect #{expectation}, but #{result}"
+        end
+
+        def description
+          description = "set session variable #{@key.inspect}"
+          description << " to #{@value.inspect}" if defined?(@value)
+          description
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        private
+
+        def assigned_value?
+          !assigned_value.nil?
+        end
+
+        def cleared_value?
+          defined?(@value) && @value.nil? && assigned_value.nil?
+        end
+
+        def assigned_correct_value?
+          return true if @value.nil?
+          assigned_value == @value
+        end
+
+        def assigned_value
+          session[@key]
+        end
+
+        def session
+          if @controller.request.respond_to?(:session)
+            @controller.request.session.to_hash
+          else
+            @controller.response.session.data
+          end
+        end
+
+        def expectation
+          expectation = "session variable #{@key} to be set"
+          expectation << " to #{@value.inspect}" if @value
+          expectation
+        end
+
+        def result
+          if session.empty?
+            "no session variables were set"
+          else
+            "the session was #{session.inspect}"
+          end
+        end
+
+      end
+
+    end
+  end
+end