watir 6.19.1 → 7.0.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c714ef62b6caccbf6f2885fd9ea9ece26d42c9b64f64642dadd445e35029da0c
-  data.tar.gz: 2621db569beaa32c36577da613a0c27e16a64ca45e286a37e1cd000c3bf46db1
+  metadata.gz: 994057876b1f2ad97972dfe3a43f139cf761aefabcacbc7ab1d2bc659693e70e
+  data.tar.gz: d0bcac18f0cfe6d9d2a0258bb57a8e2e9f0804feda5eeaf8e5d840fd859de3c4
 SHA512:
-  metadata.gz: 510bf92bb5212caec7334540076448f43bf13e4fcef510a36c78188718a1e744094b7cfe6dad3b713f51a2cf36f9ad22d5dfbf5983406fdb0bddcf75fb9a3fff
-  data.tar.gz: 634cff1ed0f60d0d88f6596b377933b0ec6eda95dae9fd554352e4bb6c55ef2f8f7b791fd0b2abc8bcc39d3bc4e4a4f52429c7db6efae533fb1d8f0e45159159
+  metadata.gz: b652878ab0a6b4365e3226a664945a86c96f8f94c6b0cd4744c0809a66d8fb49ff37951726699df217856d413d4104778164218ca365a1481ec6ab1212c2f12e
+  data.tar.gz: f6f5f093a6072f1456055853d2b93ce994b978897668eb3348ee6fe70fa872eea681c97481d254830f5d028cce0029bb9e45a5dd25d50d785a6e144592d429a2

data/.github/actions/install-chrome/action.yml

@@ -1,4 +1,5 @@
 name: 'Install Chrome'
+description: 'Install Chrome Stable'
 runs:
   using: "composite"
   steps:

data/.github/actions/setup-linux/action.yml

@@ -0,0 +1,8 @@
+name: 'Setup Linux'
+description: 'Run Linux in Virtual Desktop'
+runs:
+  using: "composite"
+  steps:
+    - shell: bash
+      run: |
+        Xvfb :99 &

data/.github/workflows/tests.yml

@@ -0,0 +1,100 @@
+name: All Tests
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  documentation-test:
+    name: Yard Doctest
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.6
+      - run: bundle install
+      - uses: ./.github/actions/install-chrome
+      - uses: ./.github/actions/setup-linux
+      - run: |
+          bundle exec rake yard:doctest
+
+  unit-test:
+    name: Unit Tests
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['2.5', '2.6', '2.7', '3.0']
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - run: bundle install
+      - uses: ./.github/actions/install-chrome
+      - uses: ./.github/actions/setup-linux
+      - run: |
+          bundle exec rake spec:unit
+        env:
+          DISPLAY: :99
+
+  linter-test:
+    name: Rubocop Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.6
+      - run: bundle install
+      - run: bundle exec rubocop
+
+  local-tests:
+    name: Local Tests
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        ruby: [ 2.6, 3.0 ]
+        task: [ chrome, firefox, edge ]
+        include:
+          - os: 'macos-latest'
+            task: 'safari'
+            ruby: 2.6
+          - os: 'macos-latest'
+            task: 'safari'
+            ruby: 3.0
+#          - os: 'windows-latest'
+#            task: 'ie'
+        exclude:
+          - os: 'ubuntu-latest'
+            task: 'edge'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ./.github/actions/install-chrome
+        if: |
+          matrix.task == 'chrome' &&
+          matrix.os == 'ubuntu-latest'
+      - uses: ./.github/actions/setup-linux
+        if:  matrix.os == 'ubuntu-latest'
+      - uses: browser-actions/setup-firefox@latest
+        with:
+          firefox-version: '86.0'
+        if: matrix.task == 'firefox'
+      - uses: ./.github/actions/enable-safari
+        if: matrix.task == 'safari'
+      - run: |
+          echo "COVERAGE=true" >> $GITHUB_ENV
+        if: |
+          matrix.os == 'ubuntu-latest' ||
+          matrix.os == 'macos-latest'
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - run: bundle install
+      - run: |
+          bundle exec rake spec:${{ matrix.task }}
+        env:
+          DISPLAY: :99

data/CHANGES.md

