selenium-webdriver 3.0.0.beta4.0 → 4.0.0.alpha5

data/lib/selenium/webdriver/remote/capabilities.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # Licensed to the Software Freedom Conservancy (SFC) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -20,39 +20,55 @@
 module Selenium
   module WebDriver
     module Remote
+
       #
       # Specification of the desired and/or actual capabilities of the browser that the
       # server is being asked to create.
       #
+
       class Capabilities
-        DEFAULTS = {
-          browser_name: '',
-          version: '',
-          platform: :any,
-          javascript_enabled: false,
-          css_selectors_enabled: false,
-          takes_screenshot: false,
-          native_events: false,
-          rotatable: false,
-          firefox_profile: nil,
-          proxy: nil
-        }.freeze
-
-        DEFAULTS.each_key do |key|
+
+        KNOWN = [
+          :browser_name,
+          :browser_version,
+          :platform_name,
+          :accept_insecure_certs,
+          :page_load_strategy,
+          :proxy,
+          :set_window_rect,
+          :timeouts,
+          :unhandled_prompt_behavior,
+          :strict_file_interactability,
+
+          # remote-specific
+          :remote_session_id,
+
+          # TODO: (AR) deprecate compatibility with OSS-capabilities
+          :implicit_timeout,
+          :page_load_timeout,
+          :script_timeout
+        ].freeze
+
+        KNOWN.each do |key|
           define_method key do
             @capabilities.fetch(key)
           end
 
+          next if key == :proxy
+
           define_method "#{key}=" do |value|
             @capabilities[key] = value
           end
         end
 
-        alias_method :css_selectors_enabled?, :css_selectors_enabled
-        alias_method :javascript_enabled?, :javascript_enabled
-        alias_method :native_events?, :native_events
-        alias_method :takes_screenshot?, :takes_screenshot
-        alias_method :rotatable?, :rotatable
+        #
+        # Backward compatibility
+        #
+
+        alias_method :version, :browser_version
+        alias_method :version=, :browser_version=
+        alias_method :platform, :platform_name
+        alias_method :platform=, :platform_name=
 
         #
         # Convenience methods for the common choices.
@@ -61,69 +77,60 @@ module Selenium
         class << self
           def chrome(opts = {})
             new({
-              browser_name: 'chrome',
-              javascript_enabled: true,
-              css_selectors_enabled: true
+              browser_name: 'chrome'
             }.merge(opts))
           end
 
           def edge(opts = {})
-            W3CCapabilities.edge(opts)
+            edge_html(opts)
           end
 
-          def firefox(opts = {})
-            return W3CCapabilities.firefox(opts) unless opts[:marionette] == false
-
+          def edge_html(opts = {})
             new({
-              browser_name: 'firefox',
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
+              browser_name: 'MicrosoftEdge',
+              platform_name: :windows
             }.merge(opts))
           end
 
-          def htmlunit(opts = {})
+          def edge_chrome(opts = {})
             new({
-              browser_name: 'htmlunit'
+              browser_name: 'MicrosoftEdge'
             }.merge(opts))
           end
 
-          def htmlunitwithjs(opts = {})
-            new({
-              browser_name: 'htmlunit',
-              javascript_enabled: true
-            }.merge(opts))
+          def firefox(opts = {})
+            opts[:browser_version] = opts.delete(:version) if opts.key?(:version)
+            opts[:platform_name] = opts.delete(:platform) if opts.key?(:platform)
+            opts[:timeouts] = {}
+            opts[:timeouts]['implicit'] = opts.delete(:implicit_timeout) if opts.key?(:implicit_timeout)
+            opts[:timeouts]['pageLoad'] = opts.delete(:page_load_timeout) if opts.key?(:page_load_timeout)
+            opts[:timeouts]['script'] = opts.delete(:script_timeout) if opts.key?(:script_timeout)
+            opts.delete(:timeouts) if opts[:timeouts].empty?
+            new({browser_name: 'firefox'}.merge(opts))
           end
 
