selenium-webdriver 0.0.17 → 0.0.18

data/firefox/src/extension/install.rdf

@@ -4,7 +4,7 @@
     <Description about="urn:mozilla:install-manifest">
         <em:id>fxdriver@googlecode.com</em:id>
         <em:name>Firefox WebDriver</em:name>
-        <em:version>2.0a2</em:version>
+        <em:version>2.0a3</em:version>
         <em:description>WebDriver implementation for Firefox</em:description>
         <em:creator>Simon Stewart</em:creator>
 

data/firefox/src/rb/lib/selenium/webdriver/firefox.rb

@@ -11,6 +11,8 @@ require "selenium/webdriver/firefox/bridge"
 
 module Selenium
   module WebDriver
+
+    # @private
     module Firefox
 
        DEFAULT_PROFILE_NAME         = "WebDriver".freeze

data/firefox/src/rb/lib/selenium/webdriver/firefox/binary.rb

@@ -1,11 +1,12 @@
 module Selenium
   module WebDriver
     module Firefox
+
+      # @private
       class Binary
 
         def initialize
           ENV['MOZ_NO_REMOTE'] = '1' # able to launch multiple instances
-          check_binary_exists
         end
 
         def create_base_profile(name)
@@ -16,7 +17,6 @@ module Selenium
             _, status = wait
           end
 
-
           if status && status.to_i != 0
             raise Error::WebDriverError, "could not create base profile: (exit status: #{status})"
           end
@@ -29,7 +29,7 @@ module Selenium
         end
 
         def execute(*extra_args)
-          args = [path, "-no-remote", "--verbose"] + extra_args
+          args = [self.class.path, "-no-remote", "--verbose"] + extra_args
           @process = ChildProcess.new(*args).start
         end
 
@@ -63,43 +63,49 @@ module Selenium
 
         private
 
-        def path
-          @path ||= case Platform.os
-                    when :macosx
-                      "/Applications/Firefox.app/Contents/MacOS/firefox-bin"
-                    when :windows
-                      windows_path
-                    when :linux, :unix
-                      "/usr/bin/firefox"
-                    else
-                      raise "Unknown platform: #{Platform.os}"
-                    end
-        end
+        class << self
+          def path
+            @path ||= case Platform.os
+                      when :macosx
+                        "/Applications/Firefox.app/Contents/MacOS/firefox-bin"
+                      when :windows
+                        windows_path
+                      when :linux, :unix
+                        Platform.find_binary("firefox3", "firefox2", "firefox") || "/usr/bin/firefox"
+                      else
+                        raise "Unknown platform: #{Platform.os}"
+                      end
+
+            unless File.file?(@path)
+              raise Error::WebDriverError, "Could not find Firefox binary. Make sure Firefox is installed (OS: #{Platform.os})"
+            end
 
-        def check_binary_exists
-          unless File.file?(path)
-            raise Error::WebDriverError, "Could not find Firefox binary. Make sure Firefox is installed (OS: #{Platform.os})"
+            @path
           end
-        end
 
-        def windows_path
-          windows_registry_path || (ENV['PROGRAMFILES'] || "\\Program Files") + "\\Mozilla Firefox\\firefox.exe"
-        end
+          private
+
+          def windows_path
+            windows_registry_path || "#{ ENV['PROGRAMFILES'] || "\\Program Files" }\\Mozilla Firefox\\firefox.exe"
+          end
 
-        def windows_registry_path
-          return if Platform.jruby? || Platform.ironruby?
-          require "win32/registry"
+          def windows_registry_path
+            require "win32/registry"
 
-          lm = Win32::Registry::HKEY_LOCAL_MACHINE
-          lm.open("SOFTWARE\\Mozilla\\Mozilla Firefox") do |reg|
-            main = lm.open("SOFTWARE\\Mozilla\\Mozilla Firefox\\#{reg.keys[0]}\\Main")
-            if entry = main.find {|key, type, data| key =~ /pathtoexe/i}
-              return entry.last
+            lm = Win32::Registry::HKEY_LOCAL_MACHINE
+            lm.open("SOFTWARE\\Mozilla\\Mozilla Firefox") do |reg|
+              main = lm.open("SOFTWARE\\Mozilla\\Mozilla Firefox\\#{reg.keys[0]}\\Main")
+              if entry = main.find {|key, type, data| key =~ /pathtoexe/i}
+                return entry.last
+              end
             end
+          rescue LoadError
+            # older JRuby or IronRuby does not have win32/registry
+            nil
+          rescue Win32::Registry::Error
+            raise Error::WebDriverError, "Firefox not found in the Windows registry. Make sure Firefox is installed"
           end
-        rescue Win32::Registry::Error
-          raise Error::WebDriverError, "Firefox not found in Windows registry, please make sure you have it installed."
-        end
+        end # class << self
 
       end # Binary
     end # Firefox

data/firefox/src/rb/lib/selenium/webdriver/firefox/bridge.rb

@@ -1,8 +1,9 @@
 module Selenium
   module WebDriver
     module Firefox
