vapir-ie 1.7.0.rc1

data/lib/vapir-ie/ie-process.rb

@@ -0,0 +1,60 @@
+require 'win32/process'
+require 'vapir-ie/ie-class'
+
+module Vapir
+  class IE
+    # the version string, from the registry key HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\Version
+    def self.version
+      @@ie_version ||= begin
+        require 'win32/registry'
+        ::Win32::Registry::HKEY_LOCAL_MACHINE.open("SOFTWARE\\Microsoft\\Internet Explorer") do |ie_key|
+          ie_key.read('Version').last
+        end
+        # OR: ::WIN32OLE.new("WScript.Shell").RegRead("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Internet Explorer\\Version")
+      end
+    end
+    # the version string divided into its numeric parts returned as an array of integers 
+    def self.version_parts
+      @@ie_version_parts ||= IE.version.split('.').map{|part| part.to_i }
+    end
+    class Process
+      # Vapir::IE::Process.start is called by Vapir::IE.new_process and does not start a new process correctly in IE8. 
+      # Calling IE8 with the -nomerge option correctly starts a new process, so call Process.create with this option if 
+      # IE's version is 8 
+      def self.start
+        program_files = ENV['ProgramFiles'] || "c:\\Program Files"
+        startup_command = "#{program_files}\\Internet Explorer\\iexplore.exe"
+        startup_command << " -nomerge" if ::Vapir::IE.version_parts.first==8
+        # maybe raise an error here if it's > 8, as not-yet-supported? who knows what incompatibilities the future will hold 
+        process_info = ::Process.create('app_name' => "#{startup_command} about:blank")
+        process_id = process_info.process_id
+        new process_id
+      end
+      
+      def initialize process_id
+        @process_id = process_id
+      end
+      attr_reader :process_id
+      
+      def window
+        Waiter.wait_until do
+          IE.each do | ie |
+            window = ie.ie
+            hwnd = ie.hwnd
+            process_id = Process.process_id_from_hwnd hwnd
+            return window if process_id == @process_id
+          end
+        end
+      end
+      
+      # Returns the process id for the specifed hWnd.
+      def self.process_id_from_hwnd hwnd
+        pid_info = ' ' * 32
+        Win32API.new('user32', 'GetWindowThreadProcessId', 'ip', 'i').
+        call(hwnd, pid_info)
+        process_id =  pid_info.unpack("L")[0]
+      end
+      
+    end
+  end
+end

data/lib/vapir-ie/image.rb

@@ -0,0 +1,59 @@
+require 'vapir-ie/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  
+  # This class is the means of accessing an image on a page.
+  # Normally a user would not need to create this object as it is returned by the Vapir::Container#image method
+  #
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class IE::Image < IE::Element
+    include Vapir::Image
+    
+    dom_attr :fileSize => :file_size
+    dom_attr :fileCreatedDate => :file_created_date
+    
+    # This method attempts to find out if the image was actually loaded by the web browser.
+    # If the image was not loaded, the browser is unable to determine some of the properties.
+    # We look for these missing properties to see if the image is really there or not.
+    # If the Disk cache is full (tools menu -> Internet options -> Temporary Internet Files), it may produce incorrect responses.
+    def loaded?
+      assert_exists do
+        !(element_object.fileCreatedDate == "" and element_object.fileSize.to_i == -1)
+      end
+    end
+    alias_deprecated :hasLoaded?, :loaded?
+    
+    # This method saves the image to the file path that is given.  The
+    # path must be in windows format (c:\\dirname\\somename.gif).  This method
+    # will not overwrite a previously existing image.  If an image already
+    # exists at the given path then a dialog will be displayed prompting
+    # for overwrite.
+    # Raises a VapirException if AutoIt is not correctly installed
+    # path - directory path and file name of where image should be saved
+    def save(path)
+    # TODO: FIX
+      require 'vapir-ie/windowhelper'
+      WindowHelper.check_autoit_installed
+      @container.goto(src)
+      begin
+        thrd = fill_save_image_dialog(path)
+        @container.document.execCommand("SaveAs")
+        thrd.join(5)
+      ensure
+        @container.back
+      end
+    end
+    
+    def fill_save_image_dialog(path)
+      raise NotImplementedError
+      #todo: FIX
+      Thread.new do
+        system("ruby -e \"require 'win32ole'; @autoit=WIN32OLE.new('AutoItX3.Control'); waitresult=@autoit.WinWait 'Save Picture', '', 15; if waitresult == 1\" -e \"@autoit.ControlSetText 'Save Picture', '', '1148', '#{path}'; @autoit.ControlSend 'Save Picture', '', '1', '{ENTER}';\" -e \"end\"")
+      end
+    end
+    private :fill_save_image_dialog
+  end
+  
+end

data/lib/vapir-ie/input_elements.rb

