dstrelau-webrat 0.5.1

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/core_extensions/tcp_socket.rb

@@ -0,0 +1,27 @@
+class TCPSocket
+
+  def self.wait_for_service_with_timeout(options)
+    start_time = Time.now
+
+    until listening_service?(options)
+      verbose_wait
+
+      if options[:timeout] && (Time.now > start_time + options[:timeout])
+        raise SocketError.new("Socket did not open within #{options[:timeout]} seconds")
+      end
+    end
+  end
+
+  def self.wait_for_service_termination_with_timeout(options)
+    start_time = Time.now
+
+    while listening_service?(options)
+      verbose_wait
+
+      if options[:timeout] && (Time.now > start_time + options[:timeout])
+        raise SocketError.new("Socket did not terminate within #{options[:timeout]} seconds")
+      end
+    end
+  end
+
+end

data/lib/webrat/culerity.rb

@@ -0,0 +1,69 @@
+require "webrat/culerity/session"
+require "webrat/culerity/scope"
+require "webrat/culerity/locator"
+require "webrat/culerity/core_ext/button"
+require "webrat/culerity/core_ext/container"
+require "webrat/culerity/core_ext/frame"
+require "webrat/culerity/core_ext/generic_field"
+require "webrat/culerity/core_ext/socket"
+
+module Webrat
+
+  def self.start_app_server #:nodoc:
+    pid_file = prepare_pid_file("#{RAILS_ROOT}/tmp/pids", "mongrel_culerity.pid")
+    system("mongrel_rails start -d --chdir=#{RAILS_ROOT} --port=#{Webrat.configuration.application_port} --environment=#{Webrat.configuration.application_environment} --pid #{pid_file} &")
+    TCPSocket.wait_for_service :host => Webrat.configuration.application_address, :port => Webrat.configuration.application_port.to_i
+  end
+
+  def self.stop_app_server #:nodoc:
+    pid_file = File.expand_path(RAILS_ROOT + "/tmp/pids/mongrel_culerity.pid")
+    system "mongrel_rails stop -c #{RAILS_ROOT} --pid #{pid_file}"
+  end
+
+  def self.prepare_pid_file(file_path, pid_file_name)
+    FileUtils.mkdir_p File.expand_path(file_path)
+    File.expand_path("#{file_path}/#{pid_file_name}")
+  end
+
+  # To use Webrat's Celerity support, activate it with (for example, in your <tt>env.rb</tt>):
+  #
+  #   require "webrat"
+  #   require "webrat/culerity"
+  #
+  #   Webrat.configure do |config|
+  #     config.mode = :culerity
+  #   end
+  #
+  # == Auto-starting of the mongrel server
+  #
+  # Webrat will automatically start an instance of Mongrel when a test is run. The Mongrel will
+  # run in the "test" environment and will run on port 3001.
+  module Culerity
+    module Methods
+      def response
+        webrat_session.response
+      end
+
+      def execute_script(source)
+        webrat_session.execute_script(source)
+      end
+
+      def clear_cookies
+        webrat_session.clear_cookies
+      end
+
+      def within_frame(name, &block)
+        webrat_session.within_frame(name, &block)
+      end
+    end
+  end
+end
+
+module ActionController #:nodoc:
+  IntegrationTest.class_eval do
+    include Webrat::Methods
+    include Webrat::Matchers
+    include Webrat::HaveTagMatcher
+    include Webrat::Culerity::Methods
+  end
+end

data/lib/webrat/culerity/core_ext/button.rb

@@ -0,0 +1,6 @@
+# Webrat matches button with alt as well, but Celerity doesn't list alt as a valid attribute
+# for a button.
+# class ::Celerity::Button
+#   remove_const :ATTRIBUTES if defined?(ATTRIBUTES) # shushes the warning
+#   ATTRIBUTES = BASE_ATTRIBUTES | [:type, :disabled, :tabindex, :accesskey, :onfocus, :onblur] | [:src, :usemap, :ismap] | [:alt]
+# end

data/lib/webrat/culerity/core_ext/container.rb

@@ -0,0 +1,13 @@
+# module Celerity
+#   module Container
+#     # Used internally to update the page object.
+#     # @api private
+#     def update_page(page)
+#       @browser.page = page unless page.web_response.content_type == "application/json"
+#     end
+# 
+#     def generic_field(*args)
+#       GenericField.new(self, *args)
+#     end
+#   end
+# end

data/lib/webrat/culerity/core_ext/frame.rb

