wycats-merb-core 0.9.8

data/lib/merb-core/test/helpers/route_helper.rb

@@ -0,0 +1,39 @@
+module Merb
+  module Test
+    module RouteHelper
+      include RequestHelper
+      
+      # Mimics the url method available to controllers.
+      #
+      # ==== Parameters
+      # name<~to_sym>:: The name of the URL to generate.
+      # params<Hash>:: Parameters for the route generation.
+      #
+      # ==== Returns
+      # String:: The generated URL.
+      def url(*args)
+        name = args.first.is_a?(Symbol) ? args.shift : :default
+        
+        unless route = Merb::Router.named_routes[name]
+          raise Merb::Router::GenerationError, "Named route not found: #{name}"
+        end
+
+        route.generate(args, @request_params || {})
+      end
+      
+      # ==== Parameters
+      # path<~to_string>:: The URL of the request.
+      # method<~to_sym>:: HTTP request method.
+      # env<Hash>:: Additional parameters for the request.
+      #
+      # ==== Returns
+      # Hash:: A hash containing the controller and action along with any parameters
+      def request_to(path, method = :get, env = {})
+        env[:request_method] ||= method.to_s.upcase
+        env[:request_uri] = path
+        
+        check_request_for_route(build_request({}, env))
+      end
+    end
+  end
+end

data/lib/merb-core/test/helpers/view_helper.rb

@@ -0,0 +1,121 @@
+module Merb
+  module Test
+    module ViewHelper
+
+      # Small utility class for working with the Hpricot parser class
+      class DocumentOutput
+
+        # ==== Parameters
+        # response_body<String>:: The response body to parse with Hpricot.
+        def initialize(response_body)
+          @parser = Hpricot.parse(response_body)
+        end
+
+        # ==== Parameters
+        # css_query<String>::
+        #   A CSS query to find the element for, e.g. "ul.links".
+        #
+        # ==== Returns
+        # String:: The content of the first tag matching the query.
+        def content_for(css_query)
+          match = @parser.search(css_query).first
+          match.inner_text unless match.nil?
+        end
+
+        # ==== Parameters
+        # css_query<String>:: A CSS query to find the elements for.
+        #
+        # ==== Returns
+        # Array[String]:: Content of all tags matching the query.
+        def content_for_all(css_query)
+          matches = @parser.search(css_query).collect{|ele| ele.inner_text}
+        end
+
+        # ==== Parameters
+        # css_query<String>:: A CSS query to find the elements for.
+        #
+        # ==== Returns
+        # Hpricot::Elements:: All tags matching the query.
+        def [](css_query)
+          @parser.search(css_query)
+        end
+      end
+
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the element for.
+      # output<DocumentOutput>::
+      #   The output to look for the element in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # String:: The content of the first tag matching the query.
+      def tag(css_query, output = process_output)
+        output.content_for(css_query)
+      end
+
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the elements for.
+      # output<DocumentOutput>::
+      #   The output to look for the element in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # Array[String]:: Content of all tags matching the query.
+      def tags(css_query, output = process_output)
+        output.content_for_all(css_query)
+      end
+
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the element for.
+      # output<DocumentOutput>::
+      #   The output to look for the element in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # Hpricot::Elem:: The first tag matching the query.
+      def element(css_query, output = process_output)
+        output[css_query].first
+      end
+  
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the elements for.
+      # output<DocumentOutput>::
+      #   The output to look for the elements in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # Array[Hpricot::Elem]:: All tags matching the query.
+      def elements(css_query, output = process_output)
+        Hpricot::Elements[*css_query.to_s.split(",").map{|s| s.strip}.map do |query|
+          output[query]
+        end.flatten]
+      end
+
+      # ==== Parameters
+      # css_query<String>:: A CSS query to find the elements for.
+      # text<String, Regexp>:: A pattern to match tag contents for.
+      # output<DocumentOutput>::
+      #   The output to look for the elements in. Defaults to process_output. 
+      #
+      # ==== Returns
+      # Array[Hpricot::Elem]:: All tags matching the query and pattern.
+      def get_elements(css_query, text, output = nil)
+        els = elements(*[css_query, output].compact)
+        case text
+          when String then els.reject {|t| !t.contains?(text) }
+          when Regexp then els.reject {|t| !t.matches?(text) }
+          else []
+        end
+      end
+  
+      protected
+
+        # ==== Returns
+        # DocumentOutput:: Document output from the response body.
+        def process_output
+          return @output unless @output.nil?
+          return @output = DocumentOutput.new(@response_output) unless @response_output.nil?
+          
+          raise "The response output was not in its usual places, please provide the output" if @controller.nil? || @controller.body.empty?
+          @response_output = @controller.body
+          @output = DocumentOutput.new(@controller.body)
+        end
+    end
+  end
+end

data/lib/merb-core/test/matchers.rb

