webrat 0.2.0 → 0.3.0

data/lib/webrat/core/label.rb

@@ -0,0 +1,18 @@
+module Webrat
+  class Label #:nodoc:
+    
+    def initialize(field, element)
+      @field    = field
+      @element  = element
+    end
+    
+    def matches_text?(label_text)
+      text =~ /^\W*#{Regexp.escape(label_text.to_s)}\b/i
+    end
+    
+    def text
+      @element.inner_text
+    end
+    
+  end
+end

data/lib/webrat/core/link.rb

@@ -0,0 +1,101 @@
+require "webrat/core_extensions/blank"
+
+module Webrat
+  class Link #:nodoc:
+    
+    def initialize(session, element)
+      @session  = session
+      @element  = element
+    end
+    
+    def click(options = {})
+      method = options[:method] || http_method
+      return if href =~ /^#/ && method == :get
+      
+      options[:javascript] = true if options[:javascript].nil?
+      
+      if options[:javascript]
+        @session.request_page(absolute_href, method, data)
+      else
+        @session.request_page(absolute_href, :get, {})
+      end
+    end
+    
+    def matches_text?(link_text)
+      html = text.gsub(' ',' ')
+      
+      if link_text.is_a?(Regexp)
+        matcher = link_text
+      else
+        matcher = /#{Regexp.escape(link_text.to_s)}/i
+      end
+      
+      html =~ matcher || title =~ matcher
+    end
+    
+    def text
+      @element.inner_html
+    end
+    
+  protected
+  
+    def data
+      authenticity_token.blank? ? {} : {"authenticity_token" => authenticity_token}
+    end
+
+    def title
+      @element['title']
+    end
+
+    def href
+      @element["href"]
+    end
+
+    def absolute_href
+      if href =~ /^\?/
+        "#{@session.current_url}#{href}"
+      elsif href !~ %r{^https?://www.example.com(/.*)} && (href !~ /^\//)
+        "#{@session.current_url}/#{href}"
+      else
+        href
+      end
+    end
+    
+    def authenticity_token
+      return unless onclick && onclick.include?("s.setAttribute('name', 'authenticity_token');") &&
+        onclick =~ /s\.setAttribute\('value', '([a-f0-9]{40})'\);/
+      $LAST_MATCH_INFO.captures.first
+    end
+    
+    def onclick
+      @element["onclick"]
+    end
+    
+    def http_method
+      if !onclick.blank? && onclick.include?("f.submit()")
+        http_method_from_js_form
+      else
+        :get
+      end
+    end
+
+    def http_method_from_js_form
+      if onclick.include?("m.setAttribute('name', '_method')")
+        http_method_from_fake_method_param
+      else
+        :post
+      end
+    end
+
+    def http_method_from_fake_method_param
+      if onclick.include?("m.setAttribute('value', 'delete')")
+        :delete
+      elsif onclick.include?("m.setAttribute('value', 'put')")
+        :put
+      else
+        raise "No HTTP method for _method param in #{onclick.inspect}"
+      end
+    end
+
+  end
+end

data/lib/webrat/core/locators.rb

@@ -0,0 +1,92 @@
+require "webrat/core_extensions/detect_mapped"
+
+module Webrat
+  module Locators
+
+    def field(*args)
+      # This is the default locator strategy
+      find_field_with_id(*args) ||
+      find_field_named(*args)   ||
+      field_labeled(*args)      ||
+      flunk("Could not find field: #{args.inspect}")
+    end
+    
+    def field_labeled(label, *field_types)
+      find_field_labeled(label, *field_types) ||
+      flunk("Could not find field labeled #{label.inspect}")
+    end
+
+    def field_named(name, *field_types)
+      find_field_named(name, *field_types) ||
+      flunk("Could not find field named #{name.inspect}")
+    end
+    
+    def field_with_id(id, *field_types)
+      find_field_with_id(id, *field_types) ||
+      flunk("Could not find field with id #{id.inspect}")
+    end
+    
+    def find_field_labeled(label, *field_types) #:nodoc:
+      forms.detect_mapped do |form|
+        form.field_labeled(label, *field_types)
+      end
+    end
+    
+    def find_field_named(name, *field_types) #:nodoc:
+      forms.detect_mapped do |form|
+        form.field_named(name, *field_types)
+      end
+    end
+    
+    def find_field_with_id(id, *field_types) #:nodoc:
+      forms.detect_mapped do |form|
+        form.field_with_id(id, *field_types)
+      end
+    end
+    
+    def find_select_option(option_text, id_or_name_or_label) #:nodoc:
+      if id_or_name_or_label
+        field = field(id_or_name_or_label, SelectField)
+        return field.find_option(option_text)
+      else
+        select_option = forms.detect_mapped do |form|
+          form.find_select_option(option_text)
+        end
+        
+        return select_option if select_option
+      end
+        
+      flunk("Could not find option #{option_text.inspect}")
+    end
+    
+    def find_button(value) #:nodoc:
+      button = forms.detect_mapped do |form|
+        form.find_button(value)
+      end
+      
+      if button
+        return button
+      else
+        flunk("Could not find button #{value.inspect}")
+      end
+    end
+    
+    def find_area(area_name) #:nodoc:
+      areas.detect { |area| area.matches_text?(area_name) } ||
+      flunk("Could not find area with name #{area_name}")
+    end
+    
+    def find_link(text) #:nodoc:
+      matching_links = links.select do |possible_link|
+        possible_link.matches_text?(text)
+      end
+      
+      if matching_links.any?
+        matching_links.min { |a, b| a.text.length <=> b.text.length }
+      else
+        flunk("Could not find link with text #{text.inspect}")
+      end
+    end
+    
+  end
+end

data/lib/webrat/core/logging.rb

@@ -0,0 +1,25 @@
+module Webrat
+  module Logging #:nodoc:
+
+    def warn_log(message) # :nodoc:
+      return unless logger
+      logger.warn message
+    end
+    
+    def debug_log(message) # :nodoc:
+      return unless logger
+      logger.debug message
+    end
+
+    def logger # :nodoc:
+      if defined? RAILS_DEFAULT_LOGGER
+        RAILS_DEFAULT_LOGGER
+      elsif defined? Merb
+        Merb.logger        
+      else
+        nil
+      end
+    end
+  
+  end
+end

data/lib/webrat/core/matchers.rb

@@ -0,0 +1,4 @@
+require "webrat/core/matchers/have_xpath"
+require "webrat/core/matchers/have_selector"
+require "webrat/core/matchers/have_tag"
+require "webrat/core/matchers/have_content"

data/lib/webrat/core/matchers/have_content.rb

@@ -0,0 +1,94 @@
+module Webrat
+  module Matchers
+  
+    class HasContent #:nodoc:
+      def initialize(content)
+        @content = content
+      end
+      
+      def matches?(stringlike)
+        if defined?(Nokogiri::XML)
+          matches_nokogiri?(stringlike)
+        else
+          matches_rexml?(stringlike)
+        end
+      end
+    
+      def matches_rexml?(stringlike)
+        @document = rexml_document(stringlike)
+        @element = @document.inner_text
+      
+        case @content
+        when String
+          @element.include?(@content)
+        when Regexp
+          @element.match(@content)
+        end
+      end
+    
+      def matches_nokogiri?(stringlike)
+        @document = Webrat.nokogiri_document(stringlike)
+        @element = @document.inner_text
+      
+        case @content
+        when String
+          @element.include?(@content)
+        when Regexp
+          @element.match(@content)
+        end
+      end
+    
+      def rexml_document(stringlike)
+        stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
+        
+        case stringlike
+        when REXML::Document
+          stringlike.root
+        when REXML::Node
+          stringlike
+        when StringIO, String
+          begin
+            REXML::Document.new(stringlike.to_s).root
+          rescue REXML::ParseException => e
+            if e.message.include?("second root element")
+              REXML::Document.new("<fake-root-element>#{stringlike}</fake-root-element>").root
+            else
+              raise e
+            end
+          end
+        end
+      end
+      
+      # ==== Returns
+      # String:: The failure message.
+      def failure_message
+        "expected the following element's content to #{content_message}:\n#{@element}"
+      end
+
+      # ==== Returns
+      # String:: The failure message to be displayed in negative matches.
+      def negative_failure_message
+        "expected the following element's content to not #{content_message}:\n#{@element}"
+      end
+    
+      def content_message
+        case @content
+        when String
+          "include \"#{@content}\""
+        when Regexp
+          "match #{@content.inspect}"
+        end
+      end
+    end
+    
+    # Matches the contents of an HTML document with
+    # whatever string is supplied
+    #
+    # ---
+    # @api public
+    def contain(content)
+      HasContent.new(content)
+    end
+    
+  end
+end

data/lib/webrat/core/matchers/have_selector.rb

@@ -0,0 +1,39 @@
+module Webrat
+  module Matchers
+    
+    class HaveSelector < HaveXpath #:nodoc:
+
+      # ==== 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
+    
+      def query
+        Nokogiri::CSS::Parser.parse(*super).map { |ast| ast.to_xpath }
+      end
+  
+    end
+    
+    # Matches HTML content against a CSS 3 selector.
+    #
+    # ==== Parameters
+    # expected<String>:: The CSS selector to look for.
+    #
+    # ==== Returns
+    # HaveSelector:: A new have selector matcher.
+    # ---
+    # @api public
+    def have_selector(expected)
+      HaveSelector.new(expected)
+    end
+    alias_method :match_selector, :have_selector
+    
+  end
+end

data/lib/webrat/core/matchers/have_tag.rb

@@ -0,0 +1,58 @@
+module Webrat
+  
+  module HaveTagMatcher
+
+    class HaveTag < ::Webrat::Matchers::HaveSelector #:nodoc:
+
+      # ==== Returns
+      # String:: The failure message.
+      def failure_message
+        "expected following output to contain a #{tag_inspect} 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_inspect}:\n#{@document}"
+      end
+
+      def tag_inspect
+        options = @expected.last.dup
+        content = options.delete(:content)
+
+        html = "<#{@expected.first}"
+        options.each do |k,v|
+          html << " #{k}='#{v}'"
+        end
+
+        if content
+          html << ">#{content}</#{@expected.first}>"
+        else
+          html << "/>"
+        end
+
+        html
+      end
+
+      def query
+        options  = @expected.last.dup
+        selector = @expected.first.to_s
+
+        selector << ":contains('#{options.delete(:content)}')" if options[:content]
+
+        options.each do |key, value|
+          selector << "[#{key}='#{value}']"
+        end
+
+        Nokogiri::CSS::Parser.parse(selector).map { |ast| ast.to_xpath }
+      end
+
+    end
+
+    def have_tag(name, attributes = {})
+      HaveTag.new([name, attributes])
+    end
+    alias_method :match_tag, :have_tag
+
+  end
+end

data/lib/webrat/core/matchers/have_xpath.rb

@@ -0,0 +1,85 @@
+module Webrat
+  module Matchers
+    
+    class HaveXpath #:nodoc:
+      def initialize(expected, &block)
+        @expected = expected
+        @block    = block
+      end
+    
+      def matches?(stringlike)
+        if defined?(Nokogiri::XML)
+          matches_nokogiri?(stringlike)
+        else
+          matches_rexml?(stringlike)
+        end
+      end
+    
+      def matches_rexml?(stringlike)
+        @document = rexml_document(stringlike)
+      
+        query.all? do |q|
+          matched = REXML::XPath.match(@document, q)
+          matched.any? && (!block_given? || matched.all?(&@block))
+        end
+      end
+    
+      def matches_nokogiri?(stringlike)
+        @document = Webrat.nokogiri_document(stringlike)
+        @document.xpath(*query).any?
+      end
+    
+      def rexml_document(stringlike)
+        stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
+        
+        case stringlike
+        when REXML::Document
+          stringlike.root
+        when REXML::Node
+          stringlike
+        when StringIO, String
+          begin
+            REXML::Document.new(stringlike.to_s).root
+          rescue REXML::ParseException => e
+            if e.message.include?("second root element")
+              REXML::Document.new("<fake-root-element>#{stringlike}</fake-root-element>").root
+            else
+              raise e
+            end
+          end
+        end
+      end
+      
+      def query
+        [@expected].flatten.compact
+      end
+    
+      # ==== Returns
+      # String:: The failure message.
+      def failure_message
+        "expected following text to match xpath #{@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 xpath #{@expected}:\n#{@document}"
+      end    
+    end
+    
+    # Matches HTML content against an XPath query
+    #
+    # ==== Parameters
+    # expected<String>:: The XPath query to look for.
+    #
+    # ==== Returns
+    # HaveXpath:: A new have xpath matcher.
+    # ---
+    # @api public
+    def have_xpath(expected)
+      HaveXpath.new(expected)
+    end
+    alias_method :match_xpath, :have_xpath
+    
+  end
+end