webrat 0.3.4 → 0.4.0

data/lib/webrat/core/session.rb

@@ -2,43 +2,66 @@ require "forwardable"
 require "ostruct"
 
 require "webrat/core/mime"
+require "webrat/core/save_and_open_page"
 
 module Webrat
+  # A page load or form submission returned an unsuccessful response code (500-599)
+  class PageLoadError < WebratError
+  end
+
+  def self.session_class
+    case Webrat.configuration.mode
+    when :rails
+      RailsSession
+    when :merb
+      MerbSession
+    when :selenium
+      SeleniumSession
+    when :rack
+      RackSession
+    when :sinatra
+      SinatraSession
+    when :mechanize
+      MechanizeSession
+    else
+      raise WebratError.new(<<-STR)
+Unknown Webrat mode: #{Webrat.configuration.mode.inspect}
+
+Please ensure you have a Webrat configuration block that specifies a mode
+in your test_helper.rb, spec_helper.rb, or env.rb (for Cucumber).
+
+This configure block supercedes the need to require "webrat/<framework>".
+
+For example:
+
+  Webrat.configure do |config|
+    config.mode = :rails
+  end
+      STR
+    end
+  end
+
   class Session
     extend Forwardable
     include Logging
-    include Flunk
-    
+    include SaveAndOpenPage
     attr_reader :current_url
-    
-    def initialize #:nodoc:
+    attr_reader :elements
+
+    def initialize(context = nil) #:nodoc:
       @http_method     = :get
       @data            = {}
       @default_headers = {}
       @custom_headers  = {}
-    end
+      @context         = context
 
-    # 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)
+      reset
     end
-    
+
     def current_dom #:nodoc:
       current_scope.dom
     end
-    
+
     # For backwards compatibility -- removing in 1.0
     def current_page #:nodoc:
       page = OpenStruct.new
@@ -47,15 +70,11 @@ module Webrat
       page.data = @data
       page
     end
-    
+
     def doc_root #:nodoc:
       nil
     end
     
-    def saved_page_dir #:nodoc:
-      File.expand_path(".")
-    end
-
     def header(key, value)
       @custom_headers[key] = value
     end
@@ -63,7 +82,7 @@ module Webrat
     def http_accept(mime_type)
       header('Accept', Webrat::MIME.mime_type(mime_type))
     end
-    
+
     def basic_auth(user, pass)
       encoded_login = ["#{user}:#{pass}"].pack("m*")
       header('HTTP_AUTHORIZATION', "Basic #{encoded_login}")
@@ -84,44 +103,51 @@ module Webrat
         send "#{http_method}", url, data || {}, h
       end
 
-      save_and_open_page if exception_caught?
-      flunk("Page load was not successful (Code: #{response_code.inspect}):\n#{formatted_error}") unless success_code?
-      
-      @_scopes      = nil
-      @_page_scope  = nil
+      save_and_open_page if exception_caught? && Webrat.configuration.open_error_files?
+      raise PageLoadError.new("Page load was not successful (Code: #{response_code.inspect}):\n#{formatted_error}") unless success_code?
+
+      reset
+
       @current_url  = url
       @http_method  = http_method
       @data         = data
-      
+
+      request_page(response_location, :get, data) if internal_redirect?
+
       return response
     end
-    
+
     def success_code? #:nodoc:
       (200..499).include?(response_code)
     end
-    
+
+    def redirect? #:nodoc:
+      response_code / 100 == 3
+    end
+
+    def internal_redirect? #:nodoc:
+      redirect? && current_host == response_location_host
+    end
+
     def exception_caught? #:nodoc:
       response_body =~ /Exception caught/
     end
-    
+
     def current_scope #:nodoc:
       scopes.last || page_scope
     end
-    
+
     # Reloads the last page requested. Note that this will resubmit forms
     # and their data.
-    #
-    # Example:
-    #   reloads
-    def reloads
+    def reload
       request_page(@current_url, @http_method, @data)
     end
 
-    alias_method :reload, :reloads
-      
-    
+    webrat_deprecate :reloads, :reload
+
+
     # Works like click_link, but only looks for the link text within a given selector
-    # 
+    #
     # Example:
     #   click_link_within "#user_12", "Vote"
     def click_link_within(selector, link_text)
@@ -130,15 +156,15 @@ module Webrat
       end
     end
 
-    alias_method :clicks_link_within, :click_link_within
-    
+    webrat_deprecate :clicks_link_within, :click_link_within
+
     def within(selector)
       scopes.push(Scope.from_scope(self, current_scope, selector))
       ret = yield(current_scope)
       scopes.pop
       return ret
     end
