webrat 0.3.4 → 0.4.0

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

@@ -28,12 +28,25 @@ module Webrat
     #
     # ==== Returns
     # HaveSelector:: A new have selector matcher.
-    # ---
-    # @api public
     def have_selector(expected, &block)
       HaveSelector.new(expected, &block)
     end
     alias_method :match_selector, :have_selector
     
+    
+    # Asserts that the body of the response contains
+    # the supplied selector
+    def assert_have_selector(expected)
+      hs = HaveSelector.new(expected)
+      assert hs.matches?(response_body), hs.failure_message
+    end
+    
+    # Asserts that the body of the response
+    # does not contain the supplied string or regepx
+    def assert_have_no_selector(expected)
+      hs = HaveSelector.new(expected)
+      assert !hs.matches?(response_body), hs.negative_failure_message
+    end
+    
   end
 end

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

@@ -3,7 +3,6 @@ module Webrat
   module HaveTagMatcher
 
     class HaveTag < ::Webrat::Matchers::HaveSelector #:nodoc:
-
       # ==== Returns
       # String:: The failure message.
       def failure_message
@@ -46,13 +45,27 @@ module Webrat
 
         Nokogiri::CSS::Parser.parse(selector).map { |ast| ast.to_xpath }
       end
-
     end
 
     def have_tag(name, attributes = {}, &block)
       HaveTag.new([name, attributes], &block)
     end
+    
     alias_method :match_tag, :have_tag
+    
+    # Asserts that the body of the response contains
+    # the supplied tag with the associated selectors
+    def assert_have_tag(name, attributes = {})
+      ht = HaveTag.new([name, attributes])
+      assert ht.matches?(response_body), ht.failure_message
+    end
+    
+    # Asserts that the body of the response
+    # does not contain the supplied string or regepx
+    def assert_have_no_tag(name, attributes = {})
+      ht = HaveTag.new([name, attributes])
+      assert !ht.matches?(response_body), ht.negative_failure_message
+    end
 
   end
 end

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

@@ -1,3 +1,6 @@
+require "webrat/core/xml/nokogiri"
+require "webrat/core/xml/rexml"
+
 module Webrat
   module Matchers
     
@@ -8,7 +11,7 @@ module Webrat
       end
     
       def matches?(stringlike)
-        if defined?(Nokogiri::XML)
+        if Webrat.configuration.parse_with_nokogiri?
           matches_nokogiri?(stringlike)
         else
           matches_rexml?(stringlike)
@@ -16,9 +19,13 @@ module Webrat
       end
     
       def matches_rexml?(stringlike)
-        @query = query
+        if REXML::Node === stringlike || Array === stringlike
+          @query = query.map { |q| q.gsub(%r'//', './') }
+        else
+          @query = query
+        end
 
-        @document = rexml_document(stringlike)
+        @document = Webrat.rexml_document(stringlike)
 
         matched = @query.map do |q|
           if @document.is_a?(Array)
@@ -38,32 +45,10 @@ module Webrat
           @query = query
         end
         
-        @document = Webrat.nokogiri_document(stringlike)
+        @document = Webrat::XML.document(stringlike)
         matched = @document.xpath(*@query)
         matched.any? && (!@block || @block.call(matched))
       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, Array
-          @query = query.map { |q| q.gsub(%r'//', './') }
-          stringlike
-        else
-          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
@@ -89,12 +74,20 @@ module Webrat
     #
     # ==== Returns
     # HaveXpath:: A new have xpath matcher.
-    # ---
-    # @api public
     def have_xpath(expected, &block)
       HaveXpath.new(expected, &block)
     end
     alias_method :match_xpath, :have_xpath
     
+    def assert_have_xpath(expected, &block)
+      hs = HaveXpath.new(expected, &block)
+      assert hs.matches?(response_body), hs.failure_message
+    end
+    
+    def assert_have_no_xpath(expected, &block)
+      hs = HaveXpath.new(expected, &block)
+      assert !hs.matches?(response_body), hs.negative_failure_message
+    end
+    
   end
 end