-          def internet_explorer(opts = {})
+          alias_method :ff, :firefox
+
+          def safari(opts = {})
             new({
-              browser_name: 'internet explorer',
-              platform: :windows,
-              takes_screenshot: true,
-              css_selectors_enabled: true,
-              native_events: true
+              browser_name: 'safari',
+              platform_name: :mac
             }.merge(opts))
           end
-          alias_method :ie, :internet_explorer
 
-          def phantomjs(opts = {})
+          def htmlunit(opts = {})
             new({
-              browser_name: 'phantomjs',
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
+              browser_name: 'htmlunit'
             }.merge(opts))
           end
 
-          def safari(opts = {})
+          def internet_explorer(opts = {})
             new({
-              browser_name: 'safari',
-              platform: :mac,
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
+              browser_name: 'internet explorer',
+              platform_name: :windows
             }.merge(opts))
           end
+          alias_method :ie, :internet_explorer
 
           #
           # @api private
@@ -133,15 +140,26 @@ module Selenium
             data = data.dup
 
             caps = new
-            caps.browser_name          = data.delete('browserName')
-            caps.version               = data.delete('version')
-            caps.platform              = data.delete('platform').downcase.to_sym if data.key?('platform')
-            caps.javascript_enabled    = data.delete('javascriptEnabled')
-            caps.css_selectors_enabled = data.delete('cssSelectorsEnabled')
-            caps.takes_screenshot      = data.delete('takesScreenshot')
-            caps.native_events         = data.delete('nativeEvents')
-            caps.rotatable             = data.delete('rotatable')
-            caps.proxy                 = Proxy.json_create(data['proxy']) if data.key?('proxy') && !data['proxy'].empty?
+            caps.browser_name = data.delete('browserName') if data.key?('browserName')
+            caps.browser_version = data.delete('browserVersion') if data.key?('browserVersion')
+            caps.platform_name = data.delete('platformName') if data.key?('platformName')
+            caps.accept_insecure_certs = data.delete('acceptInsecureCerts') if data.key?('acceptInsecureCerts')
+            caps.page_load_strategy = data.delete('pageLoadStrategy') if data.key?('pageLoadStrategy')
+
+            if data.key?('timeouts')
+              timeouts = data.delete('timeouts')
+              caps.implicit_timeout = timeouts['implicit'] if timeouts
+              caps.page_load_timeout = timeouts['pageLoad'] if timeouts
+              caps.script_timeout = timeouts['script'] if timeouts
+            end
+
+            if data.key?('proxy')
+              proxy = data.delete('proxy')
+              caps.proxy = Proxy.json_create(proxy) unless proxy.nil? || proxy.empty?
+            end
+
+            # Remote Server Specific
+            caps[:remote_session_id] = data.delete('webdriver.remote.sessionid') if data.key?('webdriver.remote.sessionid')
 
             # any remaining pairs will be added as is, with no conversion
             caps.merge!(data)
@@ -150,25 +168,20 @@ module Selenium
           end
         end
 
-        # @option :browser_name           [String] required browser name
-        # @option :version                [String] required browser version number
-        # @option :platform               [Symbol] one of :any, :win, :mac, or :x
-        # @option :javascript_enabled     [Boolean] does the driver have javascript enabled?
-        # @option :css_selectors_enabled  [Boolean] does the driver support CSS selectors?
-        # @option :takes_screenshot       [Boolean] can this driver take screenshots?
-        # @option :native_events          [Boolean] does this driver use native events?
-        # @option :proxy                  [Selenium::WebDriver::Proxy, Hash] proxy configuration
-        #
-        # Firefox-specific options:
         #
-        # @option :firefox_profile        [Selenium::WebDriver::Firefox::Profile] the firefox profile to use
+        # @param [Hash] opts
+        # @option :browser_name             [String] required browser name
+        # @option :browser_version          [String] required browser version number
+        # @option :platform_name            [Symbol] one of :any, :win, :mac, or :x
+        # @option :accept_insecure_certs    [Boolean] does the driver accept insecure SSL certifications?
+        # @option :proxy                    [Selenium::WebDriver::Proxy, Hash] proxy configuration
         #
         # @api public
         #
 
         def initialize(opts = {})
