webrat 0.3.4 → 0.4.0

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

@@ -0,0 +1,24 @@
+module Webrat
+  
+  def self.rexml_document(stringlike)
+    stringlike = stringlike.body.to_s if stringlike.respond_to?(:body)
+
+    case stringlike
+    when REXML::Document
+      stringlike.root
+    when REXML::Node, Array
+      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
+  
+end

data/lib/webrat/core_extensions/deprecate.rb

@@ -1,5 +1,5 @@
 class Module #:nodoc:
-  def deprecate(old_method_name, new_method_name)
+  def webrat_deprecate(old_method_name, new_method_name)
     define_method old_method_name do |*args|
       warn "#{old_method_name} is deprecated. Use #{new_method_name} instead."
       __send__(new_method_name, *args)

data/lib/webrat/mechanize.rb

@@ -1,28 +1,74 @@
 require "mechanize"
 
-module Webrat
+module Webrat #:nodoc:
   class MechanizeSession < Session #:nodoc:
     
-    def initialize(mechanize = WWW::Mechanize.new)
-      super()
-      @mechanize = mechanize
+    attr_accessor :response
+    alias :page :response
+    
+    def request_page(url, http_method, data) #:nodoc:
+      super(absolute_url(url), http_method, data)
     end
     
-    def get(url, data)
-      @mechanize_page = @mechanize.get(url, data)
+    def get(url, data, headers_argument_not_used = nil)
+      @response = mechanize.get(url, data)
     end
 
-    def post(url, data)
-      @mechanize_page = @mechanize.post(url, data)
+    def post(url, data, headers_argument_not_used = nil)
+      post_data = data.inject({}) do |memo, param|
+        case param.last
+        when Hash
+          param.last.each {|attribute, value| memo["#{param.first}[#{attribute}]"] = value }
+        else
+          memo[param.first] = param.last
+        end
+        memo
+      end
+      @response = mechanize.post(url, post_data)
     end
-
+    
     def response_body
-      @mechanize_page.content
+      @response.content
     end
 
     def response_code
-      @mechanize_page.code.to_i
+      @response.code.to_i
+    end
+    
+    def mechanize
+      @mechanize = WWW::Mechanize.new
     end
+
+    def_delegators :mechanize, :basic_auth
+    
+    def absolute_url(url) #:nodoc:
+      current_host, current_path = split_current_url
+      if url =~ Regexp.new('^https?://')
+        url
+      elsif url =~ Regexp.new('^/')
+        current_host + url
+      elsif url =~ Regexp.new('^\.')
+        current_host + absolute_path(current_path, url)
+      else
+        url
+      end
+    end
+    
+    private
+      def split_current_url
+        current_url =~ Regexp.new('^(https?://[^/]+)(/.*)?')
+        [Regexp.last_match(1), Regexp.last_match(2)]
+      end
       
+      def absolute_path(current_path, url)
+        levels_up = url.split('/').find_all { |x| x == '..' }.size
+        ancestor = if current_path.nil?
+          ""
+        else
+          current_path.split("/")[0..(-1 - levels_up)].join("/")
+        end
+        descendent = url.split("/")[levels_up..-1]
+        "#{ancestor}/#{descendent}"
+      end
   end
-end
+end

data/lib/webrat/merb.rb

@@ -1,75 +1,9 @@
-require "webrat/core"
+require "webrat"
 
-require "cgi"
-gem "extlib"
-require "extlib"
-require "merb-core"
-
-HashWithIndifferentAccess = Mash
-
-module Webrat
-  class MerbSession < Session #:nodoc:
-    include Merb::Test::MakeRequest
-    
-    attr_accessor :response
-    
-    def get(url, data, headers = nil)
-      do_request(url, data, headers, "GET")
-    end
-  
-    def post(url, data, headers = nil)
-      do_request(url, data, headers, "POST")
-    end
-  
-    def put(url, data, headers = nil)
-      do_request(url, data, headers, "PUT")
-    end
-  
-    def delete(url, data, headers = nil)
-      do_request(url, data, headers, "DELETE")
-    end
-    
-    def response_body
-      @response.body.to_s
-    end
-    
-    def response_code
-      @response.status
-    end
-    
-    def do_request(url, data, headers, method)
-      @response = request(url, 
-        :params => (data && data.any?) ? data : nil, 
-        :headers => headers,
-        :method => method)
-      follow_redirect
-    end
-    
-    def follow_redirect
-      self.get(@response.headers['Location'], nil, @response.headers) if @response.status == 302
-    end
-
-  end
-end
-
-module Merb
-  module Test
-    module RequestHelper #:nodoc:
-      def request(uri, env = {})
-        @_webrat_session ||= Webrat::MerbSession.new
-        @_webrat_session.response = @_webrat_session.request(uri, env)
-      end
-  
-      def follow_redirect
-        @_webrat_session.follow_redirect
-      end
-    end
-  end
-end
-
-class Merb::Test::RspecStory #:nodoc:
-  def browser
-    @browser ||= Webrat::MerbSession.new
-  end
-end
+# This is a temporary hack to support backwards compatibility
+# with Merb 1.0.8 until it's updated to use the new Webrat.configure
+# syntax
 
+Webrat.configure do |config|
+  config.mode = :merb
+end

data/lib/webrat/merb_session.rb