data/lib/webrat/core/methods.rb

@@ -5,13 +5,20 @@ module Webrat
       meths.each do |meth|
         self.class_eval <<-RUBY
           def #{meth}(*args, &blk)
-            @_webrat_session ||= ::Webrat::MerbSession.new
-            @_webrat_session.#{meth}(*args, &blk)
+            webrat_session.#{meth}(*args, &blk)
           end
         RUBY
       end
     end
     
+    def webrat
+      webrat_session
+    end
+    
+    def webrat_session
+      @_webrat_session ||= ::Webrat.session_class.new(self)
+    end
+    
     # all of these methods delegate to the @session, which should
     # be created transparently.
     #
@@ -23,22 +30,32 @@ module Webrat
       :within,
       :header, :http_accept, :basic_auth,
       :save_and_open_page,
-      :fill_in,
-      :check, 
-      :uncheck,
-      :choose,
-      :select,
-      :attach_file,
-      :cookies,
-      :response,
+      :fills_in, :fill_in,
+      :checks, :check, 
+      :unchecks, :uncheck,
+      :chooses, :choose,
+      :selects, :select,
+      :attaches_file, :attach_file,
       :current_page,
       :current_url,
-      :click_link,
-      :click_area,
-      :click_button,
+      :clicks_link, :click_link,
+      :clicks_area, :click_area,
+      :clicks_button, :click_button,
       :reload, :reloads,
-      :clicks_link_within,
-      :field_labeled
+      :clicks_link_within, :click_link_within,
+      :field_labeled,
+      :select_option,
+      :set_hidden_field, :submit_form,
+      :request_page, :current_dom,
+      :response_body, 
+      :selects_date, :selects_time, :selects_datetime,
+      :select_date, :select_time, :select_datetime,
+      :field_by_xpath,
+      :field_with_id,
+      :selenium,
+      :simulate, :automate
+      
+      
     
   end
 end

data/lib/webrat/core/mime.rb

@@ -1,7 +1,7 @@
-module Webrat
-  module MIME
+module Webrat #:nodoc:
+  module MIME #:nodoc:
     
-    def self.mime_type(string_or_symbol)
+    def self.mime_type(string_or_symbol) #:nodoc:
       if string_or_symbol.is_a?(String)
         string_or_symbol
       else

data/lib/webrat/core/save_and_open_page.rb

