mkuklis-webrat 0.5.1

data/lib/webrat/core/elements/field.rb

@@ -0,0 +1,487 @@
+require "cgi"
+require "webrat/core_extensions/blank"
+require "webrat/core_extensions/nil_to_param"
+
+require "webrat/core/elements/element"
+
+module Webrat
+  # Raised when Webrat is asked to manipulate a disabled form field
+  class DisabledFieldError < WebratError
+  end
+
+  class Field < Element #:nodoc:
+    attr_reader :value
+
+    def self.xpath_search
+      [".//button", ".//input", ".//textarea", ".//select"]
+    end
+
+    def self.xpath_search_excluding_hidden
+      [".//button", ".//input[ @type != 'hidden']", ".//textarea", ".//select"]
+    end
+
+    def self.field_classes
+      @field_classes || []
+    end
+
+    def self.inherited(klass)
+      @field_classes ||= []
+      @field_classes << klass
+      # raise args.inspect
+    end
+
+    def self.load(session, element)
+      return nil if element.nil?
+      session.elements[element.path] ||= field_class(element).new(session, element)
+    end
+
+    def self.field_class(element)
+      case element.name
+      when "button"   then ButtonField
+      when "select"
+        if element.attributes["multiple"].nil?
+          SelectField
+        else
+          MultipleSelectField
+        end
+      when "textarea" then TextareaField
+      else
+        case element["type"]
+        when "checkbox" then CheckboxField
+        when "hidden"   then HiddenField
+        when "radio"    then RadioField
+        when "password" then PasswordField
+        when "file"     then FileField
+        when "reset"    then ResetField
+        when "submit"   then ButtonField
+        when "button"   then ButtonField
+        when "image"    then ButtonField
+        else  TextField
+        end
+      end
+    end
+
+    def initialize(*args)
+      super
+      @value = default_value
+    end
+
+    def label_text
+      return nil if labels.empty?
+      labels.first.text
+    end
+
+    def id
+      @element["id"]
+    end
+
+    def disabled?
+      @element.attributes.has_key?("disabled") && @element["disabled"] != 'false'
+    end
+
+    def raise_error_if_disabled
+      return unless disabled?
+      raise DisabledFieldError.new("Cannot interact with disabled form element (#{self})")
+    end
+
+    def to_param
+      return nil if disabled?
+
+      params = case Webrat.configuration.mode
+      when :rails
+        parse_rails_request_params("#{name}=#{escaped_value}")
+      when :merb
+        ::Merb::Parse.query("#{name}=#{escaped_value}")
+      else
+        { name => [*@value].first.to_s }
+      end
+
+      unescape_params(params)
+    end
+
+    def set(value)
+      @value = value
+    end
+
+    def unset
+      @value = default_value
+    end
+
+  protected
+
+    def parse_rails_request_params(params)
+      if defined?(ActionController::AbstractRequest)
+        ActionController::AbstractRequest.parse_query_parameters(params)
+      elsif defined?(ActionController::UrlEncodedPairParser)
+        # For Rails > 2.2
+        ActionController::UrlEncodedPairParser.parse_query_parameters(params)
+      else
+        # For Rails > 2.3
+        Rack::Utils.parse_nested_query(params)
+      end
+    end
+
+    def form
+      Form.load(@session, form_element)
+    end
+
+    def form_element
+      parent = @element.parent
+
+      while parent.respond_to?(:parent)
+        return parent if parent.name == 'form'
+        parent = parent.parent
+      end
+    end
+
+    def name
+      @element["name"]
+    end
+
+    def escaped_value
+      CGI.escape(@value.to_s)
+    end
+
+    # Because we have to escape it before sending it to the above case statement,
+    # we have to make sure we unescape each value when it gets back so assertions
+    # involving characters like <, >, and &  work as expected
+    def unescape_params(params)
+      case params.class.name
+      when 'Hash', 'Mash'
+        params.each { |key,value| params[key] = unescape_params(value) }
+        params
+      when 'Array'
+        params.collect { |value| unescape_params(value) }
+      else
+        CGI.unescapeHTML(params)
+      end
+    end
+
+    def labels
+      @labels ||= label_elements.map do |element|
+        Label.load(@session, element)
+      end
+    end
+
+    def label_elements
+      return @label_elements unless @label_elements.nil?
+      @label_elements = []
+
+      parent = @element.parent
+      while parent.respond_to?(:parent)
+        if parent.name == 'label'
+          @label_elements.push parent
+          break
+        end
+        parent = parent.parent
+      end
+
+      unless id.blank?
+        @label_elements += form.element.xpath(".//label[@for = '#{id}']")
+      end
+
+      @label_elements
+    end
+
+    def default_value
+      @element["value"]
+    end
+
+    def replace_param_value(params, oval, nval)
+      output = Hash.new
+      params.each do |key, value|
+        case value
+        when Hash
+          value = replace_param_value(value, oval, nval)
+        when Array
+          value = value.map { |o| o == oval ? nval : oval }
+        when oval
+          value = nval
+        end
+        output[key] = value
+      end
+      output
+    end
+  end
+
+  class ButtonField < Field #:nodoc:
+
+    def self.xpath_search
+      [".//button", ".//input[@type = 'submit']", ".//input[@type = 'button']", ".//input[@type = 'image']"]
+    end
+
+    def to_param
+      return nil if @value.nil?
+      super
+    end
+
+    def default_value
+      nil
+    end
+
+    def click
+      raise_error_if_disabled
+      set(@element["value"]) unless @element["name"].blank?
+      form.submit
+    end
+
+  end
+
+  class HiddenField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//input[@type = 'hidden']"
+    end
+
+    def to_param
+      if collection_name?
+        super
+      else
+        checkbox_with_same_name = form.field_named(name, CheckboxField)
+
+        if checkbox_with_same_name.to_param.blank?
+          super
+        else
+          nil
+        end
+      end
+    end
+
+  protected
+
+    def collection_name?
+      name =~ /\[\]/
+    end
+
+  end
+
+  class CheckboxField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//input[@type = 'checkbox']"
+    end
+
+    def to_param
+      return nil if @value.nil?
+      super
+    end
+
+    def check
+      raise_error_if_disabled
+      set(@element["value"] || "on")
+    end
+
+    def checked?
+      @element["checked"] == "checked"
+    end
+
+    def uncheck
+      raise_error_if_disabled
+      set(nil)
+    end
+
+  protected
+
+    def default_value
+      if @element["checked"] == "checked"
+        @element["value"] || "on"
+      else
+        nil
+      end
+    end
+
+  end
+
+  class PasswordField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//input[@type = 'password']"
+    end
+
+  end
+
+  class RadioField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//input[@type = 'radio']"
+    end
+
+    def to_param
+      return nil if @value.nil?
+      super
+    end
+
+    def choose
+      raise_error_if_disabled
+      other_options.each do |option|
+        option.set(nil)
+      end
+
+      set(@element["value"] || "on")
+    end
+
+    def checked?
+      @element["checked"] == "checked"
+    end
+
+  protected
+
+    def other_options
+      form.fields.select { |f| f.name == name }
+    end
+
+    def default_value
+      if @element["checked"] == "checked"
+        @element["value"] || "on"
+      else
+        nil
+      end
+    end
+
+  end
+
+  class TextareaField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//textarea"
+    end
+
+  protected
+
+    def default_value
+      @element.inner_html
+    end
+
+  end
+
+  class FileField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//input[@type = 'file']"
+    end
+
+    attr_accessor :content_type
+
+    def set(value, content_type = nil)
+      super(value)
+      @content_type = content_type
+    end
+
+    def to_param
+      if @value.nil?
+        super
+      else
+        replace_param_value(super, @value, test_uploaded_file)
+      end
+    end
+
+  protected
+
+    def test_uploaded_file
+      case Webrat.configuration.mode
+      when :rails
+        if content_type
+          ActionController::TestUploadedFile.new(@value, content_type)
+        else
+          ActionController::TestUploadedFile.new(@value)
+        end
+      when :rack, :merb
+        Rack::Test::UploadedFile.new(@value, content_type)
+      end
+    end
+
+  end
+
+  class TextField < Field #:nodoc:
+    def self.xpath_search
+      [".//input[@type = 'text']", ".//input[not(@type)]"]
+    end
+  end
+
+  class ResetField < Field #:nodoc:
+    def self.xpath_search
+      [".//input[@type = 'reset']"]
+    end
+  end
+
+  class SelectField < Field #:nodoc:
+
+    def self.xpath_search
+      [".//select[not(@multiple)]"]
+    end
+
+    def options
+      @options ||= SelectOption.load_all(@session, @element)
+    end
+
+    def unset(value)
+      @value = nil
+    end
+
+  protected
+
+    def default_value
+      selected_options = @element.xpath(".//option[@selected = 'selected']")
+      selected_options = @element.xpath(".//option[position() = 1]") if selected_options.empty?
+
+      selected_options.map do |option|
+        return "" if option.nil?
+        option["value"] || option.inner_html
+      end.uniq.first
+    end
+
+  end
+
+  class MultipleSelectField < Field #:nodoc:
+
+    def self.xpath_search
+      [".//select[@multiple='multiple']"]
+    end
+
+    def options
+      @options ||= SelectOption.load_all(@session, @element)
+    end
+
+    def set(value)
+      @value << value
+    end
+
+    def unset(value)
+      @value.delete(value)
+    end
+
+    # We have to overide how the uri string is formed when dealing with multiples
+    # Where normally a select field might produce   name=value   with a multiple,
+    # we need to form something like   name[]=value1&name[]=value2
+    def to_param
+      return nil if disabled?
+
+      uri_string = @value.collect {|value| "#{name}=#{CGI.escape(value)}"}.join("&")
+      params = case Webrat.configuration.mode
+      when :rails
+        parse_rails_request_params(uri_string)
+      when :merb
+        ::Merb::Parse.query(uri_string)
+      else
+        { name => @value }
+      end
+
+      unescape_params(params)
+    end
+
+  protected
+
+    # Overwrite SelectField definition because we don't want to select the first option
+    # (mutliples don't select the first option unlike their non multiple versions)
+    def default_value
+      selected_options = @element.xpath(".//option[@selected = 'selected']")
+
+      selected_options.map do |option|
+        return "" if option.nil?
+        option["value"] || option.inner_html
+      end.uniq
+    end
+
+  end
+
+end