@@ -0,0 +1,158 @@
+require 'vapir-ie/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  
+  class IE::InputElement < IE::Element
+    include InputElement
+  end
+
+  #
+  # Input: Select
+  #
+  
+  # This class is the way in which select boxes are manipulated.
+  # Normally a user would not need to create this object as it is returned by the Vapir::Container#select_list method
+  class IE::SelectList < IE::InputElement
+    include SelectList
+  end
+  
+  # An item in a select list
+  class IE::Option < IE::Element
+    include Option
+  end
+  
+  # 
+  # Input: Button
+  #
+  
+  # Returned by the Vapir::Container#button method
+  class IE::Button < IE::InputElement
+    include Button
+    dom_attr :value => :caption
+  end
+
+  #
+  # Input: Text
+  #
+  
+  # This class is the main class for Text Fields
+  # Normally a user would not need to create this object as it is returned by the Vapir::Container#text_field method
+  class IE::TextField < IE::InputElement
+    include TextField
+#    def_wrap_guard :size
+    
+    # Returns true if the text field contents is matches the specified target,
+    # which can be either a string or a regular expression.
+    #   Raises UnknownObjectException if the object can't be found
+    #
+    # TODO: move to common 
+    def verify_contains(target) # FIXME: verify_contains should have same name and semantics as IE#contains_text (prolly make this work for all elements)
+      assert_exists do
+        if target.kind_of? String
+          return true if self.value == target
+        elsif target.kind_of? Regexp
+          return true if self.value.match(target) != nil
+        end
+        return false
+      end
+    end
+    
+    # Drag the entire contents of the text field to another text field
+    #  19 Jan 2005 - It is added as prototype functionality, and may change
+    #   * destination_how   - symbol, :id, :name how we identify the drop target
+    #   * destination_what  - string or regular expression, the name, id, etc of the text field that will be the drop target
+    def drag_contents_to(destination_how, destination_what)
+      assert_exists do
+        destination = @container.text_field!(destination_how, destination_what)
+        
+        element_object.focus
+        element_object.select
+        value = self.value
+        
+        with_highlight do
+          fire_event("onSelect")
+          fire_event("ondragstart")
+          fire_event("ondrag")
+          destination.with_highlight do
+            destination.fire_event("onDragEnter")
+            destination.fire_event("onDragOver")
+            destination.fire_event("ondrop")
+            destination.value = destination.value + value.to_s
+          end
+          fire_event("ondragend")
+          self.value = ""
+        end
+        
+      end
+    end
+    alias_deprecated :dragContentsTo, :drag_contents_to
+    
+    def requires_typing
+      @type_keys = true
+      self
+    end
+    def abhors_typing
+      @type_keys = false
+      self
+    end
+  end
+  
+  # this class can be used to access hidden field objects
+  # Normally a user would not need to create this object as it is returned by the Vapir::Container#hidden method
+  class IE::Hidden < IE::TextField
+    include Hidden
+  end
+  
+  # For fields that accept file uploads
+  # Windows dialog is opened and handled by WinWindow (see scripts/select_file.rb), launched in a new process.
+  class IE::FileField < IE::InputElement
+    include FileField
+    
+    # set the file location in the Choose file dialog 
+    def set(file_path)
+      assert_exists do
+        # it would be nice to do a click_no_wait and then enter the select file dialog information
+        # in the same thread, but that won't work here, because #click_no_wait runs in a javascript 
+        # setTimeout, and javascript calling to a file input's .click() method doesn't work. it appears 
+        # to work until you submit the form, at which point it says access is denied. so, the click has 
+        # to be done via WIN32OLE, but it doesn't return until the file field is set, so we need two
+        # ruby processes (since WIN32OLE blocking blocks all ruby threads).
+        # since locating this element is a much more complicated task than locating the enabled_popup
+        # of this browser, this process will handle the former, and we'll spawn another to do the
+        # latter.
+        require 'win32/process'
+        require 'vapir-common/win_window'
+        rubyw_exe= File.join(Config::CONFIG['bindir'], 'rubyw')
+        error_file_name=File.expand_path(File.join(File.dirname(__FILE__), 'scripts', 'select_file_error_status.marshal_dump'))
+        select_file_script=File.expand_path(File.join(File.dirname(__FILE__), 'scripts', 'select_file.rb'))
+        command_line=rubyw_exe+[select_file_script, browser.hwnd.to_s, file_path, error_file_name].map{|arg| " \"#{arg.gsub("/", "\\")}\""}.join('')
+         # TODO/FIX: the above method of escaping seems to have issues with trailing slashes. 
+        select_file_process=::Process.create('command_line' => command_line)
+        
+        click
+        
+        if ::Waiter.try_for(2, :exception => nil) { File.exists?(error_file_name) } # wait around a moment for the script to finish writing - #click returns before that script exits 
+          marshaled_error=File.read(error_file_name)
+          error=Marshal.load(marshaled_error)
+          error[:backtrace]+= caller(0)
+          File.delete(error_file_name)
+          raise error[:class], error[:message], error[:backtrace]
+        end
+        return file_path
+        # TODO/FIX: figure out what events ought to be fired here - onchange, maybe others
+      end
+    end
+  end
+  
+  # This class is the watir representation of a radio button.
+  class IE::Radio < IE::InputElement
+    include Radio
+  end
+  
+  # This class is the watir representation of a check box.
+  class IE::CheckBox < IE::InputElement
+    include CheckBox
+  end
+  
+end

