watir 6.18.0 → 7.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29eeb6548d5f5f91ee744107d1e3c79f0d2baf8b688c9588752e25b75fa696ef
-  data.tar.gz: 27502c2b89585471b25751b5564c08784578585d3c196f132f56b52243645735
+  metadata.gz: ebf40b52023085fd593f26f448268e0f00c51dbaf80fc3af9801d9d8c9d7703b
+  data.tar.gz: f42ee61445dc9ab61a6d236597bd67c84a2fdd837a5af0cc2236ae1eb6e19467
 SHA512:
-  metadata.gz: d2a90695c68c0db0493d1fdeac5ab90ab51604a0916b4b6cbf0abeae595c6680f62269da98b9920c7ee7db4448e70c6afe31caa280ae76234bae2fc0b51c2912
-  data.tar.gz: 645305ed2b0ae8b5777995c6620055e37850dcefdb3b5a5b609d98b4ce30f8d0cd14155a79fb2032a46862d8c10ad92e9c0112fc7fe68e31dac01b6da44cbbd9
+  metadata.gz: 61cd3f3f3cf9f3d3739ed006de8b41ad4cf60336953b518e9c993e0fafb09c7dd0d7903bbf2099d562987b91ff1aa4b351108b78767ea98b65e6eb53de78f451
+  data.tar.gz: '09017e544063c107aa91865759b4f61366476178b9c55f6b64f6bc81958eb6236d44621baff328ab4587d752a3e99be169ce9cf4be11443354d48dc019d6b04a'

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,104 @@
+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'
+            ruby: 2.6
+            task: 'safari'
+          - os: 'macos-latest'
+            ruby: 3.0
+            task: 'safari'
+          - os: 'windows-latest'
+            ruby: 2.6
+            task: 'ie'
+          - os: 'windows-latest'
+            ruby: 3.0
+            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/.rubocop.yml

@@ -19,17 +19,12 @@ Lint/UnifiedInteger:
 
 # Default: 17
 Metrics/AbcSize:
-  Max: 20
+  Max: 22
   Exclude:
-    - 'lib/watir/capabilities.rb'
     - 'lib/watir/locators/element/selector_builder.rb'
-    - 'lib/watir/locators/element/selector_builder/regexp_disassembler.rb'
-    - 'lib/watir/locators/element/selector_builder/xpath.rb'
-    - 'lib/watir/locators/element/locator.rb'
+    - 'lib/watir/locators/element/selector_builder/*.rb'
     - 'lib/watir/generator/base/generator.rb'
-    - 'lib/watir/generator/base/visitor.rb'
     - 'spec/locator_spec_helper.rb'
-    - 'spec/watirspec_helper.rb'
 
 Metrics/BlockLength:
   Exclude:

data/CHANGES.md

