watir-classic 3.0.0

data/lib/watir-classic/contrib/enabled_popup.rb

@@ -0,0 +1,21 @@
+# http://www.vbcity.com/forums/topic.asp?tid=108859
+require 'watir-classic/ie'
+module Watir
+  module PageContainer
+    include Win32
+    def enabled_popup(timeout=4)
+      # Use handle of our parent window to see if we have any currently
+      # enabled popup.
+      hwnd_modal = 0
+      Wait.until(timeout) do
+        hwnd_modal, arr = GetWindow.call(hwnd, GW_ENABLEDPOPUP)
+        hwnd_modal > 0
+      end
+      # use hwnd() method to find the IE or Container hwnd (overriden by IE)
+      if hwnd_modal == hwnd() || 0 == hwnd_modal
+        hwnd_modal = nil
+      end
+      hwnd_modal
+    end
+  end
+end

data/lib/watir-classic/contrib/ie-new-process.rb

@@ -0,0 +1,27 @@
+# based on http://svn.instiki.org/instiki/trunk/test/watir/e2e.rb
+# and http://rubyforge.org/pipermail/wtr-general/2005-November/004108.html
+
+require 'watir-classic/ie-process'
+
+class IEProcess < Watir::IE::Process 
+  def stop
+    right_to_terminate_process = 1
+    handle = Win32API.new('kernel32.dll', 'OpenProcess', 'lil', 'l').
+    call(right_to_terminate_process, 0, @process_id)
+    Win32API.new('kernel32.dll', 'TerminateProcess', 'll', 'l').call(handle, 0)
+  end
+  
+end
+
+module Watir
+  class IE
+    def process_id
+      @process_id ||= IEProcess.process_id_from_hwnd @ie.hwnd
+    end
+    attr_writer :process_id
+    def kill
+      iep = IEProcess.new process_id
+      iep.stop
+    end
+  end
+end

data/lib/watir-classic/contrib/page_checker.rb

@@ -0,0 +1,29 @@
+#  This module includes checkers which are run on every page load
+# 
+#  In order to use this module, add a require to one of your test scripts: 
+#  require 'watir-classic/contrib/page_checker'
+#  To add checkers, call the ie.add_checker method
+#
+#  ie.add_checker(PageCheckers::NAVIGATION_CHECKER)
+#
+#  Checkers are Ruby proc objects which are called within Watir::IE and passed 
+#  the current instance of ie. 
+
+module PageCheckers        
+
+	# This checker iterates through  the current document including any frames
+	# and checks for http errors, 404, 500 etc
+	NAVIGATION_CHECKER = lambda do |ie|
+		if ie.document.frames.length > 1
+			1.upto ie.document.frames.length do |i|
+				begin
+					ie.frame(:index, i).check_for_http_error
+				rescue Watir::Exception::UnknownFrameException
+					# frame can be already destroyed
+				end          
+			end
+		else
+			ie.check_for_http_error
+		end
+	end
+end

data/lib/watir-classic/cookies.rb