@@ -1,3 +1,10 @@
+### 7.0.0.beta1 (2021-03-18)
+
+* Requires Selenium 4
+* Supports Ruby 3
+* Add support for Microsoft Edge Chromium
+* Remove support for all deprecated functionality
+
 ### 6.19.1 (2021-03-17)
 
 * Fix bug preventing using Selenium 4

data/README.md

@@ -3,10 +3,7 @@
 Watir Powered By Selenium!
 
 [![Gem Version](https://badge.fury.io/rb/watir.svg)](http://badge.fury.io/rb/watir)
-[![Unit Tests](https://github.com/watir/watir/workflows/Unit%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Unit+Tests%22)
-[![Mac Tests](https://github.com/watir/watir/workflows/Mac%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Mac+Tests%22)
-[![Windows Tests](https://github.com/watir/watir/workflows/Windows%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Windows+Tests%22)
-[![Linux Tests](https://github.com/watir/watir/workflows/Linux%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Linux+Tests%22)
+[![All Tests](https://github.com/watir/watir/actions/workflows/tests.yml/badge.svg)](https://github.com/watir/watir/actions/workflows/tests.yml)
 [![Code Climate](https://codeclimate.com/github/watir/watir.svg)](https://codeclimate.com/github/watir/watir)
 [![Coverage Status](https://coveralls.io/repos/github/watir/watir/badge.svg?branch=main)](https://coveralls.io/github/watir/watir?branch=main)
 

data/Rakefile

@@ -25,7 +25,7 @@ end
 
 {
   html: 'https://www.w3.org/TR/html52/single-page.html',
-  svg: 'http://www.w3.org/TR/SVG2/single-page.html'
+  svg: 'https://www.w3.org/TR/2018/CR-SVG2-20180807/single-page.html'
 }.each do |type, spec_uri|
   namespace type do
     spec_path = "support/#{type}.html"

data/lib/watir.rb

@@ -2,7 +2,6 @@ require 'selenium-webdriver'
 require 'time'
 
 require 'watir/scroll'
-require 'watir/legacy_wait'
 require 'watir/wait'
 require 'watir/exception'
 require 'watir/window'
@@ -24,51 +23,8 @@ require 'watir/logger'
 require 'watir/version'
 
 module Watir
-  @relaxed_locate = true
-
   class << self
-    attr_writer :relaxed_locate, :always_locate, :default_timeout, :prefer_css
-
-    #
-    # Whether or not Watir should wait for an element to be found or present
-    # before taking an action.
-    # Defaults to true.
-    #
-
-    def relaxed_locate?
-      @relaxed_locate
-    end
-
-    #
-    # Whether or not Watir should re-locate a stale Element on use.
-    #
-
-    def always_locate?
-      always_locate_message
-      true
-    end
-
-    def always_locate_message
-      msg = 'Watir#always_locate'
-      repl_msg = 'Element#stale? or Element#wait_until(&:stale?) if needed for flow control'
-      Watir.logger.deprecate msg, repl_msg, ids: [:always_locate]
-    end
-
-    #
-    # Whether or not Watir should prefer CSS when translating the Watir selector to Selenium.
-    #
-
-    def prefer_css?
-      prefer_css_message
-      false
-    end
-
-    def prefer_css_message
-      msg = 'Watir#prefer_css'
-      repl_msg = 'watir_css gem - https://github.com/watir/watir_css'
-
-      Watir.logger.deprecate msg, repl_msg, ids: [:prefer_css]
-    end
+    attr_writer :default_timeout
 
     #
     # Default wait time for wait methods.

data/lib/watir/alert.rb

@@ -1,6 +1,5 @@
 module Watir
   class Alert
-    include EventuallyPresent
     include Waitable
     include Exception
 
@@ -104,13 +103,9 @@ module Watir
     end
 
     def wait_for_exists
-      return assert_exists unless Watir.relaxed_locate?
-
-      begin
-        wait_until(message: 'waiting for alert', &:exists?)
-      rescue Wait::TimeoutError
-        raise UnknownObjectException, 'unable to locate alert'
-      end
+      wait_until(message: 'waiting for alert', &:exists?)
+    rescue Wait::TimeoutError
+      raise UnknownObjectException, 'unable to locate alert'
     end
   end # Alert
 end # Watir

data/lib/watir/capabilities.rb

@@ -11,14 +11,14 @@ module Watir
       @options = options.dup
       Watir.logger.info "Creating Browser instance of #{browser} with user provided options: #{@options.inspect}"
 
-      deprecate_options_capabilities
-      deprecate_desired_capabilities
-      deprecate_url_service if @options.key?(:service) && @options.key?(:url)
+      if @options.key?(:capabilities) && @options.key?(:options)
+        raise(ArgumentError, ':capabilities and :options are not both allowed')
+      end
+      raise(ArgumentError, ':url and :service are not both allowed') if @options.key?(:service) && @options.key?(:url)
 
-      @browser = deprecate_remote(browser) || browser.nil? && infer_browser || browser.to_sym
+      @browser = browser.nil? && infer_browser || browser
 
-      @selenium_browser = options[:url] ? :remote : @browser
-      @selenium_opts = {}
+      @selenium_browser = @options.key?(:url) ? :remote : @browser
     end
 
     def to_args
@@ -28,270 +28,94 @@ module Watir
     private
 
     def process_arguments
-      @selenium_opts[:listener] = @options.delete(:listener) if @options.key?(:listener)
+      selenium_opts = {}
+      selenium_opts[:listener] = @options.delete(:listener) if @options.key?(:listener)
 
       if @options.key?(:url)
-        @selenium_opts[:url] = @options.delete(:url)
+        selenium_opts[:url] = @options.delete(:url)
       else
-        process_service(@options.delete(:service))
+        service = process_service
+        selenium_opts[:service] = service if service
       end
 
-      process_http_client
-      process_browser_options
-      process_capabilities
-      Watir.logger.info "Creating Browser instance with Watir processed options: #{@selenium_opts.inspect}"
+      selenium_opts[:http_client] = process_http_client
+      selenium_opts[:capabilities] = @options.delete(:capabilities) || process_browser_options
 
-      @selenium_opts
+      Watir.logger.info "Creating Browser instance with Watir processed options: #{selenium_opts.inspect}"
+      selenium_opts
     end
 
     def process_http_client
       http_client = @options.delete(:http_client) || Watir::HttpClient.new
-      if http_client.is_a?(Hash)
-        http_client = Watir::HttpClient.new(http_client)
-      elsif !http_client.is_a?(Selenium::WebDriver::Remote::Http::Common)
-        raise TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance'
-      end
 
-      unless http_client.is_a?(Watir::HttpClient)
+      case http_client
+      when Hash
+        Watir::HttpClient.new(**http_client)
+      when Watir::HttpClient
+        http_client
+      when Selenium::WebDriver::Remote::Http::Common
         Watir.logger.warn 'Check out the new Watir::HttpClient and let us know if there are missing features you need',
                           ids: [:watir_client]
+        http_client
+      else
+        raise TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance'
       end
-
-      process_http_client_timeouts(http_client)
-      @selenium_opts[:http_client] = http_client
     end
 
     def process_browser_options
       browser_options = @options.delete(:options) || {}
-      process_w3c_capabilities(browser_options)
-
-      case @browser
-      when :chrome
-        process_chrome_options(browser_options)
-      when :firefox
-        process_firefox_options(browser_options)
-      when :safari
-        process_safari_options(browser_options)
-      when :ie, :internet_explorer
-        process_ie_options(browser_options)
-      end
-    end
-
-    def process_capabilities
-      caps = @options.delete(:capabilities)
-
-      unless @options.empty?
-        Watir.logger.deprecate('passing unrecognized arguments into Browser constructor',
-                               'appropriate keyword to nest all arguments',
-                               ids: %i[unknown_keyword capabilities],
-                               reference: 'http://watir.com/guides/capabilities.html')
-      end
-
-      if caps
-        @selenium_opts.merge!(@options)
-      else
-        caps = Selenium::WebDriver::Remote::Capabilities.send @browser, @options.merge(@w3c_caps)
-      end
-
-      @selenium_opts[:desired_capabilities] = caps
-    end
-
-    def deprecate_desired_capabilities
-      return unless @options.key?(:desired_capabilities)
-
-      Watir.logger.deprecate(':desired_capabilities to initialize Browser',
-                             ':capabilities or preferably :options',
-                             ids: [:desired_capabilities],
-                             reference: 'http://watir.com/guides/capabilities.html')
-      @options[:capabilities] = @options.delete(:desired_capabilities)
-    end
-
-    def deprecate_url_service
-      Watir.logger.deprecate('allowing Browser initialization with both :url & :service',
-                             'just :service',
-                             ids: [:url_service],
-                             reference: 'http://watir.com/guides/capabilities.html')
-    end
-
-    def process_http_client_timeouts(http_client)
-      deprecate_client_timeout(http_client) if @options.key? :client_timeout
-      deprecate_open_timeout(http_client) if @options.key? :open_timeout
-      deprecate_read_timeout(http_client) if @options.key? :read_timeout
-    end
-
-    def deprecate_client_timeout(http_client)
-      Watir.logger.deprecate(':client_timeout to initialize Browser',
-                             ':open_timeout and/or :read_timeout in a Hash with :http_client key',
-                             ids: [:http_client_timeout],
-                             reference: 'http://watir.com/guides/capabilities.html')
-      timeout = @options.delete(:client_timeout)
-      http_client.open_timeout = timeout
-      http_client.read_timeout = timeout
-    end
-
-    def deprecate_open_timeout(http_client)
-      Watir.logger.deprecate(':open_timeout to initialize Browser',
-                             ':open_timeout in a Hash with :http_client key',
-                             ids: %i[http_open_timeout capabilities],
-                             reference: 'http://watir.com/guides/capabilities.html')
-      http_client.open_timeout = @options.delete(:open_timeout)
-    end
-
-    def deprecate_read_timeout(http_client)
-      Watir.logger.deprecate(':read_timeout to initialize Browser',
-                             ':read_timeout in a Hash with :http_client key',
-                             ids: %i[http_read_timeout capabilities],
-                             reference: 'http://watir.com/guides/capabilities.html')
-      http_client.read_timeout = @options.delete(:read_timeout)
-    end
-
-    def process_chrome_options(browser_options)
-      @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Chrome::Options
-      @selenium_opts[:options] ||= Selenium::WebDriver::Chrome::Options.new(**browser_options)
 
-      process_args
+      options = browser_options if browser_options.is_a? Selenium::WebDriver::Options
+      options ||= Selenium::WebDriver::Options.send(@browser, **browser_options)
 
-      return unless @options.delete(:headless)
+      browser_specific_options(options)
+      raise ArgumentError, "#{@options} are unrecognized arguments for Browser constructor" unless @options.empty?
 
-      @selenium_opts[:options].args << '--headless'
-      @selenium_opts[:options].args << '--disable-gpu'
+      options
     end
 
-    def process_firefox_options(browser_options)
-      @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Firefox::Options
-
-      @selenium_opts[:options] ||= Selenium::WebDriver::Firefox::Options.new(**browser_options)
-      if @options.key?(:profile)
-        new = 'Initializing Browser with both :profile and :option'
-        old = ':profile as a key inside :option'
-        Watir.logger.deprecate new, old, ids: [:firefox_profile]
-
-        @selenium_opts[:options].profile = @options.delete(:profile)
+    def browser_specific_options(options)
+      case @browser
+      when :chrome, :edge, :microsoftedge
+        if @options.delete(:headless)
+          options.args << '--headless'
+          options.args << '--disable-gpu'
+          options.args << '--no-sandbox'
+        end
+      when :firefox
+        options.headless! if @options.delete(:headless)
+      when :safari
+        Selenium::WebDriver::Safari.technology_preview! if @options.delete(:technology_preview)
       end
-
-      @selenium_opts[:options].args << '--headless' if @options.delete(:headless)
-    end
-
-    def process_safari_options(browser_options)
-      @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Safari::Options
-      @selenium_opts[:options] ||= Selenium::WebDriver::Safari::Options.new(**browser_options)
-      Selenium::WebDriver::Safari.technology_preview! if @options.delete(:technology_preview)
     end
 
-    def process_ie_options(browser_options)
-      @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::IE::Options
-      @selenium_opts[:options] ||= Selenium::WebDriver::IE::Options.new(**browser_options)
+    def process_service
+      service = @options.delete(:service)
 
-      process_args
-    end
+      case service
+      when nil
+        nil
+      when Hash
+        return if service.empty?
 
-    def process_service(service)
-      service = deprecate_service_keywords if service.nil?
-
-      @selenium_opts[:service] = case service
-                                 when Hash
-                                   return if service.empty?
-
-                                   Selenium::WebDriver::Service.send(@browser, service)
-                                 when Selenium::WebDriver::Service
-                                   service
-                                 else
-                                   raise TypeError, "#{service} needs to be Selenium Service or Hash instance"
-                                 end
-    end
-
-    def deprecate_service_keywords
-      service = {}
-      if @options.key?(:port)
-        Watir.logger.deprecate(':port to initialize Browser',
-                               ':port in a Hash with :service key',
-                               ids: %i[port_keyword capabilities],
-                               reference: 'http://watir.com/guides/capabilities.html')
-        service[:port] = @options.delete(:port)
-      end
-      if @options.key?(:driver_opts)
-        Watir.logger.deprecate(':driver_opts to initialize Browser',
-                               ':args as Array in a Hash with :service key',
-                               ids: %i[driver_opts_keyword capabilities],
-                               reference: 'http://watir.com/guides/capabilities.html')
-        service[:args] = @options.delete(:driver_opts)
+        Selenium::WebDriver::Service.send(@browser, **service)
+      when Selenium::WebDriver::Service
+        service
+      else
+        raise TypeError, "#{service} needs to be Selenium Service or Hash instance"
       end
-      service
-    end
-
-    def process_args
-      args = if @options.key?(:args)
-               deprecate_args
-               @options.delete(:args)
-             elsif @options.key?(:switches)
-               deprecate_switches
-               @options.delete(:switches)
-             else
-               []
-             end
-      args.each { |arg| @selenium_opts[:options].args << arg }
-    end
-
-    def deprecate_args
-      Watir.logger.deprecate(':args to initialize Browser',
-                             ':args inside Hash with :options key',
-                             ids: %i[args_keyword capabilities],
-                             reference: 'http://watir.com/guides/capabilities.html')
-    end
-
-    def deprecate_switches
-      Watir.logger.deprecate(':switches to initialize Browser',
-                             ':switches inside Hash with :options key',
-                             ids: %i[switches_keyword capabilities],
-                             reference: 'http://watir.com/guides/capabilities.html')
-    end
-
-    def deprecate_remote(browser)
-      return unless browser == :remote
-
-      Watir.logger.deprecate(':remote to initialize Browser',
-                             'browser key along with remote url',
-                             ids: %i[remote_keyword capabilities],
-                             reference: 'http://watir.com/guides/capabilities.html')
-      infer_browser
     end
 
     def infer_browser
       if @options.key?(:browser)
         @options.delete(:browser)
       elsif @options.key?(:capabilities)
-        @options[:capabilities].browser_name.tr(' ', '_').to_sym
+        @options[:capabilities].browser_name.tr(' ', '_').downcase.to_sym
       elsif @options.key?(:options)
         @options[:options].class.to_s.split('::')[-2].downcase.to_sym
       else
         :chrome
       end
     end
-
-    def process_w3c_capabilities(opts)
-      @w3c_caps = {}
-      return unless opts.is_a?(Hash)
-
-      w3c_keys = %i[browser_version platform_name accept_insecure_certs page_load_strategy proxy set_window_rect
-                    timeouts unhandled_prompt_behavior strict_file_interactibility]
-
-      opts.each do |key, _val|
-        next unless key.to_s.include?(':') || w3c_keys.include?(key)
-
-        @w3c_caps[key] = opts.delete(key)
-      end
-    end
-
-    def deprecate_options_capabilities
-      return unless @options.key?(:capabilities) && @options.key?(:options)
-
-      old = 'initializing Browser with both options and capabilities'
-      new = 'Hash with :options, Selenium Options instance with :options or' \
-'Selenium Capabilities instance with :capabilities'
-      Watir.logger.deprecate(old,
-                             new,
-                             ids: %i[options_capabilities capabilities],
-                             reference: 'http://watir.com/guides/capabilities.html')
-    end
   end
 end