dbrady-webrat 0.4.4

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/blank.rb

@@ -0,0 +1,58 @@
+class Object #:nodoc:
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # to
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/webrat/core_extensions/deprecate.rb

@@ -0,0 +1,8 @@
+class Module #:nodoc:
+  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)
+    end
+  end
+end

data/lib/webrat/core_extensions/detect_mapped.rb

@@ -0,0 +1,12 @@
+class Array #:nodoc:
+
+  def detect_mapped
+    each do |element|
+      result = yield element
+      return result if result
+    end
+
+    return nil
+  end
+
+end

data/lib/webrat/core_extensions/meta_class.rb

@@ -0,0 +1,6 @@
+class ::Object #:nodoc:
+  def meta_class
+    class << self; self end
+  end
+end
+

data/lib/webrat/core_extensions/nil_to_param.rb

@@ -0,0 +1,5 @@
+class NilClass #:nodoc:
+  def to_param
+    nil
+  end
+end

data/lib/webrat/mechanize.rb

@@ -0,0 +1,74 @@
+require "mechanize"
+
+module Webrat #:nodoc:
+  class MechanizeSession < Session #:nodoc:
+
+    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, headers_argument_not_used = nil)
+      @response = mechanize.get(url, data)
+    end
+
+    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
+      @response.content
+    end
+
+    def response_code
+      @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

data/lib/webrat/merb.rb

@@ -0,0 +1,9 @@
+require "webrat"
+
+# 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

@@ -0,0 +1,24 @@
+require 'webrat'
+
+class CGIMethods #:nodoc:
+  def self.parse_query_parameters(params)
+    hash = {}
+    params.split('&').each do |p|
+      pair = p.split('=')
+      hash[pair[0]] = pair[1]
+    end
+    hash
+  end
+end
+
+module Webrat
+  class RackSession < Session #:nodoc:
+    def response_body
+      @response.body
+    end
+
+    def response_code
+      @response.status
+    end
+  end
+end

data/lib/webrat/rails.rb

@@ -0,0 +1,105 @@
+require "webrat"
+
+require "action_controller"
+require "action_controller/integration"
+require "action_controller/record_identifier"
+
+module Webrat
+  class RailsSession < Session #:nodoc:
+    include ActionController::RecordIdentifier
+
+    # 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.send(http_method, normalize_url(url), data, headers)
+    end
+
+    # remove protocol, host and anchor
+    def normalize_url(href) #:nodoc:
+      uri = URI.parse(href)
+      normalized_url = []
+      normalized_url << "#{uri.scheme}://" if uri.scheme
+      normalized_url << uri.host if uri.host
+      normalized_url << ":#{uri.port}" if uri.port && ![80,443].include?(uri.port)
+      normalized_url << uri.path if uri.path
+      normalized_url << "?#{uri.query}" if uri.query
+      normalized_url.join
+    end
+
+    def update_protocol(href) #:nodoc:
+      if href =~ /^https:/
+        integration_session.https!(true)
+      elsif href =~ /^http:/
+        integration_session.https!(false)
+      end
+    end
+
+    def response #:nodoc:
+      integration_session.response
+    end
+
+  end
+end
+
+module ActionController #:nodoc:
+  IntegrationTest.class_eval do
+    include Webrat::Methods
+    include Webrat::Matchers
+  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

data/lib/webrat/selenium.rb

@@ -0,0 +1,80 @@
+require "webrat"
+gem "selenium-client", ">=1.2.14"
+require "selenium/client"
+require "webrat/selenium/selenium_session"
+require "webrat/selenium/matchers"
+require "webrat/core_extensions/tcp_socket"
+
+module Webrat
+  # To use Webrat's Selenium support, you'll need the selenium-client gem installed.
+  # Activate it with (for example, in your <tt>env.rb</tt>):
+  #
+  #   require "webrat"
+  #
+  #   Webrat.configure do |config|
+  #     config.mode = :selenium
+  #   end
+  #
+  # == Dropping down to the selenium-client API
+  #
+  # If you ever need to do something with Selenium not provided in the Webrat API,
+  # you can always drop down to the selenium-client API using the <tt>selenium</tt> method.
+  # For example:
+  #
+  #   When "I drag the photo to the left" do
+  #     selenium.dragdrop("id=photo_123", "+350, 0")
+  #   end
+  #
+  # == Choosing the underlying framework to test
+  #
+  # Webrat assumes you're using rails by default but it can also work with sinatra
+  # and merb.  To take advantage of this you can use the configuration block to
+  # set the application_framework variable.
+  #   require "webrat"
+  #
+  #   Webrat.configure do |config|
+  #     config.mode = :selenium
+  #     config.application_port = 4567
+  #     config.application_framework = :sinatra  # could also be :merb
+  #   end
+  #
+  # == Auto-starting of the appserver and java server
+  #
+  # Webrat will automatically start the Selenium Java server process and an instance
+  # of Mongrel when a test is run. The Mongrel will run in the "selenium" environment
+  # instead of "test", so ensure you've got that defined, and will run on port
+  # Webrat.configuration.application_port.
+  #
+  # == Waiting
+  #
+  # In order to make writing Selenium tests as easy as possible, Webrat will automatically
+  # wait for the correct elements to exist on the page when trying to manipulate them
+  # with methods like <tt>fill_in</tt>, etc. In general, this means you should be able to write
+  # your Webrat::Selenium tests ignoring the concurrency issues that can plague in-browser
+  # testing, so long as you're using the Webrat API.
+  module Selenium
+    module Methods
+      def response
+        webrat_session.response
+      end
+
+      def wait_for(*args, &block)
+        webrat_session.wait_for(*args, &block)
+      end
+
+      def save_and_open_screengrab
+        webrat_session.save_and_open_screengrab
+      end
+    end
+  end
+end
+
+if defined?(ActionController::IntegrationTest)
+  module ActionController #:nodoc:
+    IntegrationTest.class_eval do
+      include Webrat::Methods
+      include Webrat::Selenium::Methods
+      include Webrat::Selenium::Matchers
+    end
+  end
+end