data/lib/webrat/core/elements/form.rb

@@ -0,0 +1,103 @@
+require "webrat/core/elements/field"
+require "webrat/core_extensions/blank"
+
+require "webrat/core/elements/element"
+require "webrat/core/locators/field_named_locator"
+
+module Webrat
+  class Form < Element #:nodoc:
+    attr_reader :element
+
+    def self.xpath_search
+      [".//form"]
+    end
+
+    def fields
+      @fields ||= Field.load_all(@session, @element)
+    end
+
+    def submit
+      @session.request_page(form_action, form_method, params)
+    end
+
+    def field_named(name, *field_types)
+      Webrat::Locators::FieldNamedLocator.new(@session, dom, name, *field_types).locate
+    end
+
+  protected
+
+    def dom
+      @session.dom.xpath(path).first
+    end
+
+    def fields_by_type(field_types)
+      if field_types.any?
+        fields.select { |f| field_types.include?(f.class) }
+      else
+        fields
+      end
+    end
+
+    def params
+      all_params = {}
+
+      fields.each do |field|
+        next if field.to_param.nil?
+        merge(all_params, field.to_param)
+      end
+
+      all_params
+    end
+
+    def form_method
+      @element["method"].blank? ? :get : @element["method"].downcase
+    end
+
+    def form_action
+      @element["action"].blank? ? @session.current_url : @element["action"]
+    end
+
+    def merge(all_params, new_param)
+      new_param.each do |key, value|
+        case all_params[key]
+        when *hash_classes
+          merge_hash_values(all_params[key], value)
+        when Array
+          all_params[key] += value
+        else
+          all_params[key] = value
+        end
+      end
+    end
+
+    def merge_hash_values(a, b) # :nodoc:
+      a.keys.each do |k|
+        if b.has_key?(k)
+          case [a[k], b[k]].map{|value| value.class}
+          when *hash_classes.zip(hash_classes)
+            a[k] = merge_hash_values(a[k], b[k])
+            b.delete(k)
+          when [Array, Array]
+            a[k] += b[k]
+            b.delete(k)
+          end
+        end
+      end
+      a.merge!(b)
+    end
+
+    def hash_classes
+      klasses = [Hash]
+
+      case Webrat.configuration.mode
+      when :rails
+        klasses << HashWithIndifferentAccess
+      when :merb
+        klasses << Mash
+      end
+
+      klasses
+    end
+
+  end
+end

