selenium-webdriver 4.0.0.alpha6 → 4.0.0.beta4

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

@@ -82,6 +82,8 @@ module Selenium
           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_aria_role: [:get, 'session/:session_id/element/:id/computedrole'],
+          get_element_aria_label: [:get, 'session/:session_id/element/:id/computedlabel'],
           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'],
@@ -117,6 +119,7 @@ module Selenium
 
           actions: [:post, 'session/:session_id/actions'],
           release_actions: [:delete, 'session/:session_id/actions'],
+          print_page: [:post, 'session/:session_id/print'],
 
           #
           # Element Operations

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

@@ -28,11 +28,8 @@ module Selenium
 
       class Driver < WebDriver::Driver
         include DriverExtensions::UploadsFiles
-        include DriverExtensions::TakesScreenshot
         include DriverExtensions::HasSessionId
-        include DriverExtensions::Rotatable
         include DriverExtensions::HasRemoteStatus
-        include DriverExtensions::HasWebStorage
 
         def initialize(bridge: nil, listener: nil, **opts)
           desired_capabilities = opts[:desired_capabilities]
@@ -46,6 +43,16 @@ module Selenium
           opts[:url] ||= "http://#{Platform.localhost}:4444/wd/hub"
           super
         end
+
+        private
+
+        def devtools_url
+          capabilities['se:cdp']
+        end
+
+        def devtools_version
+          capabilities['se:cdpVersion'].split('.').first
+        end
       end # Driver
     end # Remote
   end # WebDriver

data/lib/selenium/webdriver/remote/http/common.rb

@@ -30,13 +30,8 @@ module Selenium
             'User-Agent' => "selenium/#{WebDriver::VERSION} (ruby #{Platform.os})"
           }.freeze
 
-          attr_accessor :timeout
           attr_writer :server_url
 
-          def initialize
-            @timeout = nil
-          end
-
           def quit_errors
             [IOError]
           end

data/lib/selenium/webdriver/remote/http/default.rb

@@ -28,8 +28,7 @@ module Selenium
         class Default < Common
           attr_writer :proxy
 
-          attr_accessor :open_timeout
-          attr_accessor :read_timeout
+          attr_accessor :open_timeout, :read_timeout
 
           # Initializes object.
           # Warning: Setting {#open_timeout} to non-nil values will cause a separate thread to spawn.
@@ -39,6 +38,7 @@ module Selenium
           def initialize(open_timeout: nil, read_timeout: nil)
             @open_timeout = open_timeout
             @read_timeout = read_timeout
+            super()
           end
 
           def close
@@ -55,8 +55,7 @@ module Selenium
                 http.verify_mode = OpenSSL::SSL::VERIFY_NONE
               end
 
-              # Defaulting open_timeout to nil to be consistent with Ruby 2.2 and earlier.
-              http.open_timeout = open_timeout
+              http.open_timeout = open_timeout if open_timeout
               http.read_timeout = read_timeout if read_timeout
 
               start(http)
@@ -128,12 +127,14 @@ module Selenium
           def new_http_client
             if use_proxy?
               url = @proxy.http
-              raise Error::WebDriverError, "expected HTTP proxy, got #{@proxy.inspect}" unless proxy.respond_to?(:http) && url
+              unless proxy.respond_to?(:http) && url
+                raise Error::WebDriverError,
+                      "expected HTTP proxy, got #{@proxy.inspect}"
+              end
 
               proxy = URI.parse(url)
 
-              clazz = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password)
-              clazz.new(server_url.host, server_url.port)
+              Net::HTTP.new(server_url.host, server_url.port, proxy.host, proxy.port, proxy.user, proxy.password)
             else
               Net::HTTP.new server_url.host, server_url.port
             end

data/lib/selenium/webdriver/remote/http/persistent.rb

@@ -25,6 +25,12 @@ module Selenium
       module Http
         # @api private
         class Persistent < Default
+          def initialize(open_timeout: nil, read_timeout: nil)
+            WebDriver.logger.deprecate("Selenium::WebDriver::Remote::Http::Persistent",
+                                       id: :http_persistent) { "The default HTTP client now uses persistence." }
+            super
+          end
+
           def close
             @http&.shutdown
           end