@@ -0,0 +1,9 @@
+module Merb::Test::Rspec; end
+
+require "merb-core/test/matchers/controller_matchers"
+require "merb-core/test/matchers/route_matchers"
+require "merb-core/test/matchers/view_matchers"
+
+Merb::Test::ControllerHelper.send(:include, Merb::Test::Rspec::ControllerMatchers)
+Merb::Test::RouteHelper.send(:include, Merb::Test::Rspec::RouteMatchers)
+Merb::Test::ViewHelper.send(:include, Merb::Test::Rspec::ViewMatchers)

data/lib/merb-core/test/matchers/controller_matchers.rb

@@ -0,0 +1,351 @@
+module Merb::Test::Rspec::ControllerMatchers
+
+  class BeRedirect
+    # ==== Parameters
+    # target<Fixnum, ~status>::
+    #   Either the status code or a controller with a status code.
+    #
+    # ==== Returns
+    # Boolean:: True if the status code is in the range 300..305 or 307.
+    def matches?(target)
+      @target = target
+      [307, *(300..305)].include?(target.respond_to?(:status) ? target.status : target)
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected#{inspect_target} to redirect"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected#{inspect_target} not to redirect"
+    end
+
+    # ==== Returns
+    # String:: The controller and action name.
+    def inspect_target
+      " #{@target.controller_name}##{@target.action_name}" if @target.respond_to?(:controller_name) && @target.respond_to?(:action_name)
+    end
+  end
+
+  class RedirectTo
+
+    # === Parameters
+    # String:: The expected location
+    # Hash:: Optional hash of options (currently only :message)
+    def initialize(expected, options = {})
+      @expected = expected
+      @options  = options
+    end
+
+    # ==== Parameters
+    # target<Merb::Controller>:: The controller to match
+    #
+    # ==== Returns
+    # Boolean::
+    #   True if the controller status is redirect and the locations match.
+    def matches?(target)
+      @target, @location = target, target.headers['Location']
+      @redirected = BeRedirect.new.matches?(target.status)
+
+      if @options[:message]
+        msg = Merb::Request.escape([Marshal.dump(@options[:message])].pack("m"))
+        @expected << "?_message=#{msg}"
+      end
+      
+      @location == @expected && @redirected
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      msg = "expected #{inspect_target} to redirect to <#{@expected}>, but "
+      if @redirected
+        msg << "was <#{target_location}>"
+      else
+        msg << "there was no redirection"
+      end
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected #{inspect_target} not to redirect to <#{@expected}>, but did anyway"
+    end
+
+    # ==== Returns
+    # String:: The controller and action name.
+    def inspect_target
+      "#{@target.controller_name}##{@target.action_name}"
+    end
+
+    # ==== Returns
+    # String:: Either the target's location header or the target itself.
+    def target_location
+      @target.respond_to?(:headers) ? @target.headers['Location'] : @target
+    end
+  end
+
+  class BeSuccess
+
+    # ==== Parameters
+    # target<Fixnum, ~status>::
+    #   Either the status code or a controller with a status code.
+    #
+    # ==== Returns
+    # Boolean:: True if the status code is in the range 200..207.
+    def matches?(target)
+      @target = target
+      (200..207).include?(status_code)
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected#{inspect_target} to be successful but was #{status_code}"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected#{inspect_target} not to be successful but it was #{status_code}"
+    end
+
+    # ==== Returns
+    # String:: The controller and action name.
+    def inspect_target
+      " #{@target.controller_name}##{@target.action_name}" if @target.respond_to?(:controller_name) && @target.respond_to?(:action_name)
+    end
+
+    # ==== Returns
+    # Fixnum:: Either the target's status or the target itself.
+    def status_code
+      @target.respond_to?(:status) ? @target.status : @target
+    end
+  end
+
+  class BeMissing
+
+    # ==== Parameters
+    # target<Fixnum, ~status>::
+    #   Either the status code or a controller with a status code.
+    #
+    # ==== Returns
+    # Boolean:: True if the status code is in the range 400..417.
+    def matches?(target)
+      @target = target
+      (400..417).include?(status_code)
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected#{inspect_target} to be missing but was #{status_code}"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected#{inspect_target} not to be missing but it was #{status_code}"
+    end
+
+    # ==== Returns
+    # String:: The controller and action name.
+    def inspect_target
+      " #{@target.controller_name}##{@target.action_name}" if @target.respond_to?(:controller_name) && @target.respond_to?(:action_name)
+    end
+
+    # ==== Returns
+    # Fixnum:: Either the target's status or the target itself.
+    def status_code
+      @target.respond_to?(:status) ? @target.status : @target
+    end
+  end
+
+  class BeError
+    def initialize(expected)
+      @expected = expected
+    end
+    
+    def matches?(target)
+      @target = target
+      @target.request.exceptions &&
+        @target.request.exceptions.first.is_a?(@expected)
+    end
+    
+    def failure_message
+      "expected #{@target} to be a #{@expected} error, but it was " << 
+        @target.request.exceptions.first.inspect
+    end
+    
+    def negative_failure_message
+      "expected #{@target} not to be a #{@expected} error, but it was"
+    end
+  end
+
+  class Provide
+
+    # === Parameters
+    # expected<Symbol>:: A format to check
+    def initialize(expected)
+      @expected = expected
+    end
+
+    # ==== Parameters
+    # target<Symbol>::
+    #   A ControllerClass or controller_instance
+    #
+    # ==== Returns
+    # Boolean:: True if the formats provided by the target controller/class include the expected
+    def matches?(target)
+      @target = target
+      provided_formats.include?( @expected )
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected #{@target.name} to provide #{@expected}, but it doesn't"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected #{@target.name} not to provide #{@expected}, but it does"
+    end
+
+    # ==== Returns
+    # Array[Symbol]:: The formats the expected provides
+    def provided_formats
+      @target.class_provided_formats
+    end
+  end
+
+  # Passes if the target was redirected, or the target is a redirection (300
+  # level) response code.
+  #
+  # ==== Examples
+  #   # Passes if the controller was redirected
+  #   controller.should redirect
+  #
+  #   # Also works if the target is the response code
+  #   controller.status.should redirect
+  #
+  # ==== Notes
+  # valid HTTP Redirection codes:
+  # * 300: Multiple Choices
+  # * 301: Moved Permanently
+  # * 302: Moved Temporarily (HTTP/1.0)
+  # * 302: Found (HTTP/1.1)
+  # * 303: See Other (HTTP/1.1)
+  # * 304: Not Modified
+  # * 305: Use Proxy
+  # * 307: Temporary Redirect
+  #--
+  # status codes based on: http://cheat.errtheblog.com/s/http_status_codes/
+  def redirect
+    BeRedirect.new
+  end
+
+  alias_method :be_redirection, :redirect
+
+  # Passes if the target was redirected to the expected location.
+  #
+  # ==== Paramters
+  # expected<String>:: A relative or absolute url.
+  #
+  # ==== Examples
+  #   # Passes if the controller was redirected to http://example.com/
+  #   controller.should redirect_to('http://example.com/')
+  def redirect_to(expected, options = {})
+    RedirectTo.new(expected, options)
+  end
+
+  alias_method :be_redirection_to, :redirect_to
+
+  # Passes if the request that generated the target was successful, or the
+  # target is a success (200 level) response code.
+  #
+  # ==== Examples
+  #   # Passes if the controller call was successful
+  #   controller.should respond_successfully
+  #
+  #   # Also works if the target is the response code
+  #   controller.status.should respond_successfully
+  #
+  # ==== Notes
+  # valid HTTP Success codes:
+  # * 200: OK
+  # * 201: Created
+  # * 202: Accepted
+  # * 203: Non-Authoritative Information
+  # * 204: No Content
+  # * 205: Reset Content
+  # * 206: Partial Content
+  # * 207: Multi-Status
+  #--
+  # status codes based on: http://cheat.errtheblog.com/s/http_status_codes/
+  def respond_successfully
+    BeSuccess.new
+  end
+
+  alias_method :be_successful, :respond_successfully
+
+  # Passes if the request that generated the target was missing, or the target
+  # is a client-side error (400 level) response code.
+  #
+  # ==== Examples
+  #   # Passes if the controller call was unknown or not understood
+  #   controller.should be_missing
+  #
+  #   # Also passes if the target is a response code
+  #   controller.status.should be_missing
+  #
+  # ==== Notes
+  # valid HTTP Client Error codes:
+  # * 400: Bad Request
+  # * 401: Unauthorized
+  # * 402: Payment Required
+  # * 403: Forbidden
+  # * 404: Not Found
+  # * 405: Method Not Allowed
+  # * 406: Not Acceptable
+  # * 407: Proxy Authentication Required
+  # * 408: Request Timeout
+  # * 409: Conflict
+  # * 410: Gone
+  # * 411: Length Required
+  # * 412: Precondition Failed
+  # * 413: Request Entity Too Large
+  # * 414: Request-URI Too Long
+  # * 415: Unsupported Media Type
+  # * 416: Requested Range Not Satisfiable
+  # * 417: Expectation Failed
+  # * 422: Unprocessable Entity
+  #--
+  # status codes based on: http://cheat.errtheblog.com/s/http_status_codes/
+  def be_missing
+    BeMissing.new
+  end
+  
+  def be_error(expected)
+    BeError.new(expected)
+  end
+
+  alias_method :be_client_error, :be_missing
+
+  # Passes if the controller actually provides the target format
+  #
+  # === Parameters
+  # expected<Symbol>:: A format to check
+  #
+  # ==== Examples
+  #   ControllerClass.should provide( :html )
+  #   controller_instance.should provide( :xml )
+  def provide( expected )
+    Provide.new( expected )
+  end
+end