merb-core 0.9.2

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

@@ -0,0 +1,136 @@
+module Merb::Test::Rspec::RouteMatchers
+
+  class RouteToMatcher
+
+    # ==== Parameters
+    # klass_or_name<Class, String>::
+    #   The controller class or class name to match routes for.
+    # action<~to_s>:: The name of the action to match routes for.
+    def initialize(klass_or_name, action)
+      @expected_controller = Class === klass_or_name ? klass_or_name.name : klass_or_name
+      @expected_action = action.to_s
+    end
+
+    # ==== Parameters
+    # target<Hash>:: The route parameters to match.
+    #
+    # ==== Returns
+    # Boolean:: True if the controller action and parameters match.
+    def matches?(target)
+      @target_env = target.dup
+      @target_controller, @target_action = @target_env.delete(:controller).to_s, @target_env.delete(:action).to_s
+      
+      @target_controller = "#{target.delete(:namespace)}::#{@target_controller}" if target.has_key?(:namespace)
+      
+      @expected_controller.snake_case == @target_controller.snake_case && @expected_action == @target_action && match_parameters(@target_env)
+    end
+
+    # ==== Parameters
+    # target<Hash>:: The route parameters to match.
+    #
+    # ==== Returns
+    # Boolean::
+    #   True if the parameter matcher created with #with matches or if no
+    #   parameter matcher exists.
+    def match_parameters(target)
+      @parameter_matcher.nil? ? true : @parameter_matcher.matches?(target)
+    end
+
+    # Creates a new paramter matcher.
+    #
+    # ==== Parameters
+    # parameters<Hash, ~to_param>:: The parameters to match.
+    #
+    # ==== Returns
+    # RouteToMatcher:: This matcher.
+    #
+    # ==== Alternatives
+    # If parameters is an object, then a new expected hash will be constructed
+    # with the key :id set to parameters.to_param.
+    def with(parameters)
+      @paramter_matcher = ParameterMatcher.new(parameters)
+      
+      self
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected the request to route to #{camelize(@expected_controller)}##{@expected_action}, but was #{camelize(@target_controller)}##{@target_action}"
+    end
+  
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected the request not to route to #{camelize(@expected_controller)}##{@expected_action}, but it did"
+    end
+
+    # ==== Parameters
+    # word<~to_s>:: The word to camelize.
+    #
+    # ==== Returns
+    # String:: The word camelized.
+    def camelize(word)
+      word.to_s.gsub(/^[a-z]|(\_[a-z])/) { |a| a.upcase.gsub("_", "") }
+    end
+  end
+
+  class ParameterMatcher
+
+    # ==== Parameters
+    # hash_or_object<Hash, ~to_param>:: The parameters to match.
+    #
+    # ==== Alternatives
+    # If hash_or_object is an object, then a new expected hash will be
+    # constructed with the key :id set to hash_or_object.to_param.
+    def initialize(hash_or_object)
+      @expected = {}
+      case hash_or_object
+      when Hash then @expected = hash_or_object
+      else @expected[:id] = hash_or_object.to_param
+      end
+    end
+
+    # ==== Parameters
+    # parameter_hash<Hash>:: The route parameters to match.
+    #
+    # ==== Returns
+    # Boolean:: True if the route parameters match the expected ones.
+    def matches?(parameter_hash)
+      @actual = parameter_hash.dup.except(:controller, :action)
+    
+      @expected.all? {|(k, v)| @actual.has_key?(k) && @actual[k] == v}
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected the route to contain parameters #{@expected.inspect}, but instead contained #{@actual.inspect}"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected the route not to contain parameters #{@expected.inspect}, but it did"
+    end
+  end
+
+  # Passes when the actual route parameters match the expected controller class
+  # and controller action. Exposes a +with+ method for specifying parameters.
+  #
+  # ==== Parameters
+  # klass_or_name<Class, String>::
+  #   The controller class or class name to match routes for.
+  # action<~to_s>:: The name of the action to match routes for.
+  #
+  # ==== Example
+  #   # Passes if a GET request to "/" is routed to the Widgets controller's
+  #   # index action.
+  #   request_to("/", :get).should route_to(Widgets, :index)
+  #
+  #   # Use the 'with' method for parameter checks
+  #   request_to("/123").should route_to(widgets, :show).with(:id => "123")
+  def route_to(klass_or_name, action)
+    RouteToMatcher.new(klass_or_name, action)
+  end
+end

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