data/lib/selenium/webdriver/safari.rb

@@ -20,18 +20,25 @@
 module Selenium
   module WebDriver
     module Safari
-      autoload :Bridge, 'selenium/webdriver/safari/bridge'
+      autoload :Features, 'selenium/webdriver/safari/features'
       autoload :Driver, 'selenium/webdriver/safari/driver'
       autoload :Options, 'selenium/webdriver/safari/options'
       autoload :Service, 'selenium/webdriver/safari/service'
 
       class << self
+        attr_accessor :use_technology_preview
+
         def technology_preview
           "/Applications/Safari\ Technology\ Preview.app/Contents/MacOS/safaridriver"
         end
 
         def technology_preview!
           Service.driver_path = technology_preview
+          @use_technology_preview = true
+        end
+
+        def technology_preview?
+          use_technology_preview
         end
 
         def path=(path)

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

@@ -27,18 +27,13 @@ module Selenium
       #
 
       class Driver < WebDriver::Driver
-        include DriverExtensions::HasDebugger
-        include DriverExtensions::HasPermissions
-        include DriverExtensions::HasWebStorage
-        include DriverExtensions::TakesScreenshot
+        EXTENSIONS = [DriverExtensions::HasDebugger,
+                      DriverExtensions::HasPermissions,
+                      DriverExtensions::HasWebStorage].freeze
 
         def browser
           :safari
         end
-
-        def bridge_class
-          Bridge
-        end
       end # Driver
     end # Safari
   end # WebDriver

data/lib/selenium/webdriver/safari/{bridge.rb → features.rb}

@@ -20,17 +20,17 @@
 module Selenium
   module WebDriver
     module Safari
-      class Bridge < WebDriver::Remote::Bridge
+      module Features
 
         # https://developer.apple.com/library/content/documentation/NetworkingInternetWeb/Conceptual/WebDriverEndpointDoc/Commands/Commands.html
-        COMMANDS = {
+        SAFARI_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 commands(command)
-          COMMANDS[command] || super
+          SAFARI_COMMANDS[command] || self.class::COMMANDS[command]
         end
 
         def permissions

data/lib/selenium/webdriver/safari/options.rb

@@ -28,31 +28,6 @@ module Selenium
                         automatic_profiling: 'safari:automaticProfiling'}.freeze
         BROWSER = 'safari'
 
-        CAPABILITIES.each_key do |key|
-          define_method key do
-            @options[key]
-          end
-
-          define_method "#{key}=" do |value|
-            @options[key] = value
-          end
-        end
-
-        #
-        # Create a new Options instance for W3C-capable versions of Safari.
-        #
-        # @example
-        #   options = Selenium::WebDriver::Safari::Options.new(automatic_inspection: true)
-        #   driver = Selenium::WebDriver.for :safari, options: options
-        #
-        # @param [Hash] opts the pre-defined options to create the Safari::Options with
-        # @option opts [Boolean] :automatic_inspection Preloads Web Inspector and JavaScript debugger. Default is false
-        # @option opts [Boolean] :automatic_profiling Preloads Web Inspector and starts a timeline recording. Default is false
-        #
-
-        def initialize(**opts)
-          super
-        end
       end # Options
     end # Safari
   end # WebDriver

data/lib/selenium/webdriver/support/block_event_listener.rb

@@ -25,7 +25,7 @@ module Selenium
           @callback = callback
         end
 
-        def method_missing(meth, *args) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
+        def method_missing(meth, *args) # rubocop:disable Style/MissingRespondToMissing
           @callback.call meth, *args
         end
       end # BlockEventListener

data/lib/selenium/webdriver/support/cdp/domain.rb.erb