data/lib/webrat/core/elements/label.rb

@@ -0,0 +1,31 @@
+require "webrat/core/elements/element"
+
+module Webrat
+  class Label < Element #:nodoc:
+
+    attr_reader :element
+
+    def self.xpath_search
+      [".//label"]
+    end
+
+    def for_id
+      @element["for"]
+    end
+
+    def field
+      Field.load(@session, field_element)
+    end
+
+  protected
+
+    def field_element
+      if for_id.blank?
+        @element.xpath(*Field.xpath_search_excluding_hidden).first
+      else
+        @session.current_dom.css("#" + for_id).first
+      end
+    end
+
+  end
+end

data/lib/webrat/core/elements/link.rb

@@ -0,0 +1,93 @@
+require "English"
+
+require "webrat/core_extensions/blank"
+require "webrat/core/elements/element"
+
+module Webrat
+  class Link < Element #:nodoc:
+
+    def self.xpath_search
+      [".//a[@href]"]
+    end
+
+    def click(options = {})
+      method = options[:method] || http_method
+      return if href =~ /^#/ && method == :get
+
+      options[:javascript] = true if options[:javascript].nil?
+
+      if options[:javascript]
+        @session.request_page(absolute_href, method, data)
+      else
+        @session.request_page(absolute_href, :get, {})
+      end
+    end
+
+  protected
+
+    def id
+      @element["id"]
+    end
+
+    def data
+      authenticity_token.blank? ? {} : {"authenticity_token" => authenticity_token}
+    end
+
+    def title
+      @element["title"]
+    end
+
+    def href
+      @element["href"]
+    end
+
+    def absolute_href
+      if href =~ /^\?/
+        "#{@session.current_url}#{href}"
+      elsif href !~ %r{^https?://} && (href !~ /^\//)
+        "#{@session.current_url}/#{href}"
+      else
+        href
+      end
+    end
+
+    def authenticity_token
+      return unless onclick && onclick.include?("s.setAttribute('name', 'authenticity_token');") &&
+        onclick =~ /s\.setAttribute\('value', '([a-f0-9]{40})'\);/
+      $LAST_MATCH_INFO.captures.first
+    end
+
+    def onclick
+      @element["onclick"]
+    end
+
+    def http_method
+      if !onclick.blank? && onclick.include?("f.submit()")
+        http_method_from_js_form
+      else
+        :get
+      end
+    end
+
+    def http_method_from_js_form
+      if onclick.include?("m.setAttribute('name', '_method')")
+        http_method_from_fake_method_param
+      else
+        :post
+      end
+    end
+
+    def http_method_from_fake_method_param
+      if onclick.include?("m.setAttribute('value', 'delete')")
+        :delete
+      elsif onclick.include?("m.setAttribute('value', 'put')")
+        :put
+      elsif onclick.include?("m.setAttribute('value', 'post')")
+        :post
+      else
+        raise Webrat::WebratError.new("No HTTP method for _method param in #{onclick.inspect}")
+      end
+    end
+
+  end
+end