@@ -0,0 +1,293 @@
+module Merb::Test::Rspec::ViewMatchers
+  class HaveSelector
+
+    # ==== Parameters
+    # expected<String>:: The string to look for.
+    def initialize(expected)
+      @expected = expected
+    end
+
+    # ==== Parameters
+    # stringlike<Hpricot::Elem, StringIO, String>:: The thing to search in.
+    #
+    # ==== Returns
+    # Boolean:: True if there was at least one match.
+    def matches?(stringlike)
+      @document = case stringlike
+      when Hpricot::Elem
+        stringlike
+      when StringIO
+        Hpricot.parse(stringlike.string)
+      else
+        Hpricot.parse(stringlike)
+      end
+      !@document.search(@expected).empty?
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected following text to match selector #{@expected}:\n#{@document}"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected following text to not match selector #{@expected}:\n#{@document}"
+    end
+  end
+
+  class MatchTag
+
+    # ==== Parameters
+    # name<~to_s>:: The name of the tag to look for.
+    # attrs<Hash>:: Attributes to look for in the tag (see below).
+    #
+    # ==== Options (attrs)
+    # :content<String>:: Optional content to match.
+    def initialize(name, attrs)
+      @name, @attrs = name, attrs
+      @content = @attrs.delete(:content)
+    end
+
+    # ==== Parameters
+    # target<String>:: The string to look for the tag in.
+    #
+    # ==== Returns
+    # Boolean:: True if the tag matched.
+    def matches?(target)
+      @errors = []
+      unless target.include?("<#{@name}")
+        @errors << "Expected a <#{@name}>, but was #{target}"
+      end
+      @attrs.each do |attr, val|
+        unless target.include?("#{attr}=\"#{val}\"")
+          @errors << "Expected #{attr}=\"#{val}\", but was #{target}"
+        end
+      end
+      if @content
+        unless target.include?(">#{@content}<")
+          @errors << "Expected #{target} to include #{@content}"
+        end
+      end
+      @errors.size == 0
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      @errors[0]
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "Expected not to match against <#{@name} #{@attrs.map{ |a,v| "#{a}=\"#{v}\"" }.join(" ")}> tag, but it matched"
+    end
+  end
+
+  class NotMatchTag
+
+    # === Parameters
+    # attrs<Hash>:: A set of attributes that must not be matched.
+    def initialize(attrs)
+      @attrs = attrs
+    end
+
+    # ==== Parameters
+    # target<String>:: The target to look for the match in.
+    #
+    # ==== Returns
+    # Boolean:: True if none of the attributes were matched.
+    def matches?(target)
+      @errors = []
+      @attrs.each do |attr, val|
+        if target.include?("#{attr}=\"#{val}\"")
+          @errors << "Should not include #{attr}=\"#{val}\", but was #{target}"
+        end
+      end
+      @errors.size == 0
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      @errors[0]
+    end
+  end
+
+  class HasTag
+
+    # ==== Parameters
+    # tag<~to_s>:: The tag to look for.
+    # attributes<Hash>:: Attributes for the tag (see below).
+    def initialize(tag, attributes = {})
+      @tag, @attributes = tag, attributes
+      @id, @class = @attributes.delete(:id), @attributes.delete(:class)
+    end
+
+    # ==== Parameters
+    # stringlike<Hpricot::Elem, StringIO, String>:: The thing to search in.
+    # &blk:: An optional block for searching in child elements using with_tag.
+    #
+    # ==== Returns
+    # Boolean:: True if there was at least one match.
+    def matches?(stringlike, &blk)
+      @document = case stringlike
+      when Hpricot::Elem
+        stringlike
+      when StringIO
+        Hpricot.parse(stringlike.string)
+      else
+        Hpricot.parse(stringlike)
+      end
+
+      if block_given?
+        !@document.search(selector).select do |ele|
+          begin
+            blk.call(ele)
+          rescue Spec::Expectations::ExpectationNotMetError
+            false
+          end
+        end.empty?
+      else
+        !@document.search(selector).empty?
+      end
+    end
+
+    # ==== Returns
+    # String:: The complete selector for element queries.
+    def selector
+      @selector = "//#{@tag}#{id_selector}#{class_selector}"
+      @selector << @attributes.map{|a, v| "[@#{a}=\"#{v}\"]"}.join
+
+      @selector << @inner_has_tag.selector unless @inner_has_tag.nil?
+
+      @selector
+    end
+
+    # ==== Returns
+    # String:: ID selector for use in element queries.
+    def id_selector
+      "##{@id}" if @id
+    end
+
+    # ==== Returns
+    # String:: Class selector for use in element queries.
+    def class_selector
+      ".#{@class}" if @class
+    end
+
+    # ==== Returns
+    # String:: The failure message.
+    def failure_message
+      "expected following output to contain a #{tag_for_error} tag:\n#{@document}"
+    end
+
+    # ==== Returns
+    # String:: The failure message to be displayed in negative matches.
+    def negative_failure_message
+      "expected following output to omit a #{tag_for_error} tag:\n#{@document}"
+    end
+    
+    # ==== Returns
+    # String:: The tag used in failure messages.
+    def tag_for_error
+      "#{inner_failure_message}<#{@tag}#{id_for_error}#{class_for_error}#{attributes_for_error}>"
+    end
+
+    # ==== Returns
+    # String::
+    #   The failure message to be displayed in negative matches within the
+    #   have_tag block.
+    def inner_failure_message
+      "#{@inner_has_tag.tag_for_error} tag within a " unless @inner_has_tag.nil?
+    end
+
+    # ==== Returns
+    # String:: ID for the error tag.
+    def id_for_error
+      " id=\"#{@id}\"" unless @id.nil?
+    end
+
+    # ==== Returns
+    # String:: Class for the error tag.
+    def class_for_error
+      " class=\"#{@class}\"" unless @class.nil?
+    end
+
+    # ==== Returns
+    # String:: Class for the error tag.
+    def attributes_for_error
+      @attributes.map{|a,v| " #{a}=\"#{v}\""}.join
+    end
+
+    # Search for a child tag within a have_tag block.
+    #
+    # ==== Parameters
+    # tag<~to_s>:: The tag to look for.
+    # attributes<Hash>:: Attributes for the tag (see below).
+    def with_tag(name, attrs={})
+      @inner_has_tag = HasTag.new(name, attrs)
+    end
+  end
+
+  # ==== Parameters
+  # name<~to_s>:: The name of the tag to look for.
+  # attrs<Hash>:: Attributes to look for in the tag (see below).
+  #
+  # ==== Options (attrs)
+  # :content<String>:: Optional content to match.
+  #
+  # ==== Returns
+  # MatchTag:: A new match tag matcher.
+  def match_tag(name, attrs={})
+    MatchTag.new(name, attrs)
+  end
+
+  # ==== Parameters
+  # attrs<Hash>:: A set of attributes that must not be matched.
+  #
+  # ==== Returns
+  # NotMatchTag:: A new not match tag matcher.
+  def not_match_tag(attrs)
+    NotMatchTag.new(attrs)
+  end
+
+  # ==== Parameters
+  # expected<String>:: The string to look for.
+  #
+  # ==== Returns
+  # HaveSelector:: A new have selector matcher.
+  def have_selector(expected)
+    HaveSelector.new(expected)
+  end
+  alias_method :match_selector, :have_selector
+
+  # RSpec matcher to test for the presence of tags.
+  #
+  # ==== Parameters
+  # tag<~to_s>:: The name of the tag.
+  # attributes<Hash>:: Tag attributes.
+  #
+  # ==== Returns
+  # HasTag:: A new has tag matcher.
+  #
+  # ==== Examples
+  #   # Check for <div>
+  #   body.should have_tag("div")
+  #
+  #   # Check for <span id="notice">
+  #   body.should have_tag("span", :id => :notice)
+  #
+  #   # Check for <h1 id="foo" class="bar">
+  #   body.should have_tag(:h2, :class => "bar", :id => "foo")
+  #
+  #   # Check for <div attr="val">
+  #   body.should have_tag(:div, :attr => :val)
+  def have_tag(tag, attributes = {})
+    HasTag.new(tag, attributes)
+  end
+
+  alias_method :with_tag, :have_tag
+end

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