@@ -0,0 +1,80 @@
+require "uri"
+
+module Watir
+  class Cookies
+    include Enumerable
+
+    def initialize(page_container)
+      @page_container = page_container
+    end
+
+    def each
+      @page_container.document.cookie.split(";").each do |cookie|
+        name, value = cookie.strip.split("=")
+        yield({:name => name, :value => value})
+      end
+    end
+
+    def add name, value, options={}
+      options = options.map do |option|
+        k, v = option
+        if k == :expires
+          "#{k}=#{v.gmtime.strftime("%a, %d %b %Y %H:%M:%S UTC")}"
+        elsif k == :secure
+          "secure" if v
+        else
+          "#{k}=#{v}"
+        end
+      end.compact.join("; ")
+
+      options = "; #{options}" unless options.empty?
+      @page_container.document.cookie = "#{name}=#{value}#{options}" 
+    end
+
+    def delete name
+      options = {:expires => ::Time.now - 60 * 60 * 24}
+      delete_with_options name, options
+
+      # make sure that the cookie gets deleted
+      # there's got to be some easier way to do this
+      uri = URI.parse(@page_container.url)
+      domain = uri.host
+
+      paths = uri.path.split("/").reduce([]) do |paths, path|
+        paths << "#{paths.last}/#{path}".squeeze("/")
+      end << "/"
+
+      subdomains = domain.split(".").reverse.reduce([]) do |subdomains, part|
+        subdomain = "#{part}#{subdomains.last}"
+        subdomain = "." + subdomain unless subdomain == domain
+        subdomains << subdomain
+      end
+
+      subdomains.each do |subdomain|
+        domain_options = options.merge :domain => subdomain
+        delete_with_options name, domain_options
+        delete_with_options name, domain_options.merge(:secure => true)
+
+        paths.each do |path|
+          path_options = options.merge :path => path
+          delete_with_options name, path_options 
+          delete_with_options name, path_options.merge(:secure => true)
+
+          path_domain_options = domain_options.merge :path => path
+          delete_with_options name, path_domain_options 
+          delete_with_options name, path_domain_options.merge(:secure => true)
+        end
+      end
+    end
+
+    def clear
+      each {|cookie| delete cookie[:name]}
+    end
+
+    def delete_with_options name, options={}
+      add name, nil, options
+    end
+
+    private :delete_with_options
+  end
+end

data/lib/watir-classic/core.rb

@@ -0,0 +1,43 @@
+# these require statements are needed for Watir
+# to work with minimum functionality
+require 'timeout'
+require 'watir-classic/win32ole'
+
+# these are required already in commonwatir-classic, but not when using click_no_wait!
+require 'watir-classic/util'
+require 'watir-classic/exceptions'
+require 'watir-classic/matches'
+require 'watir-classic/wait'
+require 'watir-classic/wait_helper'
+require 'watir-classic/element_extensions'
+
+require 'logger'
+require 'watir-classic/logger'
+require 'watir-classic/container'
+require 'watir-classic/xpath_locator'
+require 'watir-classic/locator'
+require 'watir-classic/page-container'
+require 'watir-classic/ie-class'
+require 'watir-classic/drag_and_drop_helper'
+require 'watir-classic/element'
+require 'watir-classic/element_collection'
+require 'watir-classic/form'
+require 'watir-classic/frame'
+require 'watir-classic/input_elements'
+require 'watir-classic/non_control_elements'
+require 'watir-classic/table'
+require 'watir-classic/image'
+require 'watir-classic/link'
+require 'watir-classic/window'
+require 'watir-classic/cookies'
+
+require 'watir-classic/win32'
+require 'watir-classic/modal_dialog'
+
+require 'watir-classic/module'
+
+require 'rautomation'
+require 'watir-classic/dialogs/file_field'
+require 'watir-classic/dialogs/javascript'
+
+require 'watir-classic/supported_elements'

data/lib/watir-classic/dialogs/file_field.rb

@@ -0,0 +1,34 @@
+module Watir
+  class FileField < InputElement
+    def set(file_path)
+      assert_file_exists(file_path)
+      assert_exists
+      click_no_wait
+      set_file_name file_path.gsub(File::SEPARATOR, File::ALT_SEPARATOR)
+      open_button.click
+    end
+
+    alias_method :value=, :set
+
+    def assert_file_exists(file_path)
+      raise Errno::ENOENT, "#{file_path} has to exist to set!" unless File.exists?(file_path)
+    end
+
+    def set_file_name(path_to_file)
+      file_upload_window.text_field(:class => 'Edit', :index => 0).set path_to_file
+    end
+
+    def open_button
+      file_upload_window.button(:value => /&Open|&Abrir/)
+    end
+
+    def cancel_button
+      file_upload_window.button(:value => /Cancel/)
+    end
+
+    def file_upload_window
+      @window ||= RAutomation::Window.new(:title => /^choose file( to upload)?|Elegir archivos para cargar$/i)
+    end
+
+  end
+end

data/lib/watir-classic/dialogs/javascript.rb