@@ -0,0 +1,50 @@
+module Webrat
+  module SaveAndOpenPage
+    # Saves the page out to RAILS_ROOT/tmp/ and opens it in the default
+    # web browser if on OS X. Useful for debugging.
+    # 
+    # Example:
+    #   save_and_open_page
+    def save_and_open_page
+      return unless File.exist?(saved_page_dir)
+
+      filename = "#{saved_page_dir}/webrat-#{Time.now.to_i}.html"
+      
+      File.open(filename, "w") do |f|
+        f.write rewrite_css_and_image_references(response_body)
+      end
+
+      open_in_browser(filename)
+    end
+    
+    def open_in_browser(path) # :nodoc
+      platform = ruby_platform
+      if platform =~ /cygwin/ || platform =~ /win32/
+        `rundll32 url.dll,FileProtocolHandler #{path.gsub("/", "\\\\")}`
+      elsif platform =~ /darwin/
+        `open #{path}`
+      end
+    end
+    
+    def rewrite_css_and_image_references(response_html) # :nodoc:
+      return response_html unless doc_root
+      response_html.gsub(/"\/(stylesheets|images)/, doc_root + '/\1')
+    end
+    
+    def saved_page_dir #:nodoc:
+      File.expand_path(".")
+    end
+    
+    def doc_root #:nodoc:
+      nil
+    end
+  
+  private
+
+    # accessor for testing
+    def ruby_platform
+      RUBY_PLATFORM
+    end
+    
+  end
+end

data/lib/webrat/core/scope.rb

@@ -1,11 +1,14 @@
-require "nokogiri"
-require "webrat/core/form"
+require "webrat/core/elements/form"
 require "webrat/core/locators"
+require "webrat/core_extensions/deprecate"
 
 module Webrat
+  # An HTML element (link, button, field, etc.) that Webrat expected was not found on the page
+  class NotFoundError < WebratError
+  end
+  
   class Scope
     include Logging
-    include Flunk
     include Locators
     
     def self.from_page(session, response, response_body) #:nodoc:
@@ -22,9 +25,15 @@ module Webrat
       end
     end
     
+    attr_reader :session
+    
     def initialize(session, &block) #:nodoc:
       @session = session
       instance_eval(&block) if block_given?
+      
+      if @selector && scoped_dom.nil?
+        raise Webrat::NotFoundError.new("The scope was not found on the page: #{@selector.inspect}")
+      end
     end
     
     # Verifies an input field or textarea exists on the current page, and stores a value for
@@ -43,7 +52,17 @@ module Webrat
       field.set(options[:with])
     end
 
-    alias_method :fills_in, :fill_in
+    webrat_deprecate :fills_in, :fill_in
+    
+    # Verifies that a hidden field exists on the current page and sets
+    # the value to that given by the <tt>:to</tt> option.
+    #
+    # Example:
+    #   set_hidden_field 'user_id', :to => 1
+    def set_hidden_field(field_locator, options = {})
+      field = locate_field(field_locator, HiddenField)
+      field.set(options[:to])
+    end
     
     # Verifies that an input checkbox exists on the current page and marks it
     # as checked, so that the value will be submitted with the form.
@@ -54,7 +73,7 @@ module Webrat
       locate_field(field_locator, CheckboxField).check
     end
 
-    alias_method :checks, :check
+    webrat_deprecate :checks, :check
     
     # Verifies that an input checkbox exists on the current page and marks it
     # as unchecked, so that the value will not be submitted with the form.
@@ -65,7 +84,7 @@ module Webrat
       locate_field(field_locator, CheckboxField).uncheck
     end
 
-    alias_method :unchecks, :uncheck
+    webrat_deprecate :unchecks, :uncheck
     
     # Verifies that an input radio button exists on the current page and marks it
     # as checked, so that the value will be submitted with the form.
@@ -76,7 +95,7 @@ module Webrat
       locate_field(field_locator, RadioField).choose
     end
 
-    alias_method :chooses, :choose
+    webrat_deprecate :chooses, :choose
     
     # Verifies that a an option element exists on the current page with the specified
     # text. You can optionally restrict the search to a specific select list by
@@ -84,14 +103,106 @@ module Webrat
     # a label. Stores the option's value to be sent when the form is submitted.
     #
     # Examples:
-    #   selects "January"
-    #   selects "February", :from => "event_month"
-    #   selects "February", :from => "Event Month"
-    def selects(option_text, options = {})
-      find_select_option(option_text, options[:from]).choose
+    #   select "January"
+    #   select "February", :from => "event_month"
+    #   select "February", :from => "Event Month"
+    def select(option_text, options = {})
+      select_option(option_text, options[:from]).choose
     end
 
-    alias_method :select, :selects
+    webrat_deprecate :selects, :select
+    
+    DATE_TIME_SUFFIXES = {
+      :year   => '1i',
+      :month  => '2i',
+      :day    => '3i',
+      :hour   => '4i',
+      :minute => '5i'
+    }
+
+    # Verifies that date elements (year, month, day) exist on the current page 
+    # with the specified values. You can optionally restrict the search to a specific
+    # date's elements by assigning <tt>options[:from]</tt> the value of the date's 
+    # label. Selects all the date elements with date provided.  The date provided may
+    # be a string or a Date/Time object.
+    #
+    # Rail's convention is used for detecting the date elements. All elements
+    # are assumed to have a shared prefix.  You may also specify the prefix
+    # by assigning <tt>options[:id_prefix]</tt>.
+    #
+    # Examples:
+    #   select_date "January 23, 2004"
+    #   select_date "April 26, 1982", :from => "Birthday"
+    #   select_date Date.parse("December 25, 2000"), :from => "Event"
+    #   select_date "April 26, 1982", :id_prefix => 'birthday'
+    def select_date(date_to_select, options ={})
+      date = date_to_select.is_a?(Date) || date_to_select.is_a?(Time) ? 
+                date_to_select : Date.parse(date_to_select) 
+      
+      id_prefix = locate_id_prefix(options) do
+        year_field = FieldByIdLocator.new(@session, dom, /(.*?)_#{DATE_TIME_SUFFIXES[:year]}$/).locate
+        raise NotFoundError.new("No date fields were found") unless year_field && year_field.id =~ /(.*?)_1i/
+        $1
+      end
+        
+      select date.year, :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:year]}"
+      select date.strftime('%B'), :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:month]}"
+      select date.day, :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:day]}"
+    end
+
+    webrat_deprecate :selects_date, :select_date
+
+    # Verifies that time elements (hour, minute) exist on the current page 
+    # with the specified values. You can optionally restrict the search to a specific
+    # time's elements by assigning <tt>options[:from]</tt> the value of the time's 
+    # label. Selects all the time elements with date provided.  The time provided may
+    # be a string or a Time object.
+    #
+    # Rail's convention is used for detecting the time elements. All elements are
+    # assumed to have a shared prefix. You may specify the prefix by assigning
+    # <tt>options[:id_prefix]</tt>.
+    #
+    # Note: Just like Rails' time_select helper this assumes the form is using
+    # 24 hour select boxes, and not 12 hours with AM/PM.
+    # 
+    # Examples:
+    #   select_time "9:30"
+    #   select_date "3:30PM", :from => "Party Time"
+    #   select_date Time.parse("10:00PM"), :from => "Event"
+    #   select_date "10:30AM", :id_prefix => 'meeting'
+    def select_time(time_to_select, options ={})
+      time = time_to_select.is_a?(Time) ? time_to_select : Time.parse(time_to_select) 
+
+      id_prefix = locate_id_prefix(options) do
+        hour_field = FieldByIdLocator.new(@session, dom, /(.*?)_#{DATE_TIME_SUFFIXES[:hour]}$/).locate
+        raise NotFoundError.new("No time fields were found") unless hour_field && hour_field.id =~ /(.*?)_4i/
+        $1
+      end
+        
+      select time.hour.to_s.rjust(2,'0'), :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:hour]}"
+      select time.min.to_s.rjust(2,'0'), :from => "#{id_prefix}_#{DATE_TIME_SUFFIXES[:minute]}"
+    end
+
+    webrat_deprecate :selects_time, :select_time
+   
+    # Verifies and selects all the date and time elements on the current page. 
+    # See #select_time and #select_date for more details and available options.
+    #
+    # Examples:
+    #   select_datetime "January 23, 2004 10:30AM"
+    #   select_datetime "April 26, 1982 7:00PM", :from => "Birthday"
+    #   select_datetime Time.parse("December 25, 2000 15:30"), :from => "Event"
+    #   select_datetime "April 26, 1982 5:50PM", :id_prefix => 'birthday'
+    def select_datetime(time_to_select, options ={})
+      time = time_to_select.is_a?(Time) ? time_to_select : Time.parse(time_to_select) 
+      
+      options[:id_prefix] ||= (options[:from] ? FieldByIdLocator.new(@session, dom, options[:from]).locate : nil)
+      
+      select_date time, options
+      select_time time, options
+    end
+
+    webrat_deprecate :selects_datetime, :select_datetime
     
     # Verifies that an input file field exists on the current page and sets
     # its value to the given +file+, so that the file will be uploaded