@@ -0,0 +1,63 @@
+# 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.
+
+# This file is automatically generated. Any changes will be lost!
+module Selenium
+  module DevTools
+    module <%= version %>
+      class <%= domain[:domain] %>
+        <% if domain[:events] %>
+        EVENTS = {
+          <% domain[:events].each do |event| %>
+          <%= h.snake_case(event[:name]) %>: '<%= event[:name] %>',
+          <% end %>
+        }.freeze
+        <% end %>
+
+        def initialize(devtools)
+          @devtools = devtools
+        end
+
+        def on(event, &block)
+          event = EVENTS[event] if event.is_a?(Symbol)
+          @devtools.callbacks["<%= domain[:domain] %>.#{event}"] << block
+        end
+
+        <% domain[:commands].each do |command| %>
+        <% if command[:parameters] %>
+        def <%= h.snake_case(command[:name]) %>(<%= h.kwargs(command[:parameters]) %>)
+        <% else %>
+        def <%= h.snake_case(command[:name]) %>
+        <% end %>
+          <% if command[:parameters] %>
+          @devtools.send_cmd('<%= domain[:domain] %>.<%= command[:name] %>',
+            <% until command[:parameters].empty? %>
+              <% parameter = command[:parameters].shift %>
+                             <%= parameter[:name] %>: <%= h.snake_case(parameter[:name]) %><%= command[:parameters].empty? ? ')' : ',' %>
+            <% end %>
+          <% else %>
+          @devtools.send_cmd('<%= domain[:domain] %>.<%= command[:name] %>')
+          <% end %>
+        end
+
+        <% end %>
+      end # <%= domain[:domain] %>
+    end # <%= version %>
+  end # DevTools
+end # Selenium

data/lib/selenium/webdriver/support/cdp_client_generator.rb

@@ -18,38 +18,48 @@
 # under the License.
 
 require 'erb'
+require 'fileutils'
 require 'json'
 
 module Selenium
   module WebDriver
     module Support
       class CDPClientGenerator
-        DEVTOOLS_DIR = File.expand_path('../devtools', __dir__)
-        BROWSER_PROTOCOL_PATH = File.expand_path('cdp/browser_protocol.json', __dir__)
-        JS_PROTOCOL_PATH = File.expand_path('cdp/js_protocol.json', __dir__)
+        # Input JSON files are generated from PDL tasks.
         TEMPLATE_PATH = File.expand_path('cdp/domain.rb.erb', __dir__)
 
         RESERVED_KEYWORDS = %w[end].freeze
 
-        def initialize
-          @browser_protocol = JSON.parse(File.read(BROWSER_PROTOCOL_PATH), symbolize_names: true)
-          @js_protocol = JSON.parse(File.read(JS_PROTOCOL_PATH), symbolize_names: true)
+        def call(output_dir:, version:, browser_protocol_path: nil, js_protocol_path: nil, loader_path: nil, **)
           @template = ERB.new(File.read(TEMPLATE_PATH))
-        end
+          @output_dir = output_dir
+          @loader_path = loader_path || "#{@output_dir}.rb"
+          @version = version
+
+          browser_protocol_path ||= File.expand_path('cdp/browser_protocol.json', __dir__)
+          js_protocol_path ||= File.expand_path('cdp/js_protocol.json', __dir__)
+
+          browser_protocol = JSON.parse(File.read(browser_protocol_path), symbolize_names: true)
+          js_protocol = JSON.parse(File.read(js_protocol_path), symbolize_names: true)
 
-        def call
-          @browser_protocol[:domains].each(&method(:process_domain))
-          @js_protocol[:domains].each(&method(:process_domain))
+          FileUtils.mkdir_p(@output_dir)
+
+          browser_protocol[:domains].each(&method(:process_domain))
+          js_protocol[:domains].each(&method(:process_domain))
+          require_file
         end
 
         def process_domain(domain)
-          result = @template.result_with_hash(domain: domain, h: self)
-          filename = File.join(DEVTOOLS_DIR, "#{snake_case(domain[:domain])}.rb")
+          result = @template.result_with_hash(domain: domain, version: @version.upcase, h: self)
+          filename = File.join(@output_dir, "#{snake_case(domain[:domain])}.rb")
           File.write(filename, remove_empty_lines(result))
         end
 
         def snake_case(string)
-          name = string.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+          name = string.gsub('JavaScript', 'Javascript')
+                       .gsub(/([A-Z]+)([A-Z][a-z]{2,})/, '\1_\2')
+                       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                       .downcase
           # Certain CDP parameters conflict with Ruby keywords
           # so we prefix the name with underscore.
           name = "_#{name}" if RESERVED_KEYWORDS.include?(name)
@@ -71,7 +81,28 @@ module Selenium
         def remove_empty_lines(string)
           string.split("\n").reject { |l| l =~ /^\s+$/ }.join("\n")
         end
+
+        def require_file
+          # rubocop:disable Lint/InterpolationCheck
+          dynamic_location = '#{File.dirname(File.absolute_path(__FILE__))}'
+          # rubocop:enable Lint/InterpolationCheck
+
+          require_all = "Dir.glob(\"#{dynamic_location}/#{@version}/*\", &method(:require))"
+          File.open(@loader_path, 'w') { |file| file.write(require_all) }
+        end
       end
     end
   end
 end
+
+if $PROGRAM_NAME == __FILE__
+  browser_protocol_path, js_protocol_path, output_dir, loader_path, version = *ARGV
+
+  Selenium::WebDriver::Support::CDPClientGenerator.new.call(
+    browser_protocol_path: browser_protocol_path,
+    js_protocol_path: js_protocol_path,
+    output_dir: output_dir,
+    loader_path: loader_path,
+    version: version
+  )
+end

data/lib/selenium/webdriver/support/event_firing_bridge.rb

@@ -120,7 +120,7 @@ module Selenium
           returned
         end
 
-        def method_missing(meth, *args, &blk) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
+        def method_missing(meth, *args, &blk) # rubocop:disable Style/MissingRespondToMissing
           @delegate.__send__(meth, *args, &blk)
         end
       end # EventFiringBridge

data/lib/selenium/webdriver/support/guards.rb

@@ -0,0 +1,95 @@
+# 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.
+
+require_relative 'guards/guard_condition'
+require_relative 'guards/guard'
+
+module Selenium
+  module WebDriver
+    module Support
+      class Guards
+        GUARD_TYPES = %i[except only exclude exclusive].freeze
+
+        attr_reader :messages
+        attr_accessor :bug_tracker
+
+        def initialize(example, bug_tracker: '', conditions: nil)
+          @example = example
+          @bug_tracker = bug_tracker
+          @guard_conditions = conditions || []
+          @guards = collect_example_guards
+          @messages = {}
+        end
+
+        def add_condition(name, condition = nil, &blk)
+          @guard_conditions << GuardCondition.new(name, condition, &blk)
+        end
+
+        def add_message(name, message)
+          @messages[name] = message
+        end
+
+        def disposition
+          if !skipping_guard.nil?
+            [:skip, skipping_guard.message]
+          elsif !pending_guard.nil? && ENV['SKIP_PENDING']
+            [:skip, pending_guard.message]
+          elsif !pending_guard.nil?
+            [:pending, pending_guard.message]
+          end
+        end
+
+        def satisfied?(guard)
+          @guard_conditions.all? { |condition| condition.satisfied?(guard) }
+        end
+
+        private
+
+        def collect_example_guards
+          guards = []
+
+          GUARD_TYPES.each do |guard_type|
+            example_group = @example.metadata[:example_group]
+            example_guards = [@example.metadata[guard_type], example_group[guard_type]]
+            while example_group[:parent_example_group]
+              example_group = example_group[:parent_example_group]
+              example_guards << example_group[guard_type]
+            end
+
+            example_guards.flatten.uniq.compact.each do |example_guard|
+              guards << Guard.new(example_guard, guard_type, self)
+            end
+          end
+
+          guards
+        end
+
+        def skipping_guard
+          @guards.select(&:exclusive?).find { |guard| !satisfied?(guard) } ||
+            @guards.select(&:exclude?).find { |guard| satisfied?(guard) }
+        end
+
+        def pending_guard
+          @guards.select(&:except?).find { |guard| satisfied?(guard) } ||
+            @guards.select(&:only?).find { |guard| !satisfied?(guard) }
+        end
+      end # Guards
+    end # Support
+  end # WebDriver
+end # Selenium