@@ -0,0 +1,65 @@
+require "webrat"
+
+require "cgi"
+gem "extlib"
+require "extlib"
+require "merb-core"
+
+HashWithIndifferentAccess = Mash
+
+module Webrat
+  class MerbSession < Session #:nodoc:
+    include Merb::Test::MakeRequest
+    
+    attr_accessor :response
+    
+    def get(url, data, headers = nil)
+      do_request(url, data, headers, "GET")
+    end
+  
+    def post(url, data, headers = nil)
+      do_request(url, data, headers, "POST")
+    end
+  
+    def put(url, data, headers = nil)
+      do_request(url, data, headers, "PUT")
+    end
+  
+    def delete(url, data, headers = nil)
+      do_request(url, data, headers, "DELETE")
+    end
+    
+    def response_body
+      @response.body.to_s
+    end
+    
+    def response_code
+      @response.status
+    end
+    
+    def do_request(url, data, headers, method)
+      @response = request(url, 
+        :params => (data && data.any?) ? data : nil, 
+        :headers => headers,
+        :method => method)
+    end
+
+  end
+end
+
+module Merb #:nodoc:
+  module Test #:nodoc:
+    module RequestHelper #:nodoc:
+      def request(uri, env = {})
+        @_webrat_session ||= Webrat::MerbSession.new
+        @_webrat_session.response = @_webrat_session.request(uri, env)
+      end
+    end
+  end
+end
+
+class Merb::Test::RspecStory #:nodoc:
+  def browser
+    @browser ||= Webrat::MerbSession.new
+  end
+end

data/lib/webrat/rack.rb

@@ -21,4 +21,4 @@ module Webrat
       @response.status
     end
   end
-end
+end

data/lib/webrat/rails.rb

@@ -1,102 +1,103 @@
 require "webrat"
 
+require "action_controller"
+require "action_controller/integration"
+require "action_controller/record_identifier"
+
 module Webrat
   class RailsSession < Session #:nodoc:
+    include ActionController::RecordIdentifier
     
-    def initialize(integration_session)
-      super()
-      @integration_session = integration_session
+    # The Rails version of within supports passing in a model and Webrat
+    # will apply a scope based on Rails' dom_id for that model.
+    #
+    # Example:
+    #   within User.last do
+    #     click_link "Delete"
+    #   end
+    def within(selector_or_object, &block)
+      if selector_or_object.is_a?(String)
+        super
+      else
+        super('#' + dom_id(selector_or_object), &block)
+      end
     end
-
+    
     def doc_root
       File.expand_path(File.join(RAILS_ROOT, 'public'))
     end
-    
+
     def saved_page_dir
       File.expand_path(File.join(RAILS_ROOT, "tmp"))
     end
-    
+
     def get(url, data, headers = nil)
       do_request(:get, url, data, headers)
     end
-    
+
     def post(url, data, headers = nil)
       do_request(:post, url, data, headers)
     end
-    
+
     def put(url, data, headers = nil)
       do_request(:put, url, data, headers)
     end
-    
+
     def delete(url, data, headers = nil)
       do_request(:delete, url, data, headers)
     end
-    
+
     def response_body
       response.body
     end
-    
+
     def response_code
       response.code.to_i
     end
-    
+
+    def xml_content_type?
+      response.headers["Content-Type"].to_s =~ /xml/
+    end
+
   protected
-    
+
+    def integration_session
+      @context
+    end
+
     def do_request(http_method, url, data, headers) #:nodoc:
       update_protocol(url)
-      @integration_session.request_via_redirect(http_method, remove_protocol(url), data, headers)
+      integration_session.send(http_method, normalize_url(url), data, headers)
     end
-  
-    def remove_protocol(href) #:nodoc:
-      if href =~ %r{^https?://www.example.com(/.*)}
-        $LAST_MATCH_INFO.captures.first
-      else
-        href
+
+    # remove protocol, host and anchor
+    def normalize_url(href) #:nodoc:
+      uri = URI.parse(href)
+      normalized_url = uri.path
+      if uri.query
+        normalized_url += "?" + uri.query
       end
+      normalized_url
     end
-    
+
     def update_protocol(href) #:nodoc:
       if href =~ /^https:/
-        @integration_session.https!(true)
+        integration_session.https!(true)
       elsif href =~ /^http:/
-        @integration_session.https!(false)
+        integration_session.https!(false)
       end
     end
-    
+
     def response #:nodoc:
-      @integration_session.response
+      integration_session.response
     end
-    
+
   end
 end
 
-module ActionController
-  module Integration
-    class Session #:nodoc:
-      
-      unless instance_methods.include?("put_via_redirect")
-        require "webrat/rails/redirect_actions"
-        include Webrat::RedirectActions
-      end
-
-      def respond_to?(name)
-        super || webrat_session.respond_to?(name)
-      end
-      
-      def method_missing(name, *args, &block)
-        if webrat_session.respond_to?(name)
-          webrat_session.send(name, *args, &block)
-        else
-          super
-        end
-      end
-      
-    protected
-    
-      def webrat_session
-        @webrat_session ||= Webrat::RailsSession.new(self)
-      end
-      
-    end
+module ActionController #:nodoc:
+  IntegrationTest.class_eval do
+    include Webrat::Methods
+    include Webrat::Matchers
   end
-end
+end

data/lib/webrat/rspec-rails.rb

@@ -0,0 +1,13 @@
+# Supports using the matchers in controller, helper, and view specs if you're
+# using rspec-rails. Just add a require statement to spec/spec_helper.rb or env.rb:
+# 
+#   require 'webrat/rspec-rails'
+#
+require "webrat/core/matchers"
+
+Spec::Runner.configure do |config|
+  # rspec should support :type => [:controller, :helper, :view] - but until it does ...
+  config.include(Webrat::Matchers, :type => :controller)
+  config.include(Webrat::Matchers, :type => :helper)
+  config.include(Webrat::Matchers, :type => :view)
+end