-      class Bridge
-        include BridgeHelper
+
+      # @private
+      class Bridge < Remote::Bridge
 
         def initialize(opts = {})
           @binary     = Binary.new
@@ -17,8 +18,7 @@ module Selenium
           end
 
           @launcher.launch
-          @connection = @launcher.connection
-          @context    = newSession
+          super :url => @launcher.connection.url, :desired_capabilities => :firefox
         end
 
         def browser
@@ -30,125 +30,14 @@ module Selenium
         end
 
         def quit
-          @connection.quit
+          super
           @binary.wait rescue nil # might raise on windows
 
           nil
         end
 
-        def getPageSource
-          execute :getPageSource
-        end
-
-        def refresh
-          execute :refresh
-        end
-
-        def getWindowHandles
-          execute :getWindowHandles
-        end
-
-        def getCurrentWindowHandle
-          execute :getCurrentWindowHandle
-        end
-
-        def getScreenshotAsBase64
-          execute :getScreenshotAsBase64
-        end
-
-        def get(url)
-          execute :get,
-                  :parameters => [url]
-        end
-
-        def close
-          execute :close
-        # TODO: rescue ?
-        end
-
-        def goBack
-          execute :goBack
-        end
-
-        def goForward
-          execute :goForward
-        end
-
-        def getCurrentUrl
-          execute :getCurrentUrl
-        end
-
-        def getTitle
-          execute :title
-        end
-
-        def executeScript(string, *args)
-          typed_args = args.map { |e| wrap_script_argument(e) }
-
-          resp = raw_execute :executeScript, :parameters => [string, typed_args]
-          raise TypeError, "expected Hash" unless resp.kind_of? Hash
-
-          unwrap_script_argument resp["response"]
-        end
-
-        #
-        # Finders - TODO: should be shared with Chrome::Bridge
-        #
-
-        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
+        def getScreenshot
+          execute :screenshot
         end
 
         def findElementByCssSelector(parent, selector)
@@ -159,309 +48,6 @@ module Selenium
           find_elements_by 'css selector', selector, parent
         end
 
