rainux-selenium-webdriver 0.0.17

data/jobbie/src/rb/lib/selenium/webdriver/ie/lib.rb

@@ -0,0 +1,99 @@
+module Selenium
+  module WebDriver
+    module IE
+      module Lib
+        extend FFI::Library
+
+        ffi_lib WebDriver::IE::DLL
+
+        attach_function :wdAddBooleanScriptArg,               [:pointer, :int                                             ], :int
+        attach_function :wdAddCookie,                         [:pointer, :pointer                                         ], :int
+        attach_function :wdAddDoubleScriptArg,                [:pointer, :double                                          ], :int
+        attach_function :wdAddElementScriptArg,               [:pointer, :pointer                                         ], :int
+        attach_function :wdAddNumberScriptArg,                [:pointer, :long                                            ], :int
+        attach_function :wdAddStringScriptArg,                [:pointer, :pointer                                         ], :int
+        attach_function :wdcGetElementAtIndex,                [:pointer, :int, :pointer                                   ], :int
+        attach_function :wdcGetElementCollectionLength,       [:pointer, :pointer                                         ], :int
+        attach_function :wdcGetStringAtIndex,                 [:pointer, :int, :pointer                                   ], :int
+        attach_function :wdcGetStringCollectionLength,        [:pointer, :pointer                                         ], :int
+        attach_function :wdClose,                             [:pointer                                                   ], :int
+        attach_function :wdCopyString,                        [:pointer, :int, :pointer                                   ], :int
+        attach_function :wdeClear,                            [:pointer                                                   ], :int
+        attach_function :wdeClick,                            [:pointer                                                   ], :int
+        attach_function :wdeGetAttribute,                     [:pointer, :pointer, :pointer                               ], :int
+        attach_function :wdeGetDetailsOnceScrolledOnToScreen, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer ], :int
+        attach_function :wdeGetLocation,                      [:pointer, :pointer, :pointer                               ], :int
+        attach_function :wdeGetSize,                          [:pointer, :pointer, :pointer                               ], :int
+        attach_function :wdeGetTagName,                       [:pointer, :pointer                                         ], :int
+        attach_function :wdeGetText,                          [:pointer, :pointer                                         ], :int
+        attach_function :wdeGetValueOfCssProperty,            [:pointer, :pointer, :pointer                               ], :int
+        attach_function :wdeIsDisplayed,                      [:pointer, :pointer                                         ], :int
+        attach_function :wdeIsEnabled,                        [:pointer, :pointer                                         ], :int
+        attach_function :wdeIsSelected,                       [:pointer, :pointer                                         ], :int
+        attach_function :wdeMouseDownAt,                      [:pointer, :long, :long                                     ], :int #hwnd, nativelong
+        attach_function :wdeMouseMoveTo,                      [:pointer, :long, :long, :long, :long, :long                ], :int # hwnd, 5x nativelong
+        attach_function :wdeMouseUpAt,                        [:pointer, :long, :long                                     ], :int # hwnd
+        attach_function :wdeSendKeys,                         [:pointer, :pointer                                         ], :int
+        attach_function :wdeSetSelected,                      [:pointer                                                   ], :int
+        attach_function :wdeSubmit,                           [:pointer                                                   ], :int
+        attach_function :wdeToggle,                           [:pointer, :pointer                                         ], :int
+        attach_function :wdExecuteScript,                     [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdeFreeElement,                      [:pointer                                                   ], :int
+        attach_function :wdFindElementByClassName,            [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementById,                   [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementByLinkText,             [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementByName,                 [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementByPartialLinkText,      [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementByTagName,              [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementByXPath,                [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementsByClassName,           [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementsById,                  [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementsByLinkText,            [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementsByName,                [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementsByPartialLinkText,     [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementsByTagName,             [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFindElementsByXPath,               [:pointer, :pointer, :pointer, :pointer                     ], :int
+        attach_function :wdFreeDriver,                        [:pointer                                                   ], :int
+        attach_function :wdFreeElementCollection,             [:pointer, :int                                             ], :int
+        attach_function :wdFreeScriptArgs,                    [:pointer                                                   ], :int
+        attach_function :wdFreeScriptResult,                  [:pointer                                                   ], :int
+        attach_function :wdFreeString,                        [:pointer                                                   ], :int
+        attach_function :wdFreeStringCollection,              [:pointer                                                   ], :int
+        attach_function :wdGet,                               [:pointer, :pointer                                         ], :int
+        attach_function :wdGetAllWindowHandles,               [:pointer, :pointer                                         ], :int
+        attach_function :wdGetBooleanScriptResult,            [:pointer, :pointer                                         ], :int
+        attach_function :wdGetCookies,                        [:pointer, :pointer                                         ], :int
+        attach_function :wdGetCurrentUrl,                     [:pointer, :pointer                                         ], :int
+        attach_function :wdGetCurrentWindowHandle,            [:pointer, :pointer                                         ], :int
+        attach_function :wdGetDoubleScriptResult,             [:pointer, :pointer                                         ], :int
+        attach_function :wdGetElementScriptResult,            [:pointer, :pointer, :pointer                               ], :int
+        attach_function :wdGetNumberScriptResult,             [:pointer, :pointer                                         ], :int
+        attach_function :wdGetPageSource,                     [:pointer, :pointer                                         ], :int
+        attach_function :wdGetScriptResultType,               [:pointer, :pointer                                         ], :int
+        attach_function :wdGetStringScriptResult,             [:pointer, :pointer                                         ], :int
+        attach_function :wdGetTitle,                          [:pointer, :pointer                                         ], :int
+        attach_function :wdGetVisible,                        [:pointer, :pointer                                         ], :int
+        attach_function :wdGoBack,                            [:pointer                                                   ], :int
+        attach_function :wdGoForward,                         [:pointer                                                   ], :int
+        attach_function :wdNewDriverInstance,                 [:pointer                                                   ], :int
+        attach_function :wdNewScriptArgs,                     [:pointer, :int                                             ], :int
+        attach_function :wdRefresh,                           [:pointer,                                                  ], :int
+        attach_function :wdSetVisible,                        [:pointer, :int                                             ], :int
+        attach_function :wdStringLength,                      [:pointer, :pointer                                         ], :int
+        attach_function :wdSwitchToActiveElement,             [:pointer, :pointer                                         ], :int
+        attach_function :wdSwitchToFrame,                     [:pointer, :pointer                                         ], :int
+        attach_function :wdSwitchToWindow,                    [:pointer, :pointer                                         ], :int
+        attach_function :wdWaitForLoadToComplete,             [:pointer                                                   ], :int
+      end
+
+      module Kernel32
+        extend FFI::Library
+
+        ffi_lib "kernel32.dll"
+
+        attach_function :MultiByteToWideChar, [:int, :long, :pointer, :int, :pointer, :int                    ], :int
+        attach_function :WideCharToMultiByte, [:int, :long, :pointer, :int, :pointer, :int, :pointer, :pointer], :int
+      end
+    end # IE
+  end # WebDriver
+end # Selenium

data/jobbie/src/rb/lib/selenium/webdriver/ie/util.rb

@@ -0,0 +1,147 @@
+module Selenium
+  module WebDriver
+    module IE
+      module Util
+        CP_ACP         = 0
+        CP_OEMCP       = 1
+        CP_MACCP       = 2
+        CP_THREAD_ACP  = 3
+        CP_SYMBOL      = 42
+        CP_UTF7        = 65000
+        CP_UTF8        = 65001
+
+        def string_array_from(raw_strings)
+          strings_ptr = raw_strings.get_pointer(0)
+          length_ptr  = FFI::MemoryPointer.new :int
+          result      = Lib.wdcGetStringCollectionLength(strings_ptr, length_ptr)
+
+          if result != 0
+            raise Error::WebDriverError, "cannot extract strings from collection, error code: #{result.inspect}"
+          end
+
+          arr    = []
+
+          length_ptr.get_int(0).times do |idx|
+            str_ptr_ref = FFI::MemoryPointer.new :pointer
+            result = Lib.wdcGetStringAtIndex(strings_ptr, idx, str_ptr_ref)
+
+            if result != 0
+              raise Error::WebDriverError, "unable to get string at index: #{idx}, error: #{result}"
+            end
+
+            arr << extract_string_from(str_ptr_ref)
+          end
+
+          arr
+        ensure
+          Lib.wdFreeStringCollection(strings_ptr)
+          raw_strings.free
+        end
+
+        def create_element(&blk)
+          element_ptr_ref = FFI::MemoryPointer.new :pointer
+          yield element_ptr_ref
+          Element.new(self, element_ptr_ref.get_pointer(0))
+        ensure
+          element_ptr_ref.free
+        end
+
+        def create_element_collection(&blk)
+          elements_ptr_ref = FFI::MemoryPointer.new :pointer
+          yield elements_ptr_ref
+
+          extract_elements_from elements_ptr_ref
+        end
+
+        def create_string(&blk)
+          wrapper = FFI::MemoryPointer.new :pointer
+          yield wrapper
+
+          extract_string_from wrapper
+        end
+
+        def extract_string_from(string_ptr_ref)
+          string_ptr = string_ptr_ref.get_pointer(0)
+          return if string_ptr.null? # getElementAttribute()
+
+          length_ptr = FFI::MemoryPointer.new :int
+
+          if Lib.wdStringLength(string_ptr, length_ptr) != 0
+            raise Error::WebDriverError, "cannot determine length of string"
+          end
+
+          length     = length_ptr.get_int(0)
+          raw_string = wstring_ptr(" "*length)
+
+          if Lib.wdCopyString(string_ptr, length, raw_string) != 0
+            raise Error::WebDriverError, "cannot copy string from native data to Ruby string"
+          end
+
+          wstring_to_bytestring raw_string
+        ensure
+          Lib.wdFreeString(string_ptr) unless string_ptr.null?
+          string_ptr_ref.free
+        end
+
+        def extract_elements_from(elements_ptr_ref)
+          elements_ptr = elements_ptr_ref.get_pointer(0)
+          length_ptr   = FFI::MemoryPointer.new :int
+
+          check_error_code Lib.wdcGetElementCollectionLength(elements_ptr, length_ptr),
+                           "Cannot extract elements from collection"
+
+          arr = []
+
+          length_ptr.get_int(0).times do |idx|
+            arr << create_element do |ptr|
+              result = Lib.wdcGetElementAtIndex(elements_ptr, idx, ptr)
+
+              if e = WebDriver::Error.for_code(result)
+                Lib.wdFreeElementCollection(elements_ptr, 1)
+                raise e, "unable to create element from collection at index #{idx} (#{result})"
+              end
+            end
+          end
+
+          Lib.wdFreeElementCollection(elements_ptr, 0)
+
+          arr
+        ensure
+          elements_ptr_ref.free
+          length_ptr.free
+        end
+
+
+        def wstring_ptr(str)
+          str  = str.to_s
+          size = Kernel32.MultiByteToWideChar(CP_UTF8, 0, str, -1, nil, 0)
+
+          unless size > 0
+            raise Error::WebDriverError, "unable to convert #{str.inspect} to wchar ptr"
+          end
+
+          buf = FFI::MemoryPointer.new :pointer, size
+          Kernel32.MultiByteToWideChar(CP_UTF8, 0, str, -1, buf, size)
+
+          buf
+        end
+
+        def wstring_to_bytestring(wstring)
+          size = Kernel32.WideCharToMultiByte(CP_UTF8, 0, wstring, -1, nil, 0, nil, nil)
+
+          unless size > 0
+            raise Error::WebDriverError, "could not convert wstring pointer to bytestring"
+          end
+
+          buf = FFI::MemoryPointer.new :pointer, size
+          Kernel32.WideCharToMultiByte(CP_UTF8, 0, wstring, -1, buf, size, nil, nil )
+
+          buf.get_bytes(0, size - 1)
+        ensure
+          buf.free if buf
+        end
+
+      end # Util
+    end # IE
+  end # WebDriver
+end # Selenium

data/remote/client/src/rb/lib/selenium/webdriver/remote.rb

@@ -0,0 +1,16 @@
+require "selenium/webdriver/remote/capabilities"
+require "selenium/webdriver/remote/default_http_client"
+require "selenium/webdriver/remote/bridge"
+require "selenium/webdriver/remote/server_error"
+require "selenium/webdriver/remote/response"
+require "selenium/webdriver/remote/commands"
+
+module Selenium
+  module WebDriver
+    module Remote
+
+    end
+  end
+end
+
+require "uri"

data/remote/client/src/rb/lib/selenium/webdriver/remote/bridge.rb

@@ -0,0 +1,408 @@
+module Selenium
+  module WebDriver
+    module Remote
+
+      COMMANDS = {}
+
+      #
+      # Low level bridge to the remote server, through which the rest of the API works.
+      #
+      # @api private
+      #
+
+      class Bridge
+        include Find
+        include BridgeHelper
+
+        DEFAULT_OPTIONS = {
+          :url                  => "http://localhost:4444/wd/hub",
+          :http_client          => DefaultHttpClient,
+          :desired_capabilities => Capabilities.firefox
+        }
+
+        #
+        # Defines a wrapper method for a command, which ultimately calls #execute.
+        #
+        # @param name [Symbol]
+        #   name of the resulting method
+        # @param url [String]
+        #   a URL template, which can include some arguments, much like the definitions on the server.
+        #   the :session_id and :context parameters are implicitly handled, but the remainder will become
+        #   required method arguments.
+        #   e.g., "session/:session_id/:context/element/:id/text" will define a method that takes id
+        #   as it's first argument.
+        # @param verb [Symbol]
+        #   the appropriate http verb, such as :get, :post, or :delete
+        #
+
+        def self.command(name, verb, url)
+          COMMANDS[name] = [verb, url.freeze]
+        end
+
+        attr_accessor :context, :http
+        attr_reader :capabilities
+
+        #
+        # Initializes the bridge with the given server URL.
+        #
+        # @param url         [String] url for the remote server
+        # @param http_client [Class] an HTTP client class that implements the same interface as DefaultHttpClient
+        # @param desired_capabilities [Capabilities] an instance of Remote::Capabilities describing the capabilities you want
+        #
+
+        def initialize(opts = {})
+          opts                 = DEFAULT_OPTIONS.merge(opts)
+          http_client_class    = opts.delete(:http_client)
+          desired_capabilities = opts.delete(:desired_capabilities)
+          url                  = opts.delete(:url)
+
+          unless opts.empty?
+            raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
+          end
+
+          if desired_capabilities.kind_of?(Symbol)
+            unless Capabilities.respond_to?(desired_capabilities)
+              raise Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
+            end
+
+            desired_capabilities = Capabilities.send(desired_capabilities)
+          end
+
+          uri = URI.parse(url)
+          uri.path += "/" unless uri.path =~ /\/$/
+
+          @context      = "context"
+          @http         = http_client_class.new uri
+          @capabilities = create_session(desired_capabilities)
+        end
+
+        def browser
+          @browser ||= @capabilities.browser_name.gsub(" ", "_").to_sym
+        end
+
+        def driver_extensions
+          []
+        end
+
+        #
+        # Returns the current session ID.
+        #
+
+        def session_id
+          @session_id || raise(Error::WebDriverError, "no current session exists")
+        end
+
+
+        def create_session(desired_capabilities)
+          resp = raw_execute :newSession, {}, desired_capabilities
+          @session_id = resp['sessionId'] || raise(Error::WebDriverError, 'no sessionId in returned payload')
+          @context    = resp['context']
+
+          Capabilities.json_create resp['value']
+        end
+
+        def get(url)
+          execute :get, {}, url
+        end
+
+        def goBack
+          execute :goBack
+        end
+
+        def goForward
+          execute :goForward
+        end
+
+        def getCurrentUrl
+          execute :getCurrentUrl
+        end
+
+        def getTitle
+          execute :getTitle
+        end
+
+        def getPageSource
+          execute :getPageSource
+        end
+
+        def getVisible
+          execute :getVisible
+        end
+
+        def setVisible(bool)
+          execute :setVisible, {}, bool
+        end
+
+        def switchToWindow(name)
+          execute :switchToWindow, :name => name
+        end
+
+        def switchToFrame(id)
+          execute :switchToFrame, :id => id
+        end
+
+        def switchToDefaultContent
+          execute :switchToFrame, :id => nil
+        end
+
+        def quit
+          execute :quit
+        end
+
+        def close
+          execute :close
+        end
+
+        def refresh
+          execute :refresh
+        end
+
+        def getWindowHandles
+          execute :getWindowHandles
+        end
+
+        def getCurrentWindowHandle
+          execute :getCurrentWindowHandle
+        end
+
+        def setSpeed(value)
+          execute :setSpeed, {}, value
+        end
+
+        def getSpeed
+          execute :getSpeed
+        end
+
+        def executeScript(script, *args)
+          unless capabilities.javascript?
+            raise Error::UnsupportedOperationError, "underlying webdriver instance does not support javascript"
+          end
+
+          typed_args = args.map { |arg| wrap_script_argument(arg) }
+          response   = raw_execute :executeScript, {}, script, typed_args
+
+          unwrap_script_argument response['value']
+        end
+
+        def addCookie(cookie)
+          execute :addCookie, {}, cookie
+        end
+
+        def deleteCookie(name)
+          execute :deleteCookie, :name => name
+        end
+
+        def getAllCookies
+          execute :getAllCookies
+        end
+
+        def deleteAllCookies
+          execute :deleteAllCookies
+        end
+
+        def findElementByClassName(parent, class_name)
+          find_element_by 'class name', class_name, parent
+        end
+
+        def findElementsByClassName(parent, class_name)
+          find_elements_by 'class name', class_name, parent
+        end
+
+        def findElementById(parent, id)
+          find_element_by 'id', id, parent
+        end
+
+        def findElementsById(parent, id)
+          find_elements_by 'id', id, parent
+        end
+
+        def findElementByLinkText(parent, link_text)
+          find_element_by 'link text', link_text, parent
+        end
+
+        def findElementsByLinkText(parent, link_text)
+          find_elements_by 'link text', link_text, parent
+        end
+
+        def findElementByPartialLinkText(parent, link_text)
+          find_element_by 'partial link text', link_text, parent
+        end
+
+        def findElementsByPartialLinkText(parent, link_text)
+          find_elements_by 'partial link text', link_text, parent
+        end
+
+        def findElementByName(parent, name)
+          find_element_by 'name', name, parent
+        end
+
+        def findElementsByName(parent, name)
+          find_elements_by 'name', name, parent
+        end
+
+        def findElementByTagName(parent, tag_name)
+          find_element_by 'tag name', tag_name, parent
+        end
+
+        def findElementsByTagName(parent, tag_name)
+          find_elements_by 'tag name', tag_name, parent
+        end
+
+        def findElementByXpath(parent, xpath)
+          find_element_by 'xpath', xpath, parent
+        end
+
+        def findElementsByXpath(parent, xpath)
+          find_elements_by 'xpath', xpath, parent
+        end
+
+
+        #
+        # Element functions
+        #
+
+        def clickElement(element)
+          execute :clickElement, :id => element
+        end
+
+        def getElementTagName(element)
+          execute :getElementTagName, :id => element
+        end
+
+        def getElementAttribute(element, name)
+          execute :getElementAttribute, :id => element, :name => name
+        end
+
+        def getElementValue(element)
+          execute :getElementValue, :id => element
+        end
+
+        def getElementText(element)
+          execute :getElementText, :id => element
+        end
+
+        def getElementLocation(element)
+          data = execute :getElementLocation, :id => element
+
+          Point.new data['x'], data['y']
+        end
+
+        def getElementSize(element)
+          data = execute :getElementSize, :id => element
+
+          Dimension.new data['width'], data['height']
+        end
+
+        def sendKeysToElement(element, string)
+          execute :sendKeysToElement, {:id => element}, {:value => string.split(//u)}
+        end
+
+        def clearElement(element)
+          execute :clearElement, :id => element
+        end
+
+        def isElementEnabled(element)
+          execute :isElementEnabled, :id => element
+        end
+
+        def isElementSelected(element)
+          execute :isElementSelected, :id => element
+        end
+
+        def isElementDisplayed(element)
+          execute :isElementDisplayed, :id => element
+        end
+
+        def submitElement(element)
+          execute :submitElement, :id => element
+        end
+
+        def toggleElement(element)
+          execute :toggleElement, :id => element
+        end
+
+        def setElementSelected(element)
+          execute :setElementSelected, :id => element
+        end
+
+        def getElementValueOfCssProperty(element, prop)
+          execute :getElementValueOfCssProperty, :id => element, :property_name => prop
+        end
+
+        def getActiveElement
+          Element.new self, element_id_from(execute(:getActiveElement))
+        end
+        alias_method :switchToActiveElement, :getActiveElement
+
+        def hoverOverElement(element)
+          execute :hoverOverElement, :id => element
+        end
+
+        def dragElement(element, rigth_by, down_by)
+          # TODO: why is element sent twice in the payload?
+          execute :dragElement, {:id => element}, element, rigth_by, down_by
+        end
+
+        private
+
+        def find_element_by(how, what, parent = nil)
+          if parent
+            # TODO: why is how sent twice in the payload?
+            id = execute :findChildElement, {:id => parent, :using => how}, {:using => how, :value => what}
+          else
+            id = execute :findElement, {}, how, what
+          end
+
+          Element.new self, element_id_from(id)
+        end
+
+        def find_elements_by(how, what, parent = nil)
+          if parent
+            # TODO: why is how sent twice in the payload?
+            ids = execute :findChildElements, {:id => parent, :using => how}, {:using => how, :value => what}
+          else
+            ids = execute :findElements, {}, how, what
+          end
+
+          ids.map { |id| Element.new self, element_id_from(id) }
+        end
+
+
+        #
+        # executes a command on the remote server via the REST / JSON API.
+        #
+        #
+        # Returns the 'value' of the returned payload
+        #
+
+        def execute(*args)
+          raw_execute(*args)['value']
+        end
+
+        #
+        # executes a command on the remote server via the REST / JSON API.
+        #
+        # Returns a WebDriver::Remote::Response instance
+        #
+
+        def raw_execute(command, opts = {}, *args)
+          verb, path = COMMANDS[command] || raise("unknown command #{command.inspect}")
+          path       = path.dup
+
+          path[':session_id'] = @session_id if path.include?(":session_id")
+          path[':context']    = @context if path.include?(":context")
+
+          begin
+            opts.each { |key, value| path[key.inspect] = URI.escape(value.to_s) }
+          rescue IndexError
+            raise ArgumentError, "#{opts.inspect} invalid for #{command.inspect}"
+          end
+
+          puts "-> #{verb.to_s.upcase} #{path}" if $DEBUG
+          http.call verb, path, *args
+        end
+
+      end # Bridge
+    end # Remote
+  end # WebDriver
+end # Selenium