-    
+
     # Issues a GET request for a page, follows any redirects, and verifies the final page
     # load was successful.
     #
@@ -147,17 +173,8 @@ module Webrat
     def visit(url = nil, http_method = :get, data = {})
       request_page(url, http_method, data)
     end
-    
-    alias_method :visits, :visit
-    
-    def open_in_browser(path) #:nodoc
-      `open #{path}`
-    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
+
+    webrat_deprecate :visits, :visit
 
     # Subclasses can override this to show error messages without html
     def formatted_error #:nodoc:
@@ -171,18 +188,63 @@ module Webrat
     def page_scope #:nodoc:
       @_page_scope ||= Scope.from_page(self, response, response_body)
     end
-    
+
+    def dom
+      page_scope.dom
+    end
+
+    def xml_content_type?
+      false
+    end
+
+    def simulate
+      return if Webrat.configuration.mode == :selenium
+      yield
+    end
+
+    def automate
+      return unless Webrat.configuration.mode == :selenium
+      yield
+    end
+
     def_delegators :current_scope, :fill_in,            :fills_in
+    def_delegators :current_scope, :set_hidden_field
+    def_delegators :current_scope, :submit_form
     def_delegators :current_scope, :check,              :checks
     def_delegators :current_scope, :uncheck,            :unchecks
     def_delegators :current_scope, :choose,             :chooses
     def_delegators :current_scope, :select,             :selects
+    def_delegators :current_scope, :select_datetime,    :selects_datetime
+    def_delegators :current_scope, :select_date,        :selects_date
+    def_delegators :current_scope, :select_time,        :selects_time
     def_delegators :current_scope, :attach_file,        :attaches_file
     def_delegators :current_scope, :click_area,         :clicks_area
     def_delegators :current_scope, :click_link,         :clicks_link
     def_delegators :current_scope, :click_button,       :clicks_button
-    def_delegators :current_scope, :should_see
-    def_delegators :current_scope, :should_not_see
     def_delegators :current_scope, :field_labeled
+    def_delegators :current_scope, :field_by_xpath
+    def_delegators :current_scope, :field_with_id
+    def_delegators :current_scope, :select_option
+
+  private
+
+    def response_location
+      response.headers["Location"]
+    end
+
+    def current_host
+      URI.parse(current_url).host || "www.example.com"
+    end
+
+    def response_location_host
+      URI.parse(response_location).host || "www.example.com"
+    end
+
+    def reset
+      @elements     = {}
+      @_scopes      = nil
+      @_page_scope  = nil
+    end
+    
   end
 end

data/lib/webrat/core/xml.rb

@@ -0,0 +1,115 @@
+require "webrat/core/xml/nokogiri"
+require "webrat/core/xml/hpricot"
+require "webrat/core/xml/rexml"
+
+module Webrat #:nodoc:
+  module XML #:nodoc:
+    
+    def self.document(stringlike) #:nodoc:
+      if Webrat.configuration.parse_with_nokogiri?
+        Webrat.nokogiri_document(stringlike)
+      else
+        Webrat.rexml_document(Webrat.hpricot_document(stringlike).to_html)
+      end
+    end
+    
+    def self.html_document(stringlike) #:nodoc:
+      if Webrat.configuration.parse_with_nokogiri?
+        Webrat.html_nokogiri_document(stringlike)
+      else
+        Webrat.rexml_document(Webrat.hpricot_document(stringlike).to_html)
+      end
+    end
+    
+    def self.xml_document(stringlike) #:nodoc:
+      if Webrat.configuration.parse_with_nokogiri?
+        Webrat.xml_nokogiri_document(stringlike)
+      else
+        Webrat.rexml_document(Webrat.hpricot_document(stringlike).to_html)
+      end
+    end
+
+    def self.to_html(element)
+      if Webrat.configuration.parse_with_nokogiri?
+        element.to_html
+      else
+        element.to_s
+      end
+    end
+    
+    def self.inner_html(element)
+      if Webrat.configuration.parse_with_nokogiri?
+        element.inner_html
+      else
+        element.text
+      end
+    end
+    
+    def self.all_inner_text(element)
+      if Webrat.configuration.parse_with_nokogiri?
+        element.inner_text
+      else
+        Hpricot(element.to_s).children.first.inner_text
+      end
+    end
+    
+    def self.inner_text(element)
+      if Webrat.configuration.parse_with_nokogiri?
+        element.inner_text
+      else
+        if defined?(Hpricot::Doc) && element.is_a?(Hpricot::Doc)
+          element.inner_text
+        else
+          element.text
+        end
+      end
+    end
+    
+    def self.xpath_to(element)
+      if Webrat.configuration.parse_with_nokogiri?
+        element.path
+      else
+        element.xpath
+      end
+    end
+    
+    def self.attribute(element, attribute_name)
+      return element[attribute_name] if element.is_a?(Hash)
+      
+      if Webrat.configuration.parse_with_nokogiri?
+        element[attribute_name]
+      else
+        element.attributes[attribute_name]
+      end
+    end
+    
+    def self.xpath_at(*args)
+      xpath_search(*args).first
+    end
+    
+    def self.css_at(*args)
+      css_search(*args).first
+    end
+    
+    def self.xpath_search(element, *searches)
+      searches.flatten.map do |search|
+        if Webrat.configuration.parse_with_nokogiri?
+          element.xpath(search)
+        else
+          REXML::XPath.match(element, search)
+        end
+      end.flatten.compact
+    end
+    
+    def self.css_search(element, *searches) #:nodoc:
+      xpath_search(element, css_to_xpath(*searches))
+    end
+    
+    def self.css_to_xpath(*selectors)
+      selectors.map do |rule|
+        Nokogiri::CSS.xpath_for(rule, :prefix => ".//")
+      end.flatten.uniq
+    end
+    
+  end
+end