@@ -1,3 +1,54 @@
+### 7.0.0.beta3 (2021-05-05)
+
+* Fix Bug preventing proper use of vendor extension capabilities
+* Changed how timeouts are supported in Watir Capabilities (#932)
+* Changed the default Alert Behavior not to automatically get dismissed when an exception happens (#931)
+
+### 7.0.0.beta2 (2021-03-28)
+
+* Replace Watir Logger implementation with Selenium Logger subclass
+* Change Watir Guards to use Selenium's new Guards. Tests run as pending when guarded.
+* Implement `#set` as standard interface for each Input Element (#405)
+* Implement `Element#set` to take correct `#set` behavior based on evaluated element (#664)
+* Optimize Performance for Select Lists (#846)
+* Allow user to set values on Select List exclusively by `:label`, `:text`, or `:value` (#846)
+* Allow user to check if option selected in Select List by `:label`, `:text`, or `:value` (#929)
+* Implement `Window#restore!` to return to original Window and close all others (#923)
+* Minor performance improvement for iterating over windows (#923)
+* Implement `Browser#closed?`; same as `Browser#exists?` without the Windows checks (#923)
+* Update methods that use Selenium's Actions class to scroll element into view before acting (#847)
+* Fix bug for `:text` locator with `Regexp` value based on whitespace (#924)
+* Remove executing after hooks when changing frames (#888)
+
+### 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
+* Fix bug preventing non-xml characters in attributes (#787)
+
+### 6.19.0 (2021-03-12)
+
+* Create custom Watir HTTP Client
+* Require minimum of Selenium 3.142.7
+* Add support for starting browser with :http_client and :service hashes
+* Allow inferring desired browser from Capabilities or Options if browser not specified
+* Deprecate WindowCollection#to_a method
+* Deprecate starting browser with both Capabilities and Options
+* Deprecate starting browser with both URL and Service
+* Deprecate using :desired_capabilities
+* Deprecate starting browser service keywords in top level Hash
+* Deprecate using :remote to start a browser; browser name must be specified
+* Deprecate sending unknown keywords into the top level
+* Fix bug preventing Safari Options from being recognized
+* Fix bug preventing options provided without :remote keyword from being properly recognized (#812, #870)
+* Fix bug preventing :headless from being recognized when :options specified (#692)
+
 ### 6.18.0 (2021-02-26)
 
 * Implement `WindowCollection` to manage multiple `Window` objects

data/README.md

@@ -3,12 +3,9 @@
 Watir Powered By Selenium!
 
 [![Gem Version](https://badge.fury.io/rb/watir.svg)](http://badge.fury.io/rb/watir)
-[![Unit Tests](https://github.com/titusfortner/watir/workflows/Unit%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Unit+Tests%22)
-[![Mac Tests](https://github.com/titusfortner/watir/workflows/Mac%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Mac+Tests%22)
-[![Windows Tests](https://github.com/titusfortner/watir/workflows/Windows%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Windows+Tests%22)
-[![Linux Tests](https://github.com/titusfortner/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=master)
+[![Coverage Status](https://coveralls.io/repos/github/watir/watir/badge.svg?branch=main)](https://coveralls.io/github/watir/watir?branch=main)
 
 ## Using Watir
 

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'
@@ -14,59 +13,18 @@ require 'watir/alert'
 require 'watir/js_snippets'
 require 'watir/container'
 require 'watir/cookies'
+require 'watir/http_client'
 require 'watir/capabilities'
 require 'watir/navigation'
 require 'watir/browser'
 require 'watir/screenshot'
 require 'watir/after_hooks'
 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/browser.rb

@@ -55,16 +55,21 @@ module Watir
       @default_context = true
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # TODO: w3c default behavior does not like checking if alert exists
     def inspect
       if alert.exists?
         format('#<%s:0x%x alert=true>', self.class, hash * 2)
       else
         format('#<%s:0x%x url=%s title=%s>', self.class, hash * 2, url.inspect, title.inspect)
       end
+    rescue Selenium::WebDriver::Error::NoSuchWindowError
+      format('#<%s:0x%x closed=%s>', self.class, hash * 2, closed?)
     rescue Errno::ECONNREFUSED
       format('#<%s:0x%x closed=true>', self.class, hash * 2)
     end
     alias selector_string inspect
+    # rubocop:enable Metrics/AbcSize
 
     #
     # Returns URL of current page.
@@ -101,13 +106,23 @@ module Watir
     #
 
     def close
-      return if @closed
+      return if closed?
 
       @driver.quit
       @closed = true
     end
     alias quit close
 
+    #
+    # Returns true if browser is closed and false otherwise.
+    #
+    # @return [Boolean]
+    #
+
+    def closed?
+      @closed
+    end
+
     #
     # Handles cookies.
     #
@@ -252,12 +267,12 @@ module Watir
     #
 
     def exist?
-      !@closed && window.present?
+      !closed? && window.present?
     end
     alias exists? exist?
 
     def locate
-      raise Error, 'browser was closed' if @closed
+      raise Error, 'browser was closed' if closed?
 
       ensure_context
     end
@@ -267,7 +282,6 @@ module Watir
 
       driver.switch_to.default_content
       @default_context = true
-      after_hooks.run
     end
 
     def browser

data/lib/watir/capabilities.rb

@@ -2,19 +2,23 @@ module Watir
   class Capabilities
     attr_reader :options
 
-    def initialize(browser, options = {})
+    def initialize(browser = nil, options = {})
+      if browser.is_a?(Hash)
+        options = browser
+        browser = nil
+      end
+
       @options = options.dup
       Watir.logger.info "Creating Browser instance of #{browser} with user provided options: #{@options.inspect}"
-      @browser = if browser == :remote && @options.key?(:browser)
-                   @options.delete(:browser)
-                 elsif browser == :remote && @options.key?(:desired_capabilities)
-                   @options[:desired_capabilities].browser_name.to_sym
-                 else
-                   browser.to_sym
-                 end
-      @selenium_browser = browser == :remote || options[:url] ? :remote : browser
-
-      @selenium_opts = {}
+
+      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 = browser.nil? && infer_browser || browser
+
+      @selenium_browser = @options.key?(:url) ? :remote : @browser
     end
 
     def to_args
@@ -24,129 +28,125 @@ module Watir
     private
 
     def process_arguments
-      url = @options.delete(:url)
-      if url
-        @selenium_opts[:url] = url
-      elsif @options.key?(:service)
-        @selenium_opts[:service] = options.delete(:service)
+      selenium_opts = {}
+      selenium_opts[:listener] = @options.delete(:listener) if @options.key?(:listener)
+
+      if @options.key?(:url)
+        selenium_opts[:url] = @options.delete(:url)
+      else
+        service = process_service
+        selenium_opts[:service] = service if service
       end
 
-      create_http_client
+      selenium_opts[:http_client] = process_http_client
+      selenium_opts[:capabilities] = @options.delete(:capabilities) || process_browser_options
+
+      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
+
+      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',
+                          id: [:watir_client]
+        http_client
+      else
+        raise TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance'
+      end
+    end
+
+    def process_browser_options
+      browser_options = @options.delete(:options).dup || {}
+      vendor_caps = process_vendor_capabilities(browser_options)
 
-      @selenium_opts[:port] = @options.delete(:port) if @options.key?(:port)
-      @selenium_opts[:driver_opts] = @options.delete(:driver_opts) if @options.key?(:driver_opts)
-      @selenium_opts[:listener] = @options.delete(:listener) if @options.key?(:listener)
+      options = if browser_options.is_a? Selenium::WebDriver::Options
+                  browser_options
+                else
+                  convert_timeouts(browser_options)
+                  Selenium::WebDriver::Options.send(@browser, **browser_options)
+                end
 
-      process_browser_options
-      process_capabilities
-      Watir.logger.info "Creating Browser instance with Watir processed options: #{@selenium_opts.inspect}"
+      options.unhandled_prompt_behavior ||= :ignore
+      browser_specific_options(options)
+      raise ArgumentError, "#{@options} are unrecognized arguments for Browser constructor" unless @options.empty?
 
-      @selenium_opts
+      vendor_caps << options
     end
 
-    def create_http_client
-      client_timeout = @options.delete(:client_timeout)
-      open_timeout = @options.delete(:open_timeout)
-      read_timeout = @options.delete(:read_timeout)
+    def process_vendor_capabilities(opts)
+      return [] unless opts.is_a? Hash
 
-      http_client = @options.delete(:http_client)
+      vendor = opts.select { |key, _val| key.to_s.include?(':') && opts.delete(key) }
+      vendor.map { |k, v| Selenium::WebDriver::Remote::Capabilities.new(k => v) }
+    end
 
-      %i[open_timeout read_timeout client_timeout].each do |t|
-        next if http_client.nil? || !respond_to?(t)
+    def convert_timeouts(browser_options)
+      browser_options[:timeouts] ||= {}
+      browser_options[:timeouts].keys.each do |key|
+        raise(ArgumentError, 'do not set implicit wait, Watir handles waiting automatically') if key.to_s == 'implicit'
 
-        msg = "You can pass #{t} value directly into Watir::Browser opt without needing to use :http_client"
-        Watir.logger.warn msg, ids: %i[http_client use_capabilities]
+        Watir.logger.deprecate('using timeouts directly in options',
+                               ":#{key}_timeout",
+                               id: 'timeouts')
+      end
+      if browser_options.key?(:page_load_timeout)
+        browser_options[:timeouts][:page_load] = browser_options.delete(:page_load_timeout) * 1000
       end
 
-      http_client ||= Selenium::WebDriver::Remote::Http::Default.new
+      return unless browser_options.key?(:script_timeout)
 
-      http_client.timeout = client_timeout if client_timeout
-      http_client.open_timeout = open_timeout if open_timeout
-      http_client.read_timeout = read_timeout if read_timeout
-      @selenium_opts[:http_client] = http_client
+      browser_options[:timeouts][:script] = browser_options.delete(:script_timeout) * 1000
     end
 
-    # TODO: - this will get addressed with Capabilities Update
-    # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Metrics/PerceivedComplexity:
-    # rubocop:disable Metrics/CyclomaticComplexity::
-    def process_browser_options
-      browser_options = @options.delete(:options) || {}
-
-      case @selenium_browser
-      when :chrome
-        if @options.key?(:args) || @options.key?(:switches)
-          browser_options ||= {}
-          browser_options[:args] = (@options.delete(:args) || @options.delete(:switches)).dup
-        end
+    def browser_specific_options(options)
+      case @browser
+      when :chrome, :edge, :microsoftedge
         if @options.delete(:headless)
-          browser_options ||= {}
-          browser_options[:args] ||= []
-          browser_options[:args] += ['--headless', '--disable-gpu']
+          options.args << '--headless'
+          options.args << '--disable-gpu'
+          options.args << '--no-sandbox'
         end
-        @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Chrome::Options
-        @selenium_opts[:options] ||= Selenium::WebDriver::Chrome::Options.new(**browser_options)
       when :firefox
-        profile = @options.delete(:profile)
-        if browser_options.is_a? Selenium::WebDriver::Firefox::Options
-          @selenium_opts[:options] = browser_options
-          if profile
-            msg = 'Initializing Browser with both :profile and :option', ':profile as a key inside :option'
-            Watir.logger.deprecate msg, ids: [:firefox_profile]
-          end
-        end
-        if @options.delete(:headless)
-          browser_options ||= {}
-          browser_options[:args] ||= []
-          browser_options[:args] += ['--headless']
-        end
-        @selenium_opts[:options] ||= Selenium::WebDriver::Firefox::Options.new(**browser_options)
-        @selenium_opts[:options].profile = profile if profile
+        options.headless! if @options.delete(:headless)
       when :safari
         Selenium::WebDriver::Safari.technology_preview! if @options.delete(:technology_preview)
-      when :remote
-        if @browser == :chrome && @options.delete(:headless)
-          args = @options.delete(:args) || @options.delete(:switches) || []
-          @options['chromeOptions'] = {'args' => args + ['--headless', '--disable-gpu']}
-        end
-        if @browser == :firefox && @options.delete(:headless)
-          args = @options.delete(:args) || @options.delete(:switches) || []
-          @options[Selenium::WebDriver::Firefox::Options::KEY] = {'args' => args + ['--headless']}
-        end
-        if @browser == :safari && @options.delete(:technology_preview)
-          @options['safari.options'] = {'technologyPreview' => true}
-        end
-      when :ie
-        if @options.key?(:args)
-          browser_options ||= {}
-          browser_options[:args] = @options.delete(:args).dup
-        end
-        unless browser_options.is_a? Selenium::WebDriver::IE::Options
-          ie_caps = browser_options.select { |k| Selenium::WebDriver::IE::Options::CAPABILITIES.include?(k) }
-          browser_options = Selenium::WebDriver::IE::Options.new(**browser_options)
-          ie_caps.each { |k, v| browser_options.add_option(k, v) }
-        end
-        @selenium_opts[:options] = browser_options
       end
     end
 
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/PerceivedComplexity:
-    # rubocop:enable Metrics/CyclomaticComplexity::
+    def process_service
+      service = @options.delete(:service)
 
-    def process_capabilities
-      caps = @options.delete(:desired_capabilities)
+      case service
+      when nil
+        nil
+      when Hash
+        return if service.empty?
 
-      if caps
-        msg = 'You can pass values directly into Watir::Browser opt without needing to use :desired_capabilities'
-        Watir.logger.warn msg,
-                          ids: [:use_capabilities]
-        @selenium_opts.merge!(@options)
+        Selenium::WebDriver::Service.send(@browser, **service)
+      when Selenium::WebDriver::Service
+        service
       else
-        caps = Selenium::WebDriver::Remote::Capabilities.send @browser, @options
+        raise TypeError, "#{service} needs to be Selenium Service or Hash instance"
       end
+    end
 
-      @selenium_opts[:desired_capabilities] = caps
+    def infer_browser
+      if @options.key?(:browser)
+        @options.delete(:browser)
+      elsif @options.key?(:capabilities)
+        @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
   end
 end