data/lib/vapir-ie/link.rb

@@ -0,0 +1,23 @@
+require 'vapir-ie/element'
+require 'vapir-common/elements/elements'
+
+module Vapir
+  
+  # This class is the means of accessing a link on a page
+  # Normally a user would not need to create this object as it is returned by the Vapir::Container#link method
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class IE::Link < IE::Element
+    include Vapir::Link
+    
+    # if an image is used as part of the link, this will return true
+    def link_has_image
+      images.length > 0
+    end
+    
+    def src
+      raise NotImplementedError, "Link#src is gone. use Link#images to get a collection of images from which you may get the #src attribute"
+    end
+  end
+  
+end

data/lib/vapir-ie/logger.rb

@@ -0,0 +1,21 @@
+require 'logger'
+
+module Vapir
+  class VapirLogger < Logger
+    def initialize(filName, logsToKeep, maxLogSize)
+      super(filName, logsToKeep, maxLogSize)
+      self.level = Logger::DEBUG
+      self.datetime_format = "%d-%b-%Y %H:%M:%S"
+      self.debug("Vapir starting")
+    end
+  end
+  
+  class DefaultLogger < Logger
+    def initialize
+      super(STDERR)
+      self.level = Logger::WARN
+      self.datetime_format = "%d-%b-%Y %H:%M:%S"
+      self.info "Log started"
+    end
+  end
+end

data/lib/vapir-ie/modal_dialog.rb

