selenium-webdriver 3.142.7 → 4.0.0.alpha1

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

@@ -20,29 +20,38 @@
 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|
-          if key != :javascript_enabled
-            define_method key do
-              @capabilities.fetch(key)
-            end
+
+        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
@@ -53,19 +62,13 @@ module Selenium
         end
 
         #
-        # Returns javascript_enabled capability.
-        # It is true if not set explicitly.
+        # Backward compatibility
         #
-        def javascript_enabled
-          javascript_enabled = @capabilities.fetch(:javascript_enabled)
-          javascript_enabled.nil? ? true : javascript_enabled
-        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
+        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.
@@ -74,16 +77,14 @@ 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 = {})
             new({
               browser_name: 'MicrosoftEdge',
-              platform: :windows
+              platform_name: :windows
             }.merge(opts))
           end
 
@@ -94,15 +95,15 @@ module Selenium
             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)
-            new({browser_name: 'firefox', marionette: true}.merge(opts))
+            new({browser_name: 'firefox'}.merge(opts))
           end
 
-          def firefox_legacy(opts = {})
+          alias_method :ff, :firefox
+
+          def safari(opts = {})
             new({
-              browser_name: 'firefox',
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
+              browser_name: 'safari',
+              platform_name: :mac
             }.merge(opts))
           end
 
@@ -112,44 +113,14 @@ module Selenium
             }.merge(opts))
           end
 
-          def htmlunitwithjs(opts = {})
-            new({
-              browser_name: 'htmlunit',
-              javascript_enabled: true
-            }.merge(opts))
-          end
-
           def internet_explorer(opts = {})
             new({
               browser_name: 'internet explorer',
-              platform: :windows,
-              takes_screenshot: true,
-              css_selectors_enabled: true,
-              native_events: true
+              platform_name: :windows
             }.merge(opts))
           end
           alias_method :ie, :internet_explorer
 
-          def phantomjs(opts = {})
-            WebDriver.logger.deprecate 'Selenium support for PhantomJS', 'headless Chrome/Firefox or HTMLUnit'
-            new({
-              browser_name: 'phantomjs',
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
-            }.merge(opts))
-          end
-
-          def safari(opts = {})
-            new({
-              browser_name: 'safari',
-              platform: :mac,
-              javascript_enabled: true,
-              takes_screenshot: true,
-              css_selectors_enabled: true
-            }.merge(opts))
-          end
-
           #
           # @api private
           #
@@ -158,15 +129,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.tr(' ', '_').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)
@@ -176,21 +158,19 @@ module Selenium
         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
+        # @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
 
         #
@@ -230,24 +210,20 @@ module Selenium
         # @api private
         #
 
-        def as_json(*) # rubocop:disable Metrics/CyclomaticComplexity
+        def as_json(*)
           hash = {}
 
           @capabilities.each do |key, value|
             case key
             when :platform
               hash['platform'] = value.to_s.upcase
-            when :firefox_profile
-              if value
-                WebDriver.logger.deprecate(':firefox_profile capabilitiy', 'Selenium::WebDriver::Firefox::Options#profile')
-                hash['firefox_profile'] = value.as_json['zip']
-              end
             when :proxy
-              hash['proxy'] = value.as_json if value
-            when String, :firefox_binary
-              if key == :firefox_binary && value
-                WebDriver.logger.deprecate(':firefox_binary capabilitiy', 'Selenium::WebDriver::Firefox::Options#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
@@ -268,6 +244,7 @@ module Selenium
 
           as_json == other.as_json
         end
+
         alias_method :eql?, :==
 
         protected
@@ -279,6 +256,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

@@ -0,0 +1,156 @@
+# 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
+# regarding copyright ownership.  The SFC licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Selenium
+  module WebDriver
+    module Remote
+
+      #
+      # https://w3c.github.io/webdriver/#endpoints
+      # @api private
+      #
+
+      class Bridge
+        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

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

@@ -36,12 +36,19 @@ module Selenium
 
         def initialize(opts = {})
           listener = opts.delete(:listener)
-          @bridge = Bridge.handshake(opts)
-          if @bridge.dialect == :oss
-            extend DriverExtensions::HasTouchScreen
-            extend DriverExtensions::HasLocation
-            extend DriverExtensions::HasNetworkConnection
+          desired_capabilities = opts.delete(:desired_capabilities) { Capabilities.new }
+
+          if desired_capabilities.is_a?(Symbol)
+            unless Capabilities.respond_to?(desired_capabilities)
+              raise Error::WebDriverError, "invalid desired capability: #{desired_capabilities.inspect}"
+            end
+
+            desired_capabilities = Capabilities.__send__(desired_capabilities)
           end
+
+          @bridge = Bridge.new(opts)
+          @bridge.create_session(desired_capabilities, opts.delete(:options))
+
           super(@bridge, listener: listener)
         end