@@ -0,0 +1,38 @@
+require 'open3'
+
+# Runs specs in all files matching the file pattern.
+#
+# ==== Parameters
+# globs<String, Array[String]>:: File patterns to look for.
+# spec_cmd<~to_s>:: The spec command. Defaults to "spec".
+def run_specs(globs, spec_cmd='spec')
+  require "optparse"
+  require "spec"
+  globs = globs.is_a?(Array) ? globs : [globs]
+  examples, failures, errors, pending = 0, 0, 0, 0
+  globs.each do |glob|
+    Dir[glob].each do |spec|
+      response = Open3.popen3("#{spec_cmd} #{File.expand_path(spec)} -f s -c") do |i,o,e|
+        while out = o.gets
+          STDOUT.puts out
+          STDOUT.flush
+          if out =~ /\d+ example/
+            e, f, p = out.match(/(\d+) examples?, (\d+) failures?(?:, (\d+) pending?)?/)[1..-1]
+            examples += e.to_i; failures += f.to_i; pending += p.to_i          
+          end
+        end
+        errors += 1 if e.is_a?(IO)
+        STDOUT.puts e.read if e.is_a?(IO)
+      end
+    end
+  end
+  puts
+  puts "*** TOTALS ***"
+  if failures == 0
+    print "\e[32m"
+  else
+    print "\e[31m"
+  end
+  puts "#{examples} examples, #{failures} failures, #{errors} errors, #{pending} pending"
+  print "\e[0m"  
+end