@@ -0,0 +1,224 @@
+require 'vapir-common/win_window'
+require 'vapir-common/modal_dialog'
+require 'vapir-ie/page_container'
+require 'Win32API'
+
+module Vapir
+  class IE::ModalDialog
+    include Vapir::ModalDialog
+    def locate
+      @modal_window=@browser.win_window.enabled_popup
+    end
+    
+    def exists?
+      @modal_window && @modal_window.exists?
+    end
+    
+    def text
+      assert_exists
+      @modal_window.children.select{|child| child.class_name.downcase=='static' && child.text!=''}.map{|c| c.text }.join(' ')
+    end
+    
+    def set_text_field(value)
+      assert_exists
+      edit_field=@modal_window.children.detect{|child| child.class_name=='Edit'} || (raise "No Edit field in the popup!")
+      edit_field.send_set_text!(value)
+      value
+    end
+    
+    def click_button(button_text, options={})
+      assert_exists
+      options=handle_options(options, :timeout => ModalDialog::DEFAULT_TIMEOUT)
+      @modal_window.click_child_button_try_for!(button_text, options[:timeout])
+    end
+    
+    def close
+      if (document=IE::ModalDialogDocument.new(self, :error => false, :timeout => 0)) && document.exists?
+        document.close
+      else
+        @modal_window.send_close!
+      end
+      ::Waiter.try_for(ModalDialog::DEFAULT_TIMEOUT, :exception => Vapir::Exception::WindowException.new("The modal window failed to close")) do
+        !exists?
+      end
+    end
+    
+    def hwnd
+      assert_exists
+      @modal_window.hwnd
+    end
+    def win_window
+      @modal_window
+    end
+    
+    def document
+      assert_exists
+      IE::ModalDialogDocument.new(self)
+    end
+  end
+  class IE::ModalDialogDocument
+    include IE::PageContainer
+    @@iedialog_file = (File.expand_path(File.dirname(__FILE__) + '/..') + "/vapir-ie/IEDialog/Release/IEDialog.dll").gsub('/', '\\')
+
+    GetUnknown = Win32API.new(@@iedialog_file, 'GetUnknown', ['l', 'p'], 'v')
+    def initialize(containing_modal_dialog, options={})
+      options=handle_options(options, :timeout => ModalDialog::DEFAULT_TIMEOUT, :error => true)
+      @containing_modal_dialog=containing_modal_dialog
+      
+      intUnknown = nil
+      ::Waiter.try_for(options[:timeout], :exception => (options[:error] && "Unable to attach to Modal Window after #{options[:timeout]} seconds.")) do
+        intPointer = [0].pack("L") # will contain the int value of the IUnknown*
+        GetUnknown.call(@containing_modal_dialog.hwnd, intPointer)
+        intArray = intPointer.unpack('L')
+        intUnknown = intArray.first
+        intUnknown > 0
+      end
+      if intUnknown && intUnknown > 0
+        @document_object = WIN32OLE.connect_unknown(intUnknown)
+      end
+    end
+    attr_reader :containing_modal_dialog
+    attr_reader :document_object
+    def locate!(options={})
+      exists? || raise(Vapir::Exception::NoMatchingWindowFoundException, "The modal dialog seems to have stopped existing.")
+    end
+    
+    def exists?
+      # todo/fix: will the document object change / become invalid / need to be relocated? 
+      @document_object && @containing_modal_dialog.exists?
+    end
+    
+    # this looks for a modal dialog on this modal dialog. but really it's modal to the same browser window
+    # that this is modal to, so we will check for the modal on the browser, see if it isn't the same as our
+    # self, and return it if so. 
+    def modal_dialog(options={})
+      ::Waiter.try_for(ModalDialog::DEFAULT_TIMEOUT, 
+                        :exception => NoMatchingWindowFoundException.new("No other modal dialog was found on the browser."),
+                        :condition => proc{|md| md.hwnd != containing_modal_dialog.hwnd }
+                      ) do
+        modal_dialog=containing_modal_dialog.browser.modal_dialog(options)
+      end
+    end
+  end
+end
+=begin
+module Watir
+  class IE::ModalDialog
+    include IE::Container
+    include IE::PageContainer
+    include Win32
+
+    # Return the current window handle
+    attr_reader :hwnd
+
+    def find_modal_from_window
+      # Use handle of our parent window to see if we have any currently
+      # enabled popup.
+      hwnd = @container.hwnd
+      hwnd_modal = 0
+      begin
+        Watir::until_with_timeout do
+          hwnd_modal, arr = GetWindow.call(hwnd, GW_ENABLEDPOPUP) # GW_ENABLEDPOPUP = 6
+          hwnd_modal > 0
+        end
+      rescue TimeOutException
+        return nil
+      end
+      if hwnd_modal == hwnd || hwnd_modal == 0
+        hwnd_modal = nil
+      end
+      @hwnd = hwnd_modal
+    end
+    private :find_modal_from_window
+
+    def locate
+      how = @how
+      what = @what
+
+      case how
+      when nil
+        unless find_modal_from_window
+          raise NoMatchingWindowFoundException, 
+            "Modal Dialog not found. Timeout = #{Watir::IE.attach_timeout}"
+        end
+      when :title
+        case what.class.to_s
+        # TODO: re-write like WET's so we can select on regular expressions too.
+        when "String"
+          begin
+            Watir::until_with_timeout do
+              title = "#{what} -- Web Page Dialog"
+              @hwnd, arr = FindWindowEx.call(0, 0, nil, title)
+              @hwnd > 0
+            end
+          rescue TimeOutException
+            raise NoMatchingWindowFoundException, 
+              "Modal Dialog with title #{what} not found. Timeout = #{Watir::IE.attach_timeout}"
+          end
+        else
+          raise ArgumentError, "Title value must be String"
+        end
+      else
+        raise ArgumentError, "Only null and :title methods are supported"
+      end
+
+      intUnknown = 0
+      begin
+        Watir::until_with_timeout do
+          intPointer = " " * 4 # will contain the int value of the IUnknown*
+          GetUnknown.call(@hwnd, intPointer)
+          intArray = intPointer.unpack('L')
+          intUnknown = intArray.first
+          intUnknown > 0
+        end
+      rescue TimeOutException => e
+        raise NoMatchingWindowFoundException, 
+          "Unable to attach to Modal Window #{what.inspect} after #{e.duration} seconds."
+      end
+      
+      copy_test_config @parent_container
+      @document = WIN32OLE.connect_unknown(intUnknown)
+    end
+
+    def initialize(container, how, what=nil)
+      set_container container
+      @how = how
+      @what = what
+      @parent_container = container
+      # locate our modal dialog's Document object and save it
+      begin
+        locate
+      rescue NoMethodError => e
+        message = 
+          "IE#modal_dialog not supported with the current version of Ruby (#{RUBY_VERSION}).\n" + 
+          "See http://jira.openqa.org/browse/WTR-2 for details.\n" +
+            e.message
+        raise NoMethodError.new(message)
+      end
+    end
+
+    def document
+      @document
+    end
+    
+    # Return the title of the document
+    def title
+      document.title
+    end
+
+    def attach_command
+      "Watir::IE.find(:hwnd, #{@container.hwnd}).modal_dialog"
+    end
+      
+    def wait(options={})
+    end
+    
+    # Return true if the modal exists. Mostly this is useful for testing whether
+    # a modal has closed.
+    def exists?
+      Watir::Win32::window_exists? @hwnd
+    end
+    alias :exist? :exists?
+  end
+end
+=end