@@ -104,13 +215,22 @@ module Webrat
       locate_field(field_locator, FileField).set(path, content_type)
     end
 
-    alias_method :attaches_file, :attach_file
-    
+    webrat_deprecate :attaches_file, :attach_file
+
+    # Issues a request for the URL pointed to by an <tt>area</tt> tag
+    # on the current page, follows any redirects, and verifies the
+    # final page load was successful.
+    #
+    # The area used is the first area whose title or id contains the
+    # given +area_name+ (case is ignored).
+    #
+    # Example:
+    #   click_area 'Australia'
     def click_area(area_name)
       find_area(area_name).click
     end
     
-    alias_method :clicks_area, :click_area
+    webrat_deprecate :clicks_area, :click_area
     
     # Issues a request for the URL pointed to by a link on the current page,
     # follows any redirects, and verifies the final page load was successful.
@@ -124,17 +244,23 @@ module Webrat
     # Passing a :method in the options hash overrides the HTTP method used
     # for making the link request
     # 
+    # It will try to find links by (in order of precedence):
+    #   innerHTML, with simple &nbsp; handling
+    #   title
+    #   id
+    #    
+    # innerHTML and title are matchable by text subtring or Regexp
+    # id is matchable by full text equality or Regexp
+    # 
     # Example:
     #   click_link "Sign up"