@@ -0,0 +1,43 @@
+module Watir
+
+  class JavascriptDialog
+    WINDOW_TITLES = ['Message from webpage', 'Windows Internet Explorer','Microsoft Internet Explorer',/Mensaje de p.*/]
+
+    def initialize(opts={})
+      @opts = opts
+    end
+
+    def exists?
+      javascript_dialog_window.exists?
+    end
+
+    def button(value)
+      javascript_dialog_window.button(:value => value)
+    end
+
+    def close
+      javascript_dialog_window.close
+    end
+
+    def text
+      javascript_dialog_window.text
+    end
+
+    def javascript_dialog_window
+      @window ||= ::RAutomation::Window.new(:title => @opts[:title] || /^(#{WINDOW_TITLES.join('|')})$/)
+    end
+
+    Watir::Container.module_eval do
+      def javascript_dialog(opts={})
+        JavascriptDialog.new(opts)
+      end
+
+      alias_method :dialog, :javascript_dialog
+    end
+  end
+end
+
+
+
+
+

data/lib/watir-classic/drag_and_drop_helper.rb

@@ -0,0 +1,68 @@
+module Watir
+  module DragAndDropHelper
+
+    def drag_and_drop_on(target)
+      perform_action do
+        assert_target target
+        drop_x, drop_y = target.send :source_x_y
+        drag_to drop_x, drop_y
+      end
+    end
+
+    def drag_and_drop_by(distance_x, distance_y)
+      perform_action do
+        drag_x, drag_y = source_x_y
+        drag_to drag_x + distance_x, drag_y + distance_y
+      end
+    end
+
+    private
+
+    def drag_to(drop_x, drop_y)
+      drag_x, drag_y = source_x_y
+      mouse = page_container.rautomation.mouse
+      mouse.move :x => drag_x , :y => drag_y
+      mouse.press
+      mouse.move :x => drop_x, :y => drop_y
+      mouse.release
+    end
+
+    def source_x_y
+      center_x_y_absolute left_edge_absolute, top_edge_absolute
+    end
+
+    def assert_target(target)
+      target.assert_exists
+      target.assert_enabled
+    end
+
+    def top_edge
+      ole_object.getBoundingClientRect(0).top.to_i
+    end
+
+    def top_edge_absolute
+      top_edge + page_container.document.parentWindow.screenTop.to_i
+    end
+
+    def left_edge
+      ole_object.getBoundingClientRect(0).left.to_i
+    end
+
+    def left_edge_absolute
+      left_edge + page_container.document.parentWindow.screenLeft.to_i
+    end
+
+    def right_edge
+      ole_object.getBoundingClientRect(0).right.to_i
+    end
+
+    def bottom_edge
+      ole_object.getBoundingClientRect(0).bottom.to_i
+    end
+
+    def center_x_y_absolute x, y
+      return (right_edge - left_edge) / 2 + x, (bottom_edge - top_edge) / 2 + y
+    end
+
+  end
+end

data/lib/watir-classic/element.rb

@@ -0,0 +1,438 @@
+module Watir
+  # Base class for html elements.
+  # This is not a class that users would normally access.
+  class Element # Wrapper
+    include Comparable
+    include ElementExtensions
+    include Exception
+    include Container # presumes @container is defined
+    include DragAndDropHelper
+
+    attr_accessor :container
+
+    # number of spaces that separate the property from the value in the to_s method
+    TO_S_SIZE = 14
+
+    def initialize(container, specifiers)
+      set_container container
+      raise ArgumentError, "#{specifiers.inspect} has to be Hash" unless specifiers.is_a?(Hash)
+
+      @o = specifiers[:ole_object]
+      @specifiers = specifiers
+    end
+
+    def <=> other
+      assert_exists
+      other.assert_exists
+      ole_object.sourceindex <=> other.ole_object.sourceindex
+    end
+
+    alias_method :eql?, :==
+
+    def locate
+      @o = @container.locator_for(TaggedElementLocator, @specifiers, self.class).locate
+    end  
+
+    # Return the ole object, allowing any methods of the DOM that Watir doesn't support to be used.
+    def ole_object
+      @o
+    end
+
+    def ole_object=(o)
+      @o = o
+    end
+
+    def inspect
+      '#<%s:0x%x located=%s specifiers=%s>' % [self.class, hash*2, !!ole_object, @specifiers.inspect]
+    end
+
+    private
+
+    def self.attr_ole(method_name, ole_method_name=nil)
+      class_eval %Q[
+        def #{method_name}
+          assert_exists
+          ole_method_name = '#{ole_method_name || method_name.to_s.gsub(/\?$/, '')}'
+          ole_object.invoke(ole_method_name) rescue attribute_value(ole_method_name) || '' rescue ''
+        end]
+    end
+
+    public
+
+    def assert_exists
+      locate
+      unless ole_object
+        exception_class = self.is_a?(Frame) ? UnknownFrameException : UnknownObjectException
+        raise exception_class.new(Watir::Exception.message_for_unable_to_locate(@specifiers))
+      end
+    end
+
+    def assert_enabled
+      raise ObjectDisabledException, "object #{@specifiers.inspect} is disabled" unless enabled?
+    end
+
+    # return the id of the element
+    attr_ole :id
+    # return the title of the element
+    attr_ole :title
+    # return the class name of the element
+    # raise an ObjectNotFound exception if the object cannot be found
+    attr_ole :class_name, :className
+    # return the unique COM number for the element
+    attr_ole :unique_number, :uniqueNumber
+    # Return the outer html of the object - see http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/outerhtml.asp?frame=true
+    attr_ole :html, :outerHTML
+
+    def tag_name
+      assert_exists
+      @o.tagName.downcase
+    end
+
+    # returns specific Element subclass for current Element
+    def to_subtype
+      assert_exists
+
+      tag = tag_name
+      if tag == "html"
+        element(:ole_object => ole_object)
+      elsif tag == "input"
+        send(ole_object.invoke('type'), :ole_object => ole_object)
+      elsif tag == "select"
+        select_list(:ole_object => ole_object)
+      elsif respond_to?(tag.downcase)
+        send(tag.downcase, :ole_object => ole_object)
+      else
+        self
+      end
+    end
+
+    # send keys to element
+    def send_keys(*keys)
+      focus
+      page_container.send_keys *keys
+    end
+
+    # return the css style as a string
+    def style
+      assert_exists
+      ole_object.style.cssText
+    end
+
+    # Return the innerText of the object or an empty string if the object is
+    # not visible
+    # Raise an ObjectNotFound exception if the object cannot be found
+    def text
+      assert_exists
+      visible? ? ole_object.innerText.strip : ""
+    end
+
+    def __ole_inner_elements
+      assert_exists
+      ole_object.all
+    end
+
+    def document
+      assert_exists
+      ole_object
+    end
+
+    # Return the element immediately containing self. 
+    def parent
+      assert_exists
+      parent_element = ole_object.parentelement
+      return unless parent_element
+      Element.new(self, :ole_object => parent_element).to_subtype
+    end
+
+    def typingspeed
+      @container.typingspeed
+    end
+
+    def type_keys
+      @type_keys || @container.type_keys
+    end
+
+    def activeObjectHighLightColor
+      @container.activeObjectHighLightColor
+    end
+
+    # Return an array with many of the properties, in a format to be used by the to_s method
+    def string_creator
+      n = []
+      n <<   "id:".ljust(TO_S_SIZE) +         self.id.to_s
+      return n
+    end
+
+    private :string_creator
+
+    # Display basic details about the object. Sample output for a button is shown.
+    # Raises UnknownObjectException if the object is not found.
+    #      name      b4
+    #      type      button
+    #      id         b5
+    #      value      Disabled Button
+    #      disabled   true
+    def to_s
+      assert_exists
+      return string_creator.join("\n")
+    end
+
+    # This method is responsible for setting and clearing the colored highlighting on the currently active element.
+    # use :set   to set the highlight
+    #   :clear  to clear the highlight
+    # TODO: Make this two methods: set_highlight & clear_highlight
+    # TODO: Remove begin/rescue blocks
+    def highlight(set_or_clear)
+      if set_or_clear == :set
+        begin
+          @original_color ||= ole_object.style.backgroundColor
+          ole_object.style.backgroundColor = @container.activeObjectHighLightColor
+        rescue
+          @original_color = nil
+        end
+      else
+        begin
+          ole_object.style.backgroundColor = @original_color if @original_color
+        rescue
+          # we could be here for a number of reasons...
+          # e.g. page may have reloaded and the reference is no longer valid
+        ensure
+          @original_color = nil
+        end
+      end
+    end
+
+    private :highlight
+
+    #   This method clicks the active element.
+    #   raises: UnknownObjectException  if the object is not found
+    #   ObjectDisabledException if the object is currently disabled
+    def click
+      click!
+      @container.wait
+    end
+
+    def right_click
+      perform_action {fire_event("oncontextmenu"); @container.wait}
+    end
+
+    def double_click
+      perform_action {fire_event("ondblclick"); @container.wait}
+    end
+
+    def replace_method(method)
+      method == 'click' ? 'click!' : method
+    end
+
+    private :replace_method
+
+    def build_method(method_name, *args)
+      arguments = args.map do |argument|
+        if argument.is_a?(String)
+          argument = "'#{argument}'"  
+        else
+          argument = argument.inspect
+        end
+      end
+      "#{replace_method(method_name)}(#{arguments.join(',')})"
+    end
+
+    private :build_method
+
+    def generate_ruby_code(element, method_name, *args)
+      # needs to be done like this to avoid segfault on ruby 1.9.3
+      tag_name = @specifiers[:tag_name].join("' << '")
+      element = "#{self.class}.new(#{@page_container.attach_command}, :tag_name => Array.new << '#{tag_name}', :unique_number => #{unique_number})"
+      method = build_method(method_name, *args)
+      ruby_code = "$:.unshift(#{$LOAD_PATH.map {|p| "'#{p}'" }.join(").unshift(")});" <<
+                    "require '#{File.expand_path(File.dirname(__FILE__))}/core';#{element}.#{method};"
+      ruby_code
+    end
+
+    private :generate_ruby_code
+
+    def spawned_no_wait_command(command)
+      command = "-e #{command.inspect}"
+      unless $DEBUG
+        "start rubyw #{command}"
+      else
+        puts "#no_wait command:"
+        command = "ruby #{command}"
+        puts command
+        command
+      end
+    end
+
+    private :spawned_no_wait_command
+
+    def click!
+      perform_action do
+        # Not sure why but in IE9 Document mode, passing a parameter
+        # to click seems to work. Firing the onClick event breaks other tests
+        # so this seems to be the safest change and also works fine in IE8
+        ole_object.click(0)
+      end
+    end
+
+    # Flash the element the specified number of times.
+    # Defaults to 10 flashes.
+    def flash number=10
+      assert_exists
+      number.times do
+        highlight(:set)
+        sleep 0.05
+        highlight(:clear)
+        sleep 0.05
+      end
+      nil
+    end
+
+    # Executes a user defined "fireEvent" for objects with JavaScript events tied to them such as DHTML menus.
+    #   usage: allows a generic way to fire javascript events on page objects such as "onMouseOver", "onClick", etc.
+    #   raises: UnknownObjectException  if the object is not found
+    #           ObjectDisabledException if the object is currently disabled
+    def fire_event(event)
+      perform_action {dispatch_event(event); @container.wait}
+    end
+
+    def dispatch_event(event)
+      assert_exists
+
+      if IE.version_parts.first.to_i >= 9 && container.page_container.document.documentMode.to_i >= 9
+        ole_object.dispatchEvent(create_event(event))
+      else
+        ole_object.fireEvent(event)
+      end
+    end
+
+    def create_event(event)
+     event =~ /on(.*)/i
+     event = $1 if $1
+     event.downcase!
+     # See http://www.howtocreate.co.uk/tutorials/javascript/domevents
+     case event
+       when 'abort', 'blur', 'change', 'error', 'focus', 'load',
+            'reset', 'resize', 'scroll', 'select', 'submit', 'unload'
+         event_name = :initEvent
+         event_type = 'HTMLEvents'
+         event_args = [event, true, true]
+       when 'select'
+         event_name = :initUIEvent
+         event_type = 'UIEvent'
+         event_args = [event, true, true, @container.page_container.document.parentWindow.window,0]
+       when 'keydown', 'keypress', 'keyup'
+         event_name = :initKeyboardEvent
+         event_type = 'KeyboardEvent'
+         # 'type', bubbles, cancelable, windowObject, ctrlKey, altKey, shiftKey, metaKey, keyCode, charCode
+         event_args = [event, true, true, @container.page_container.document.parentWindow.window, false, false, false, false, 0, 0]
+       when 'click', 'dblclick', 'mousedown', 'mousemove', 'mouseout', 'mouseover', 'mouseup',
+            'contextmenu', 'drag', 'dragstart', 'dragenter', 'dragover', 'dragleave', 'dragend', 'drop', 'selectstart'
+         event_name = :initMouseEvent
+         event_type = 'MouseEvents'
+         # 'type', bubbles, cancelable, windowObject, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget
+         event_args = [event, true, true, @container.page_container.document.parentWindow.window, 1, 0, 0, 0, 0, false, false, false, false, 0, @container.page_container.document]
+       else
+         raise UnhandledEventException, "Don't know how to trigger event '#{event}'"
+     end
+     event = @container.page_container.document.createEvent(event_type)
+     event.send event_name, *event_args
+     event
+   end
+
+    # This method sets focus on the active element.
+    #   raises: UnknownObjectException  if the object is not found
+    #           ObjectDisabledException if the object is currently disabled
+    def focus
+      assert_exists
+      assert_enabled
+      @page_container.focus
+      ole_object.focus(0)
+    end
+
+    def focused?
+      assert_exists
+      assert_enabled
+      @page_container.document.activeElement.uniqueNumber == unique_number
+    end
+
+    # Returns whether this element actually exists.
+    def exists?
+      begin
+        locate
+      rescue WIN32OLERuntimeError, UnknownObjectException
+        @o = nil
+      end
+      !!@o
+    end
+
+    alias :exist? :exists?
+
+    # Returns true if the element is enabled, false if it isn't.
+    #   raises: UnknownObjectException  if the object is not found
+    def enabled?
+      assert_exists
+      !disabled?
+    end
+
+    def disabled?
+      assert_exists
+      false
+    end
+
+    # If any parent element isn't visible then we cannot write to the
+    # element. The only realiable way to determine this is to iterate
+    # up the DOM element tree checking every element to make sure it's
+    # visible.
+    def visible?
+      # Now iterate up the DOM element tree and return false if any
+      # parent element isn't visible 
+      assert_exists
+      object = @o
+      while object
+        begin
+          if object.currentstyle.invoke('visibility') =~ /^hidden$/i
+            return false
+          end
+          if object.currentstyle.invoke('display') =~ /^none$/i
+            return false
+          end
+        rescue WIN32OLERuntimeError
+        end
+        object = object.parentElement
+      end
+      true
+    end
+
+    # Get attribute value for any attribute of the element.
+    # Returns null if attribute doesn't exist.
+    def attribute_value(attribute_name)
+      assert_exists
+      ole_object.getAttribute(attribute_name)
+    end
+
+    def perform_action
+      assert_exists
+      assert_enabled
+      highlight(:set)
+      yield
+      highlight(:clear)
+    end
+
+    private :perform_action
+
+    def method_missing(method_name, *args, &block)
+      meth = method_name.to_s
+      if meth =~ /(.*)_no_wait/ && self.respond_to?($1)
+        perform_action do
+          ruby_code = generate_ruby_code(self, $1, *args)
+          system(spawned_no_wait_command(ruby_code))
+        end
+      elsif meth =~ /^data_(.*)/
+        self.send(:attribute_value, meth.gsub("_", "-")) || ''
+      else
+        super
+      end
+    end
+      
+  end
+end