-          @capabilities = DEFAULTS.merge(opts)
-          self.proxy    = opts.delete(:proxy)
+          @capabilities = opts
+          self.proxy = opts.delete(:proxy)
         end
 
         #
@@ -204,6 +217,7 @@ module Selenium
           end
         end
 
+        #
         # @api private
         #
 
@@ -214,11 +228,13 @@ module Selenium
             case key
             when :platform
               hash['platform'] = value.to_s.upcase
-            when :firefox_profile
-              hash['firefox_profile'] = value.as_json['zip'] if value
             when :proxy
-              hash['proxy'] = value.as_json if value
-            when String, :firefox_binary
+              if value
+                hash['proxy'] = value.as_json
+                hash['proxy']['proxyType'] &&= hash['proxy']['proxyType'].downcase
+                hash['proxy']['noProxy'] = hash['proxy']['noProxy'].split(', ') if hash['proxy']['noProxy'].is_a?(String)
+              end
+            when String
               hash[key.to_s] = value
             when Symbol
               hash[camel_case(key.to_s)] = value
@@ -236,8 +252,10 @@ module Selenium
 
         def ==(other)
           return false unless other.is_a? self.class
+
           as_json == other.as_json
         end
+
         alias_method :eql?, :==
 
         protected
@@ -249,6 +267,7 @@ module Selenium
         def camel_case(str)
           str.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
         end
+
       end # Capabilities
     end # Remote
   end # WebDriver

data/lib/selenium/webdriver/remote/commands.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # Licensed to the Software Freedom Conservancy (SFC) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -20,197 +20,137 @@
 module Selenium
   module WebDriver
     module Remote
+
+      #
+      # https://w3c.github.io/webdriver/#endpoints
+      # @api private
+      #
+
       class Bridge