-        #
-        # Element functions
-        #
-
-        def clickElement(element)
-          # execute :clickElement, :element_id => element
-          execute :click,
-                  :element_id => element
-        end
-
-        def getElementTagName(element)
-          # execute :getElementTagName, :element_id => element
-          execute :getTagName,
-                  :element_id => element
-        end
-
-        def getElementAttribute(element, name)
-          # execute :getElementAttribute, :element_id => element, :parameters => [name]
-          execute :getAttribute,
-                  :element_id => element,
-                  :parameters => [name]
-        end
-
-        def getElementValue(element)
-          # execute :getElementValue, :element_id => element
-          execute :getValue,
-                  :element_id => element
-        end
-
-        def getElementText(element)
-          # execute :getElementText, :element_id => element
-          execute :getText,
-                  :element_id => element
-        end
-
-        def getElementLocation(element)
-          # data = execute :getElementLocation, :element_id => element
-          data = execute :getLocation,
-                         :element_id => element
-
-          Point.new data["x"], data["y"]
-        end
-
-        def getElementSize(element)
-          # execute :getElementSize, :element_id => element
-          data = execute :getSize,
-                         :element_id => element
-
-          Dimension.new data['width'], data['height']
-        end
-
-        def sendKeysToElement(element, string)
-          # execute :sendKeysToElement, :element_id => element, :parameters => [string.split(//u)]
-          execute :sendKeys,
-                  :element_id => element,
-                  :parameters => [string.to_s]
-        end
-
-        def clearElement(element)
-          # execute :clearElement, :element_id => element
-          execute :clear,
-                  :element_id => element
-        end
-
-        def isElementEnabled(element)
-          # execute :isElementEnabled, :element_id => element
-          !getElementAttribute(element, "disabled")
-        end
-
-        def isElementSelected(element)
-          # execute :isElementSelected, :element_id => element
-          execute :isSelected,
-                  :element_id => element
-        end
-
-        def isElementDisplayed(element)
-          # execute :isElementDisplayed, :element_id => element
-          execute :isDisplayed,
-                  :element_id => element
-        end
-
-        def submitElement(element)
-          # execute :submitElement, :element_id => element
-          execute :submit,
-                  :element_id => element
-        end
-
-        def toggleElement(element)
-          # execute :toggleElement, :element_id => element
-          execute :toggle,
-                  :element_id => element
-        end
-
-        def setElementSelected(element)
-          # execute :setElementSelected, :element_id => element
-          execute :setSelected,
-                  :element_id => element
-        end
-
-        def getElementValueOfCssProperty(element, prop)
-          # execute :getElementValueOfCssProperty, :element_id => element, :parameters => [prop]
-          execute :getValueOfCssProperty,
-                  :element_id => element,
-                  :parameters => [prop]
-        end
-
-        def hoverOverElement(element)
-          execute :hover,
-                  :element_id => element
-          # execute :hoverOverElement, :element_id => element
-        end
-
-        def dragElement(element, rigth_by, down_by)
-          execute :dragElement,
-                  :element_id => element,
-                  :parameters => [rigth_by, down_by]
-        end
-
-
-        def setSpeed(speed)
-          pixel_speed = case speed
-                        when "SLOW"   then '1'
-                        when "MEDIUM" then '10'
-                        when "FAST"   then '100'
-                        else
-                          raise ArgumentError, "unknown speed: #{speed.inspect}"
-                        end
-
-          execute :setMouseSpeed,
-                  :parameters => [pixel_speed]
-        end
-
-        def getSpeed
-          case execute(:getMouseSpeed)
-          when '1'    then  "SLOW"
-          when '10'   then  "MEDIUM"
-          when '100'  then  "FAST"
-          else
-            "FAST"
-          end
-        end
-
-        def addCookie(cookie)
-          execute :addCookie,
-                  :parameters => [cookie.to_json] # uhm, sending text instead of data
-        end
-
-        def deleteCookie(name)
-          execute :deleteCookie,
-                  :parameters => [{:name => name}.to_json] # ditto
-        end
-
-        def getAllCookies
-          data = execute :getCookie
-          data.map do |c|
-            parse_cookie_string(c) unless c.strip.empty?
-          end.compact
-        end
-
-        #
-        #  FF-specific?
-        #
-
-        def deleteAllCookies
-          execute :deleteAllCookies
-        end
-
-        def getCookieNamed(name)
-          getCookies.find { |c| c['name'] == name }
-        end
-
-        def switchToFrame(name)
-          execute :switchToFrame,
-                  :parameters => [name.to_s]
-        end
-
-        def switchToDefaultContent
-          execute :switchToDefaultContent
-        end
-
-        def switchToWindow(name)
-          @context = execute  :switchToWindow,
-                              :parameters => [name.to_s]
-        end
-
-        def switchToActiveElement
-          Element.new self, element_id_from(execute(:switchToActiveElement))
-        end
-        alias_method :getActiveElement, :switchToActiveElement
-
-        private
-
-        def find_element_by(how, what, parent = nil)
-          if parent
-            id = execute :findChildElement,
-                         :parameters => [{:id => parent, :using => how, :value => what}]
-          else
-            id = execute :findElement,
-                         :parameters => [how, what]
-          end
-
-          Element.new self, element_id_from(id)
-        end
-
-        def find_elements_by(how, what, parent = nil)
-          if parent
-            id_string = execute :findChildElements,
-                                :parameters => [{:id => parent, :using => how, :value => what}]
-          else
-            id_string = execute :findElements,
-                                :parameters => [how, what]
-          end
-
-          id_string.map { |id| Element.new self, element_id_from(id) }
-        end
-
-        def newSession
-          execute :newSession
-        end
-
-        def execute(*args)
-          raw_execute(*args)['response']
-        end
-
-        def raw_execute(command, opts = {})
-          request = {:commandName => command, :context => @context.to_s}
-
-          if eid = opts[:element_id]
-            request[:elementId] = eid
-          end
-
-          if params = opts[:parameters]
-            request[:parameters] = params
-          end
-
-          puts "--> #{request.inspect}" if $DEBUG
-
-          @connection.send_string request.to_json
-          resp = @connection.read_response
-
-          puts "<-- #{resp.inspect}" if $DEBUG
-
-          if resp['isError']
-            case resp['response']
-            when String
-              msg = resp['response']
-            when Hash
-              msg = resp['response']['message']
-            end
-
-            msg ||= resp.inspect
-            raise Error::WebDriverError, msg
-          end
-
-          if ctx = resp['context']
-            @context = ctx
-          end
-
-          resp
-        end
-
-        #
-        # wrap/unwrap will be shared with Chrome (overrides BridgeHelper for now)
-        #
-
-        def wrap_script_argument(arg)
-          case arg
-          when Integer, Float
-            { :type => "NUMBER", :value => arg }
-          when TrueClass, FalseClass, NilClass
-            { :type => "BOOLEAN", :value => !!arg }
-          when Element
-            { :type => "ELEMENT", :value => arg.ref }
-          when String
-            { :type => "STRING", :value => arg.to_s }
-          when Array # Enumerable?
-            arg.map { |e| wrap_script_argument(e) }
-          else
-            raise TypeError, "Parameter is not of recognized type: #{arg.inspect}:#{arg.class}"
-          end
-        end
-
-        def unwrap_script_argument(arg)
-          raise TypeError, "expected Hash" unless arg.kind_of? Hash
-          case arg["type"]
-          when "NULL"
-            nil
-          when "ELEMENT"
-            Element.new self, element_id_from(arg["value"])
-          when "ARRAY"
-            arg['value'].map { |e| unwrap_script_argument(e) }
-          # when "POINT"
-          #   Point.new arg['x'], arg['y']
-          # when "DIMENSION"
-          #   Dimension.new arg['width'], arg['height']
-          # when "COOKIE"
-          #   {:name => arg['name'], :value => arg['value']}
-          else
-            arg["value"]
-          end
-        end
-
-
       end # Bridge
     end # Firefox
   end # WebDriver