selenium-webdriver 2.53.3 → 3.142.7

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

@@ -0,0 +1,310 @@
+# 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
+      module W3C
+
+        #
+        # Specification of the desired and/or actual capabilities of the browser that the
+        # server is being asked to create.
+        #
+        # @api private
+        #
+
+        class Capabilities
+
+          EXTENSION_CAPABILITY_PATTERN = /\A[\w-]+:.*\z/.freeze
+
+          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: (alex) deprecate in favor of Firefox::Options?
+            :accessibility_checks,
+            :device,
+
+            # TODO: (alex) 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|
+              case key
+              when :accessibility_checks
+                WebDriver.logger.deprecate(":accessibility_checks capability")
+              when :device
+                WebDriver.logger.deprecate(":device capability")
+              end
+              @capabilities[key] = value
+            end
+          end
+
+          #
+          # 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.
+          #
+
+          class << self
+            def edge(opts = {})
+              WebDriver.logger.deprecate('Selenium::WebDriver::Remote::W3C::Capabilities.edge',
+                                         'Selenium::WebDriver::Remote::Capabilities.edge')
+              Remote::Capabilities.edge(opts)
+            end
+
+            def firefox(opts = {})
+              WebDriver.logger.deprecate('Selenium::WebDriver::Remote::W3C::Capabilities.firefox',
+                                         'Selenium::WebDriver::Remote::Capabilities.firefox')
+              Remote::Capabilities.firefox(opts)
+            end
+
+            alias_method :ff, :firefox
+
+            #
+            # @api private
+            #
+
+            def json_create(data)
+              data = data.dup
+
+              caps = new
+              caps.browser_name = data.delete('browserName')
+              caps.browser_version = data.delete('browserVersion')
+              caps.platform_name = data.delete('platformName')
+              caps.accept_insecure_certs = data.delete('acceptInsecureCerts') if data.key?('acceptInsecureCerts')
+              caps.page_load_strategy = data.delete('pageLoadStrategy')
+              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
+
+              proxy = data.delete('proxy')
+              caps.proxy = Proxy.json_create(proxy) unless proxy.nil? || proxy.empty?
+
+              # Remote Server Specific
+              caps[:remote_session_id] = data.delete('webdriver.remote.sessionid')
+
+              # Marionette Specific
+              caps[:accessibility_checks] = data.delete('moz:accessibilityChecks')
+              caps[:profile] = data.delete('moz:profile')
+              caps[:rotatable] = data.delete('rotatable')
+              caps[:device] = data.delete('device')
+
+              # any remaining pairs will be added as is, with no conversion
+              caps.merge!(data)
+
+              caps
+            end
+
+            #
+            # Creates W3C compliant capabilities from OSS ones.
+            # @param oss_capabilities [Hash, Remote::Capabilities]
+            #
+
+            def from_oss(oss_capabilities) # rubocop:disable Metrics/MethodLength
+              w3c_capabilities = new
+
+              # TODO: (alex) make capabilities enumerable?
+              oss_capabilities = oss_capabilities.__send__(:capabilities) unless oss_capabilities.is_a?(Hash)
+              oss_capabilities.each do |name, value|
+                next if value.nil?
+                next if value.is_a?(String) && value.empty?
+
+                capability_name = name.to_s
+
+                snake_cased_capability_names = KNOWN.map(&:to_s)
+                camel_cased_capability_names = snake_cased_capability_names.map(&w3c_capabilities.method(:camel_case))
+
+                next unless snake_cased_capability_names.include?(capability_name) ||
+                            camel_cased_capability_names.include?(capability_name) ||
+                            capability_name.match(EXTENSION_CAPABILITY_PATTERN)
+
+                w3c_capabilities[name] = value
+              end
+
+              # User can pass :firefox_options or :firefox_profile.
+              #
+              # TODO: (alex) Refactor this whole method into converter class.
+              firefox_options = oss_capabilities['firefoxOptions'] || oss_capabilities['firefox_options'] || oss_capabilities[:firefox_options]
+              firefox_profile = oss_capabilities['firefox_profile'] || oss_capabilities[:firefox_profile]
+              firefox_binary  = oss_capabilities['firefox_binary'] || oss_capabilities[:firefox_binary]
+
+              if firefox_options
+                WebDriver.logger.deprecate(':firefox_options capabilitiy', 'Selenium::WebDriver::Firefox::Options')
+              end
+
+              if firefox_profile
+                WebDriver.logger.deprecate(':firefox_profile capabilitiy', 'Selenium::WebDriver::Firefox::Options#profile')
+              end
+
+              if firefox_binary
+                WebDriver.logger.deprecate(':firefox_binary capabilitiy', 'Selenium::WebDriver::Firefox::Options#binary')
+              end
+
+              if firefox_profile && firefox_options
+                second_profile = firefox_options['profile'] || firefox_options[:profile]
+                if second_profile && firefox_profile != second_profile
+                  raise Error::WebDriverError, 'You cannot pass 2 different Firefox profiles'
+                end
+              end
+
+              if firefox_options || firefox_profile || firefox_binary
+                options = WebDriver::Firefox::Options.new(firefox_options || {})
+                options.binary = firefox_binary if firefox_binary
+                options.profile = firefox_profile if firefox_profile
+                w3c_capabilities.merge!(options.as_json)
+              end
+
+              w3c_capabilities
+            end
+          end
+
+          #
+          # @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 = opts
+            self.proxy = opts.delete(:proxy)
+          end
+
+          #
+          # Allows setting arbitrary capabilities.
+          #
+
+          def []=(key, value)
+            @capabilities[key] = value
+          end
+
+          def [](key)
+            @capabilities[key]
+          end
+
+          def merge!(other)
+            if other.respond_to?(:capabilities, true) && other.capabilities.is_a?(Hash)
+              @capabilities.merge! other.capabilities
+            elsif other.is_a? Hash
+              @capabilities.merge! other
+            else
+              raise ArgumentError, 'argument should be a Hash or implement #capabilities'
+            end
+          end
+
+          def proxy=(proxy)
+            case proxy
+            when Hash
+              @capabilities[:proxy] = Proxy.new(proxy)
+            when Proxy, nil
+              @capabilities[:proxy] = proxy
+            else
+              raise TypeError, "expected Hash or #{Proxy.name}, got #{proxy.inspect}:#{proxy.class}"
+            end
+          end
+
+          #
+          # @api private
+          #
+
+          def as_json(*)
+            hash = {}
+
+            @capabilities.each do |key, value|
+              case key
+              when :platform
+                hash['platform'] = value.to_s.upcase
+              when :proxy
+                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, :firefox_binary
+                hash[key.to_s] = value
+              when Symbol
+                hash[camel_case(key.to_s)] = value
+              else
+                raise TypeError, "expected String or Symbol, got #{key.inspect}:#{key.class} / #{value.inspect}"
+              end
+            end
+
+            hash
+          end
+
+          def to_json(*)
+            JSON.generate as_json
+          end
+
+          def ==(other)
+            return false unless other.is_a? self.class
+
+            as_json == other.as_json
+          end
+
+          alias_method :eql?, :==
+
+          protected
+
+          attr_reader :capabilities
+
+          private
+
+          def camel_case(str)
+            str.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+          end
+
+        end # Capabilities
+      end # W3c
+    end # Remote
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,157 @@
+# 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
+      module W3C
+
+        #
+        # http://www.w3.org/TR/2015/WD-webdriver-20150918/#list-of-endpoints
+        # @api private
+        #
+
+        class Bridge
+          COMMANDS = {
+
+            #
+            # 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 # W3C
+    end # Remote
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/remote.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
@@ -19,23 +19,17 @@
 
 require 'uri'
 
-require 'selenium/webdriver/remote/capabilities'
-require 'selenium/webdriver/remote/w3c_capabilities'
 require 'selenium/webdriver/remote/bridge'
-require 'selenium/webdriver/remote/w3c_bridge'
-require 'selenium/webdriver/remote/server_error'
+require 'selenium/webdriver/remote/driver'
 require 'selenium/webdriver/remote/response'
-require 'selenium/webdriver/remote/commands'
-require 'selenium/webdriver/remote/w3c_commands'
+require 'selenium/webdriver/remote/server_error'
 require 'selenium/webdriver/remote/http/common'
 require 'selenium/webdriver/remote/http/default'
 
-module Selenium
-  module WebDriver
-
-    # @api private
-    module Remote
+require 'selenium/webdriver/remote/capabilities'
+require 'selenium/webdriver/remote/oss/bridge'
+require 'selenium/webdriver/remote/oss/commands'
 
-    end # Remote
-  end # WebDriver
-end # Selenium
+require 'selenium/webdriver/remote/w3c/bridge'
+require 'selenium/webdriver/remote/w3c/capabilities'
+require 'selenium/webdriver/remote/w3c/commands'

data/lib/selenium/webdriver/safari/bridge.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,113 +20,29 @@
 module Selenium
   module WebDriver
     module Safari
+      module Bridge
 
-      class Bridge < Remote::Bridge
-        COMMAND_TIMEOUT = 60
-
-        def initialize(opts = {})
-          command_timeout = Integer(opts[:timeout] || COMMAND_TIMEOUT)
-          safari_options  = opts.delete(:options) || Safari::Options.new(opts)
-          capabilities    = merge_capabilities(opts, safari_options)
-
-          @command_id ||= 0
-
-          # TODO: handle safari_opts['cleanSession']
-          @server = Server.new(safari_options.port, command_timeout)
-          @server.start
-
-          @safari = Browser.new
-          @safari.start(prepare_connect_file)
-
-          @server.wait_for_connection
-
-          super(desired_capabilities: capabilities)
-        end
-
-        def quit
-          super
-
-          @server.stop
-          @safari.stop
-        end
-
-        def driver_extensions
-          [
-            DriverExtensions::TakesScreenshot,
-            DriverExtensions::HasInputDevices
-          ]
-        end
-
-        private
+        # https://developer.apple.com/library/content/documentation/NetworkingInternetWeb/Conceptual/WebDriverEndpointDoc/Commands/Commands.html
+        COMMANDS = {
+          get_permissions: [:get, 'session/:session_id/apple/permissions'],
+          set_permissions: [:post, 'session/:session_id/apple/permissions'],
+          attach_debugger: [:post, 'session/:session_id/apple/attach_debugger']
+        }.freeze
 
-        def create_session(desired_capabilities)
-          resp = raw_execute :newSession, {}, :desiredCapabilities => desired_capabilities
-          Remote::Capabilities.json_create resp.fetch('value')
+        def commands(command)
+          COMMANDS[command] || super
         end
 
-        def raw_execute(command, opts = {}, command_hash = nil)
-          @command_id += 1
-
-          params = {}
-          opts.each do |key, value|
-            params[camel_case(key.to_s)] = value
-          end
-
-          params.merge!(command_hash) if command_hash
-
-          @server.send(
-            :origin  => "webdriver",
-            :type    => "command",
-            :command => { :id => @command_id.to_s, :name => command, :parameters => params}
-          )
-
-          raw = @server.receive
-          response = raw.fetch('response')
-
-          status_code = response['status']
-          if status_code != 0
-            raise Error.for_code(status_code), response['value']['message']
-          end
-
-          if raw['id'].to_s != @command_id.to_s
-            raise Error::WebDriverError, "response id does not match command id: #{raw['id']} != #{@command_id}"
-          end
-
-          response
+        def permissions
+          execute(:get_permissions)['permissions']
         end
 
-        def camel_case(str)
-          parts = str.split('_')
-          parts[1..-1].map { |e| e.capitalize! }
-
-          parts.join
+        def permissions=(permissions)
+          execute :set_permissions, {}, {permissions: permissions}
         end
 
-        def prepare_connect_file
-          # TODO: use tempfile?
-          path = File.join(Dir.tmpdir, "safaridriver-#{Time.now.usec}.html")
-
-          File.open(path, 'w') do |io|
-            io << "<!DOCTYPE html><script>window.location = '#{@server.uri}';</script>"
-          end
-
-          FileReaper << path
-          path.gsub! "/", "\\" if Platform.windows?
-
-          path
-        end
-
-        def merge_capabilities(opts, safari_options)
-          caps  = safari_options.to_capabilities
-          other = opts[:desired_capabilities]
-
-          if other
-            other = opts[:desired_capabilities].as_json
-            caps['safari.options'].merge!(other.delete('safari.options') || {})
-            caps.merge!(other)
-          end
-
-          caps
+        def attach_debugger
+          execute :attach_debugger, {}, {}
         end
 
       end # Bridge