@@ -0,0 +1,14 @@
+# class Celerity::Frame
+#   # Fixes an exception that is raised when setting a field in a frame.
+#   # Fixed in kamal-celerity. Will remove when applied upstream.
+#   def locate
+#     super
+#     if @object
+#       @inline_frame_object = @object.getEnclosedWindow.getFrameElement
+#       self.page            = @object.getEnclosedPage
+#       if (frame = self.page.getDocumentElement)
+#         @object = frame
+#       end
+#     end
+#   end
+# end

data/lib/webrat/culerity/core_ext/generic_field.rb

@@ -0,0 +1,21 @@
+# module Celerity
+#   class GenericField < Element
+#     include Container
+#     RADIO_CHECK = CheckBox::TAGS | Radio::TAGS
+#     TAGS = TextField::TAGS | Hidden::TAGS | RADIO_CHECK
+#     DEFAULT_HOW = :name
+# 
+#     def set?
+#       assert_exists
+#       assert_radio_check
+#       @object.isChecked
+#     end
+#     alias_method :checked?, :set?
+# 
+#   protected
+#     def assert_radio_check
+#       locator = ElementLocator.new(@container, self.class)
+#       raise "Not a radio or checkbox" unless RADIO_CHECK.any? { |ident| locator.send(:element_matches_ident?, @object, ident) }
+#     end
+#   end
+# end

data/lib/webrat/culerity/core_ext/socket.rb

@@ -0,0 +1,21 @@
+require 'timeout'
+require 'socket'
+
+class TCPSocket
+  def self.wait_for_service(options)
+    socket = nil
+    Timeout::timeout(options[:timeout] || 20) do
+      loop do
+        begin
+          socket = TCPSocket.new(options[:host], options[:port])
+          return
+        rescue Errno::ECONNREFUSED
+          puts ".\n"
+          sleep 2
+        end
+      end
+    end
+  ensure
+    socket.close unless socket.nil?
+  end  
+end

data/lib/webrat/culerity/locator.rb

@@ -0,0 +1,22 @@
+module Webrat
+  class CulerityLocator
+    def initialize(container, value, element_type, *how)
+      @container    = container
+      @value        = value
+      @element_type = element_type
+      @how          = how.blank? ? [:id, :name, :label] : how
+    end
+
+    def locate
+      @how.each do |how|
+        e = @container.send(@element_type, how => @value)
+        return e if e.exists?
+      end
+      nil
+    end
+
+    def locate!
+      locate || raise(NotFoundError.new("#{@element_type} matching \"#{@value}\" not found"))
+    end
+  end
+end

data/lib/webrat/culerity/scope.rb

@@ -0,0 +1,97 @@
+module Webrat
+  class CulerityScope
+    attr_reader :container
+
+    def initialize(container)
+      @container = container
+    end
+
+    def check(id_or_name_or_label, value = true)
+      elem = element_locator(id_or_name_or_label, :check_box)
+      elem.set(value)
+    end
+
+    webrat_deprecate :checks, :check
+
+    def choose(id_or_name_or_label)
+      elem = element_locator(id_or_name_or_label, :radio)
+      elem.set
+    end
+
+    webrat_deprecate :chooses, :choose
+
+    def click_button(value_or_id_or_alt = nil, options = {})
+      options = value_or_id_or_alt if value_or_id_or_alt.is_a?(Hash)
+
+      with_handler options.delete(:confirm) do
+        if value_or_id_or_alt
+          elem = element_locator(value_or_id_or_alt, :button, :value, :id, :text, :alt)
+        else
+          elem = container.buttons[0] # celerity should really include Enumerable here
+        end
+        elem.click
+      end
+    end
+
+    webrat_deprecate :clicks_button, :click_button
+
+    def click_link(text_or_title_or_id, options = {})
+      with_handler options.delete(:confirm) do
+        elem = element_locator(text_or_title_or_id, :link, :text, :title, :id)
+        elem.click
+      end
+    end
+
+    webrat_deprecate :clicks_link, :click_link
+
+    def field_by_xpath(xpath)
+      element_locator(xpath, :generic_field, :xpath)
+    end
+
+    def field_labeled(label)
+      element_locator(label, :generic_field, :label)
+    end
+
+    def field_with_id(id)
+      element_locator(id, :generic_field, :id)
+    end
+
+    def fill_in(id_or_name_or_label, options = {})
+      elem = element_locator(id_or_name_or_label, :text_field)
+      elem.set(options[:with])
+    end
+
+    webrat_deprecate :fills_in, :fill_in
+
+    def response_body
+      container.html
+    end
+
+    def select(option_text, options = {})
+      elem = element_locator(options[:from], :select_list)
+      elem.select(option_text)
+    end
+
+    webrat_deprecate :selects, :select
+
+    def uncheck(id_or_name_or_label)
+      check(id_or_name_or_label, false)
+    end
+
+    webrat_deprecate :unchecks, :uncheck
+
+  protected
+
+    # Returns a +Culerity::Element+
+    def element_locator(locator, element, *how)
+      CulerityLocator.new(container, locator, element, *how).locate!
+    end
+
+    def with_handler(proc, &block)
+      old_handler = container.browser.webclient.confirm_handler
+      container.browser.webclient.confirm_handler = proc
+      block.call
+      container.browser.webclient.confirm_handler = old_handler
+    end
+  end
+end