-        #
-        # https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol#command-reference
-        #
-
-        command :newSession, :post, 'session'
-        command :getCapabilities, :get, 'session/:session_id'
-        command :status, :get, 'status'
-
-        #
-        # basic driver
-        #
-
-        command :getCurrentUrl, :get, 'session/:session_id/url'
-        command :get, :post, 'session/:session_id/url'
-        command :goForward, :post, 'session/:session_id/forward'
-        command :goBack, :post, 'session/:session_id/back'
-        command :refresh, :post, 'session/:session_id/refresh'
-        command :quit, :delete, 'session/:session_id'
-        command :close, :delete, 'session/:session_id/window'
-        command :getPageSource, :get, 'session/:session_id/source'
-        command :getTitle, :get, 'session/:session_id/title'
-        command :findElement, :post, 'session/:session_id/element'
-        command :findElements, :post, 'session/:session_id/elements'
-        command :getActiveElement, :post, 'session/:session_id/element/active'
-
-        #
-        # window handling
-        #
-
-        command :getCurrentWindowHandle, :get, 'session/:session_id/window_handle'
-        command :getWindowHandles, :get, 'session/:session_id/window_handles'
-        command :setWindowSize, :post, 'session/:session_id/window/:window_handle/size'
-        command :setWindowPosition, :post, 'session/:session_id/window/:window_handle/position'
-        command :getWindowSize, :get, 'session/:session_id/window/:window_handle/size'
-        command :getWindowPosition, :get, 'session/:session_id/window/:window_handle/position'
-        command :maximizeWindow, :post, 'session/:session_id/window/:window_handle/maximize'
-
-        #
-        # script execution
-        #
-
-        command :executeScript, :post, 'session/:session_id/execute'
-        command :executeAsyncScript, :post, 'session/:session_id/execute_async'
-
-        #
-        # screenshot
-        #
-
-        command :screenshot, :get, 'session/:session_id/screenshot'
-
-        #
-        # alerts
-        #
-
-        command :dismissAlert, :post, 'session/:session_id/dismiss_alert'
-        command :acceptAlert, :post, 'session/:session_id/accept_alert'
-        command :getAlertText, :get, 'session/:session_id/alert_text'
-        command :setAlertValue, :post, 'session/:session_id/alert_text'
-        command :setAuthentication, :post, 'session/:session_id/alert/credentials'
-
-        #
-        # target locator
-        #
-
-        command :switchToFrame, :post, 'session/:session_id/frame'
-        command :switchToParentFrame, :post, 'session/:session_id/frame/parent'
-        command :switchToWindow, :post, 'session/:session_id/window'
-
-        #
-        # options
-        #
-
-        command :getCookies, :get, 'session/:session_id/cookie'
-        command :addCookie, :post, 'session/:session_id/cookie'
-        command :deleteAllCookies, :delete, 'session/:session_id/cookie'
-        command :deleteCookie, :delete, 'session/:session_id/cookie/:name'
-
-        #
-        # timeouts
-        #
-
-        command :implicitlyWait, :post, 'session/:session_id/timeouts/implicit_wait'
-        command :setScriptTimeout, :post, 'session/:session_id/timeouts/async_script'
-        command :setTimeout, :post, 'session/:session_id/timeouts'
-
-        #
-        # element
-        #
-
-        command :describeElement, :get, 'session/:session_id/element/:id'
-        command :findChildElement, :post, 'session/:session_id/element/:id/element'
-        command :findChildElements, :post, 'session/:session_id/element/:id/elements'
-        command :clickElement, :post, 'session/:session_id/element/:id/click'
-        command :submitElement, :post, 'session/:session_id/element/:id/submit'
-        command :getElementValue, :get, 'session/:session_id/element/:id/value'
-        command :sendKeysToElement, :post, 'session/:session_id/element/:id/value'
-        command :uploadFile, :post, 'session/:session_id/file'
-        command :getElementTagName, :get, 'session/:session_id/element/:id/name'
-        command :clearElement, :post, 'session/:session_id/element/:id/clear'
-        command :isElementSelected, :get, 'session/:session_id/element/:id/selected'
-        command :isElementEnabled, :get, 'session/:session_id/element/:id/enabled'
-        command :getElementAttribute, :get, 'session/:session_id/element/:id/attribute/:name'
-        command :elementEquals, :get, 'session/:session_id/element/:id/equals/:other'
-        command :isElementDisplayed, :get, 'session/:session_id/element/:id/displayed'
-        command :getElementLocation, :get, 'session/:session_id/element/:id/location'
-        command :getElementLocationOnceScrolledIntoView, :get, 'session/:session_id/element/:id/location_in_view'
-        command :getElementSize, :get, 'session/:session_id/element/:id/size'
-        command :dragElement, :post, 'session/:session_id/element/:id/drag'
-        command :getElementValueOfCssProperty, :get, 'session/:session_id/element/:id/css/:property_name'
-        command :getElementText, :get, 'session/:session_id/element/:id/text'
-
-        #
-        # rotatable
-        #
-
-        command :getScreenOrientation, :get, 'session/:session_id/orientation'
-        command :setScreenOrientation, :post, 'session/:session_id/orientation'
-
-        #
-        # interactions API
-        #
-
-        command :click, :post, 'session/:session_id/click'
-        command :doubleClick, :post, 'session/:session_id/doubleclick'
-        command :mouseDown, :post, 'session/:session_id/buttondown'
-        command :mouseUp, :post, 'session/:session_id/buttonup'
-        command :mouseMoveTo, :post, 'session/:session_id/moveto'
-        command :sendModifierKeyToActiveElement, :post, 'session/:session_id/modifier'
-        command :sendKeysToActiveElement, :post, 'session/:session_id/keys'
-
-        #
-        # html 5
-        #
-
-        command :executeSql, :post, 'session/:session_id/execute_sql'
-
-        command :getLocation, :get, 'session/:session_id/location'
-        command :setLocation, :post, 'session/:session_id/location'
-
-        command :getAppCache, :get, 'session/:session_id/application_cache'
-        command :getAppCacheStatus, :get, 'session/:session_id/application_cache/status'
-        command :clearAppCache, :delete, 'session/:session_id/application_cache/clear'
-
-        command :getNetworkConnection, :get, 'session/:session_id/network_connection'
-        command :setNetworkConnection, :post, 'session/:session_id/network_connection'
-
-        command :getLocalStorageItem, :get, 'session/:session_id/local_storage/key/:key'
-        command :removeLocalStorageItem, :delete, 'session/:session_id/local_storage/key/:key'
-        command :getLocalStorageKeys, :get, 'session/:session_id/local_storage'
-        command :setLocalStorageItem, :post, 'session/:session_id/local_storage'
-        command :clearLocalStorage, :delete, 'session/:session_id/local_storage'
-        command :getLocalStorageSize, :get, 'session/:session_id/local_storage/size'
-
-        command :getSessionStorageItem, :get, 'session/:session_id/session_storage/key/:key'
-        command :removeSessionStorageItem, :delete, 'session/:session_id/session_storage/key/:key'
-        command :getSessionStorageKeys, :get, 'session/:session_id/session_storage'
-        command :setSessionStorageItem, :post, 'session/:session_id/session_storage'
-        command :clearSessionStorage, :delete, 'session/:session_id/session_storage'
-        command :getSessionStorageSize, :get, 'session/:session_id/session_storage/size'
-
-        #
-        # ime
-        #
-
-        command :imeGetAvailableEngines, :get, 'session/:session_id/ime/available_engines'
-        command :imeGetActiveEngine, :get, 'session/:session_id/ime/active_engine'
-        command :imeIsActivated, :get, 'session/:session_id/ime/activated'
-        command :imeDeactivate, :post, 'session/:session_id/ime/deactivate'
-        command :imeActivateEngine, :post, 'session/:session_id/ime/activate'
-
-        #
-        # touch
-        #
-
-        command :touchSingleTap, :post, 'session/:session_id/touch/click'
-        command :touchDoubleTap, :post, 'session/:session_id/touch/doubleclick'
-        command :touchLongPress, :post, 'session/:session_id/touch/longclick'
-        command :touchDown, :post, 'session/:session_id/touch/down'
-        command :touchUp, :post, 'session/:session_id/touch/up'
-        command :touchMove, :post, 'session/:session_id/touch/move'
-        command :touchScroll, :post, 'session/:session_id/touch/scroll'
-        command :touchFlick, :post, 'session/:session_id/touch/flick'
-
-        #
-        # logs
-        #
-
-        command :getAvailableLogTypes, :get, 'session/:session_id/log/types'
-        command :getLog, :post, 'session/:session_id/log'
-      end
+        COMMANDS = {
+          status: [:get, 'status'],
+
+          #
+          # session handling
+          #
+
+          new_session: [:post, 'session'],
+          delete_session: [:delete, 'session/:session_id'],
+
+          #
+          # basic driver
+          #
+
+          get: [:post, 'session/:session_id/url'],
+          get_current_url: [:get, 'session/:session_id/url'],
+          back: [:post, 'session/:session_id/back'],
+          forward: [:post, 'session/:session_id/forward'],
+          refresh: [:post, 'session/:session_id/refresh'],
+          get_title: [:get, 'session/:session_id/title'],
+
+          #
+          # window and Frame handling
+          #
+
+          get_window_handle: [:get, 'session/:session_id/window'],
+          new_window: [:post, 'session/:session_id/window/new'],
+          close_window: [:delete, 'session/:session_id/window'],
+          switch_to_window: [:post, 'session/:session_id/window'],
+          get_window_handles: [:get, 'session/:session_id/window/handles'],
+          fullscreen_window: [:post, 'session/:session_id/window/fullscreen'],
+          minimize_window: [:post, 'session/:session_id/window/minimize'],
+          maximize_window: [:post, 'session/:session_id/window/maximize'],
+          set_window_size: [:post, 'session/:session_id/window/size'],
+          get_window_size: [:get, 'session/:session_id/window/size'],
+          set_window_position: [:post, 'session/:session_id/window/position'],
+          get_window_position: [:get, 'session/:session_id/window/position'],
+          set_window_rect: [:post, 'session/:session_id/window/rect'],
+          get_window_rect: [:get, 'session/:session_id/window/rect'],
+          switch_to_frame: [:post, 'session/:session_id/frame'],
+          switch_to_parent_frame: [:post, 'session/:session_id/frame/parent'],
+
+          #
+          # element
+          #
+
+          find_element: [:post, 'session/:session_id/element'],
+          find_elements: [:post, 'session/:session_id/elements'],
+          find_child_element: [:post, 'session/:session_id/element/:id/element'],
+          find_child_elements: [:post, 'session/:session_id/element/:id/elements'],
+          get_active_element: [:get, 'session/:session_id/element/active'],
+          is_element_selected: [:get, 'session/:session_id/element/:id/selected'],
+          get_element_attribute: [:get, 'session/:session_id/element/:id/attribute/:name'],
+          get_element_property: [:get, 'session/:session_id/element/:id/property/:name'],
+          get_element_css_value: [:get, 'session/:session_id/element/:id/css/:property_name'],
+          get_element_text: [:get, 'session/:session_id/element/:id/text'],
+          get_element_tag_name: [:get, 'session/:session_id/element/:id/name'],
+          get_element_rect: [:get, 'session/:session_id/element/:id/rect'],
+          is_element_enabled: [:get, 'session/:session_id/element/:id/enabled'],
+
+          #
+          # document handling
+          #
+
+          get_page_source: [:get, 'session/:session_id/source'],
+          execute_script: [:post, 'session/:session_id/execute/sync'],
+          execute_async_script: [:post, 'session/:session_id/execute/async'],
+
+          #
+          # cookies
+          #
+
+          get_all_cookies: [:get, 'session/:session_id/cookie'],
+          get_cookie: [:get, 'session/:session_id/cookie/:name'],
+          add_cookie: [:post, 'session/:session_id/cookie'],
+          delete_cookie: [:delete, 'session/:session_id/cookie/:name'],
+          delete_all_cookies: [:delete, 'session/:session_id/cookie'],
+
+          #
+          # timeouts
+          #
+
+          set_timeout: [:post, 'session/:session_id/timeouts'],
+
+          #
+          # actions
+          #
+
+          actions: [:post, 'session/:session_id/actions'],
+          release_actions: [:delete, 'session/:session_id/actions'],
+
+          #
+          # Element Operations
+          #
+
+          element_click: [:post, 'session/:session_id/element/:id/click'],
+          element_tap: [:post, 'session/:session_id/element/:id/tap'],
+          element_clear: [:post, 'session/:session_id/element/:id/clear'],
+          element_send_keys: [:post, 'session/:session_id/element/:id/value'],
+
+          #
+          # alerts
+          #
+
+          dismiss_alert: [:post, 'session/:session_id/alert/dismiss'],
+          accept_alert: [:post, 'session/:session_id/alert/accept'],
+          get_alert_text: [:get, 'session/:session_id/alert/text'],
+          send_alert_text: [:post, 'session/:session_id/alert/text'],
+
+          #
+          # screenshot
+          #
+
+          take_screenshot: [:get, 'session/:session_id/screenshot'],
+          take_element_screenshot: [:get, 'session/:session_id/element/:id/screenshot'],
+
+          #
+          # server extensions
+          #
+
+          upload_file: [:post, 'session/:session_id/se/file']
+        }.freeze
+
+      end # Bridge
     end # Remote
   end # WebDriver
 end # Selenium