-    #
     #   click_link "Sign up", :javascript => false
-    # 
     #   click_link "Sign up", :method => :put
-    def click_link(link_text, options = {})
-      find_link(link_text).click(options)
+    def click_link(text_or_title_or_id, options = {})
+      find_link(text_or_title_or_id).click(options)
     end
 
-    alias_method :clicks_link, :click_link
+    webrat_deprecate :clicks_link, :click_link
     
     # Verifies that a submit button exists for the form, then submits the form, follows
     # any redirects, and verifies the final page was successful.
@@ -149,7 +275,19 @@ module Webrat
       find_button(value).click
     end
 
-    alias_method :clicks_button, :click_button
+    webrat_deprecate :clicks_button, :click_button
+
+    # Submit the form with the given id.
+    #
+    # Note that +click_button+ is usually preferrable for simulating
+    # form submissions, as you may specify part of the button text
+    # rather than the form id.
+    #
+    # Example:
+    #   submit_form 'login'
+    def submit_form(id)
+      FormLocator.new(@session, dom, id).locate.submit
+    end
     
     def dom # :nodoc:
       return @dom if @dom
@@ -164,16 +302,22 @@ module Webrat
     end
     
   protected
-  
+    
     def page_dom #:nodoc:
       return @response.dom if @response.respond_to?(:dom)
-      dom = Webrat.nokogiri_document(@response_body)
+      
+      if @session.xml_content_type?
+        dom = Webrat::XML.xml_document(@response_body)
+      else
+        dom = Webrat::XML.html_document(@response_body)
+      end
+      
       Webrat.define_dom_method(@response, dom)
       return dom
     end
     
-    def scoped_dom #:nodoc:
-      Webrat.nokogiri_document(@scope.dom.search(@selector).first.to_html)
+    def scoped_dom
+      Webrat::XML.css_at(@scope.dom, @selector)
     end
     
     def locate_field(field_locator, *field_types) #:nodoc:
@@ -184,25 +328,23 @@ module Webrat
       end
     end
     
-    def areas #:nodoc:
-      dom.search("area").map do |element| 
-        Area.new(@session, element)
-      end
-    end
-    
-    def links #:nodoc:
-      dom.search("a[@href]").map do |link_element|
-        Link.new(@session, link_element)
+    def locate_id_prefix(options, &location_strategy) #:nodoc:
+      return options[:id_prefix] if options[:id_prefix]
+      
+      if options[:from]
+        if (label = LabelLocator.new(@session, dom, options[:from]).locate)
+          label.for_id
+        else
+          raise NotFoundError.new("Could not find the label with text #{options[:from]}")
+        end
+      else
+        yield
       end
     end
     
     def forms #:nodoc:
-      return @forms if @forms
-      
-      @forms = dom.search("form").map do |form_element|
-        Form.new(@session, form_element)
-      end
+      @forms ||= Form.load_all(@session, dom)
     end
     
   end
-end
+end