data/lib/webrat/culerity/session.rb

@@ -0,0 +1,155 @@
+require "culerity"
+require "forwardable"
+require "webrat/core/save_and_open_page"
+
+module Webrat #:nodoc:
+  class CulerityResponse
+    attr_reader :body
+
+    def initialize(body)
+      @body = body
+    end
+  end
+
+  class CuleritySession #:nodoc:
+    include Webrat::SaveAndOpenPage
+    extend Forwardable
+
+    attr_reader :current_url
+
+    def initialize(*args) # :nodoc:
+    end
+
+    def response
+      CulerityResponse.new(response_body)
+    end
+
+    def visit(url = nil, http_method = :get, data = {})
+      reset
+      # TODO querify data
+      @current_url = container.goto(absolute_url(url))
+    end
+
+    webrat_deprecate :visits, :visit
+
+    def click_link_within(selector, text_or_title_or_id)
+      within(selector) do
+        click_link(text_or_title_or_id)
+      end
+    end
+
+    webrat_deprecate :clicks_link_within, :click_link_within
+
+    def reload
+      reset
+      container.refresh
+    end
+
+    webrat_deprecate :reloads, :reload
+
+    def clear_cookies
+      container.clear_cookies
+    end
+
+    def execute_script(source)
+      container.execute_script(source)
+    end
+
+    def current_scope
+      scopes.last || base_scope
+    end
+
+    def scopes
+      @_scopes ||= []
+    end
+
+    def base_scope
+      @_base_scope ||= CulerityScope.new(container)
+    end
+
+    def within(selector)
+      xpath = Webrat::XML.css_to_xpath(selector).first
+      scope = CulerityScope.new(container.element_by_xpath(xpath))
+      scopes.push(scope)
+      ret = yield
+      scopes.pop
+      return ret
+    end
+
+    def within_frame(name)
+      scope = CulerityScope.new(container.frame(:name => name))
+      scopes.push(scope)
+      if block_given?
+        ret = yield
+        scopes.pop
+        return ret
+      end
+      scope
+    end
+
+    def_delegators :current_scope, :check,         :checks
+    def_delegators :current_scope, :choose,        :chooses
+    def_delegators :current_scope, :click_button,  :clicks_button
+    def_delegators :current_scope, :click_link,    :clicks_link
+    def_delegators :current_scope, :fill_in,       :fills_in
+    def_delegators :current_scope, :field_by_xpath
+    def_delegators :current_scope, :field_labeled
+    def_delegators :current_scope, :field_with_id
+    def_delegators :current_scope, :response_body
+    def_delegators :current_scope, :select,        :selects
+    def_delegators :current_scope, :uncheck,       :unchecks
+
+  protected
+
+    def container
+      setup unless $setup_done
+      unless @_browser
+        @_server = ::Culerity::run_server
+        @_browser = ::Culerity::RemoteBrowserProxy.new @_server, {:browser => :firefox, :log_level => :off}
+        at_exit do
+          @_browser.exit
+          @_server.close
+        end
+      end
+      @_browser
+    end
+
+    def absolute_url(url) #:nodoc:
+      if url =~ Regexp.new('^https?://')
+        url
+      elsif url =~ Regexp.new('^/')
+        "#{current_host}#{url}"
+      else
+        "#{current_host}/#{url}"
+      end
+    end
+
+    def current_host
+      @_current_host ||= [Webrat.configuration.application_address, Webrat.configuration.application_port].join(":")
+    end
+
+    def setup #:nodoc:
+      silence_stream(STDOUT) do
+        Webrat.start_app_server
+      end
+      teardown_at_exit
+      $setup_done = true
+    end
+
+    def teardown_at_exit #:nodoc:
+      at_exit do
+        silence_stream(STDOUT) do
+          Webrat.stop_app_server
+        end
+      end
+    end
+
+  private
+
+    def reset
+      @_scopes     = nil
+      @_base_scope = nil
+    end
+
+  end
+end