data/lib/webrat/core/xml/hpricot.rb

@@ -0,0 +1,19 @@
+module Webrat
+  
+  def self.hpricot_document(stringlike)
+    return stringlike.dom if stringlike.respond_to?(:dom)
+
+    if Hpricot::Doc === stringlike
+      stringlike
+    elsif Hpricot::Elements === stringlike
+      stringlike
+    elsif StringIO === stringlike
+      Hpricot(stringlike.string)
+    elsif stringlike.respond_to?(:body)
+      Hpricot(stringlike.body.to_s)
+    else
+      Hpricot(stringlike.to_s)
+    end
+  end
+  
+end

data/lib/webrat/core/xml/nokogiri.rb

@@ -0,0 +1,76 @@
+require "webrat/core_extensions/meta_class"
+
+module Webrat
+  
+  def self.nokogiri_document(stringlike) #:nodoc:
+    return stringlike.dom if stringlike.respond_to?(:dom)
+    
+    if Nokogiri::HTML::Document === stringlike
+      stringlike
+    elsif Nokogiri::XML::NodeSet === stringlike
+      stringlike
+    elsif StringIO === stringlike
+      Nokogiri::HTML(stringlike.string)
+    elsif stringlike.respond_to?(:body)
+      Nokogiri::HTML(stringlike.body.to_s)
+    else
+      Nokogiri::HTML(stringlike.to_s)
+    end
+  end
+  
+  def self.html_nokogiri_document(stringlike) #:nodoc:
+    return stringlike.dom if stringlike.respond_to?(:dom)
+    
+    if Nokogiri::HTML::Document === stringlike
+      stringlike
+    elsif Nokogiri::XML::NodeSet === stringlike
+      stringlike
+    elsif StringIO === stringlike
+      Nokogiri::HTML(stringlike.string)
+    elsif stringlike.respond_to?(:body)
+      Nokogiri::HTML(stringlike.body.to_s)
+    else
+      Nokogiri::HTML(stringlike.to_s)
+    end
+  end
+  
+  def self.xml_nokogiri_document(stringlike) #:nodoc:
+    return stringlike.dom if stringlike.respond_to?(:dom)
+    
+    if Nokogiri::HTML::Document === stringlike
+      stringlike
+    elsif Nokogiri::XML::NodeSet === stringlike
+      stringlike
+    elsif StringIO === stringlike
+      Nokogiri::XML(stringlike.string)
+    elsif stringlike.respond_to?(:body)
+      Nokogiri::XML(stringlike.body.to_s)
+    else
+      Nokogiri::XML(stringlike.to_s)
+    end
+  end
+  
+  def self.define_dom_method(object, dom) #:nodoc:
+    object.meta_class.send(:define_method, :dom) do
+      dom
+    end
+  end
+  
+end
+
+
+module Nokogiri #:nodoc:
+  module CSS #:nodoc:
+    class XPathVisitor #:nodoc:
+      
+      def visit_pseudo_class_text(node) #:nodoc:
+        "@type='text'"
+      end
+
+      def visit_pseudo_class_password(node) #:nodoc:
+        "@type='password'"
+      end
+      
+    end
+  end
+end