watir 7.0.0.beta1 → 7.0.0.beta5

data/lib/watir/has_window.rb

@@ -1,5 +1,7 @@
 module Watir
   module HasWindow
+    attr_writer :original_window
+
     #
     # Returns browser windows array.
     #

data/lib/watir/locators.rb

@@ -14,6 +14,10 @@ require 'watir/locators/button/matcher'
 require 'watir/locators/cell/selector_builder'
 require 'watir/locators/cell/selector_builder/xpath'
 
+require 'watir/locators/option/matcher'
+require 'watir/locators/option/selector_builder'
+require 'watir/locators/option/selector_builder/xpath'
+
 require 'watir/locators/row/selector_builder'
 require 'watir/locators/row/selector_builder/xpath'
 

data/lib/watir/locators/element/matcher.rb

@@ -82,7 +82,7 @@ module Watir
           when :tag_name
             element.tag_name.downcase
           when :text
-            execute_js(:getTextContent, element)
+            execute_js(:getTextContent, element).gsub(/\s+/, ' ').strip
           when :visible
             element.displayed?
           when :visible_text

data/lib/watir/locators/element/selector_builder.rb

@@ -88,9 +88,6 @@ module Watir
 
         def normalize_locator(how, what)
           case how
-          when 'text'
-            Watir.logger.deprecate "String 'text' as a locator", 'Symbol :text', ids: [:text_string]
-            [:text, what]
           when :tag_name
             what = what.to_s if what.is_a?(::Symbol)
             [how, what]

data/lib/watir/locators/element/selector_builder/xpath.rb

@@ -218,7 +218,8 @@ module Watir
 
           def equal_pair(key, value)
             if key == :class
-              negate_xpath = value =~ /^!/ && value.slice!(0)
+              negate_xpath = value =~ /^!/
+              value = value[1..-1] if negate_xpath
               expression = "contains(concat(' ', @class, ' '), #{XpathSupport.escape " #{value} "})"
 
               negate_xpath ? "not(#{expression})" : expression

data/lib/watir/locators/option/matcher.rb

@@ -0,0 +1,24 @@
+module Watir
+  module Locators
+    class Option
+      class Matcher < Element::Matcher
+        def fetch_value(element, how)
+          case how
+          when :any
+            [element.attribute(:value),
+             execute_js(:getTextContent, element).gsub(/\s+/, ' ').strip,
+             element.attribute(:label)]
+          else
+            super
+          end
+        end
+
+        def matches_values?(found, expected)
+          return super unless found.is_a?(Array)
+
+          found.find { |possible| matches_values?(possible, expected) }
+        end
+      end
+    end
+  end
+end

data/lib/watir/locators/option/selector_builder.rb

@@ -0,0 +1,8 @@
+module Watir
+  module Locators
+    class Option
+      class SelectorBuilder < Element::SelectorBuilder
+      end
+    end
+  end
+end

data/lib/watir/locators/option/selector_builder/xpath.rb

@@ -0,0 +1,37 @@
+module Watir
+  module Locators
+    class Option
+      class SelectorBuilder
+        class XPath < Element::SelectorBuilder::XPath
+          private
+
+          def attribute_string
+            result = if @selector.key?(:any)
+                       to_match = @selector.delete :any
+                       value = process_attribute(:value, to_match)
+                       text = process_attribute(:text, to_match)
+                       label = process_attribute(:label, to_match)
+                       "[#{value} or #{text} or #{label}]"
+                     else
+                       ''
+                     end
+
+            attributes = @selector.keys.map { |key|
+              process_attribute(key, @selector.delete(key))
+            }.flatten.compact
+            attribute_values = attributes.empty? ? '' : "[#{attributes.join(' and ')}]"
+            "#{result}#{attribute_values}"
+          end
+
+          def add_to_matching(key, regexp, results = nil)
+            return unless results.nil? || requires_matching?(results, regexp)
+
+            return super unless %i[value text label].include? key
+
+            @built[:any] = regexp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/watir/logger.rb

@@ -16,84 +16,13 @@ module Watir
   #   Watir.logger.info('This is info message')
   #   Watir.logger.warn('This is warning message')
   #
-  class Logger
-    extend Forwardable
-    include ::Logger::Severity
-
-    def_delegators :@logger, :debug, :debug?,
-                   :info, :info?,
-                   :warn?,
-                   :error, :error?,
-                   :fatal, :fatal?,
-                   :level, :level=
-
-    def initialize(progname = 'Watir')
-      @logger = create_logger($stdout)
-      @logger.progname = progname
-      @ignored = []
-    end
-
-    def ignore(ids)
-      @ignored.concat Array(ids).map(&:to_s)
-    end
-
-    def output=(io)
-      @logger.reopen(io)
-    end
-
-    #
-    # Only log a warn message if it is not set to be ignored.
-    #
-    def warn(message, ids: [], &block)
-      msg = ids.empty? ? '' : "[#{ids.map!(&:to_s).map(&:inspect).join(', ')}] "
-      msg += message
-      @logger.warn(msg, &block) unless (@ignored & ids).any?
-    end
-
-    #
-    # Returns IO object used by logger internally.
-    #
-    # Normally, we would have never needed it, but we want to
-    # use it as IO object for all child processes to ensure their
-    # output is redirected there.
-    #
-    # It is only used in debug level, in other cases output is suppressed.
-    #
-    # @api private
-    #
-    def io
-      @logger.instance_variable_get(:@logdev).instance_variable_get(:@dev)
-    end
-
-    #
-    # Marks code as deprecated with replacement.
-    #
-    # @param [String] old
-    # @param [String] new
-    #
-    def deprecate(old, new, reference: '', ids: [])
-      return if @ignored.include?('deprecations') || (@ignored & ids.map!(&:to_s)).any?
-
-      msg = ids.empty? ? '' : "[#{ids.map(&:inspect).join(', ')}] "
-      ref_msg = reference.empty? ? '.' : "; see explanation for this deprecation: #{reference}."
-      warn "[DEPRECATION] #{msg}#{old} is deprecated. Use #{new} instead#{ref_msg}"
+  class Logger < Selenium::WebDriver::Logger
+    def initialize
+      super('Watir')
     end
 
     def selenium=(val)
       Selenium::WebDriver.logger.level = val
     end
-
-    private
-
-    def create_logger(output)
-      logger = ::Logger.new(output)
-      logger.progname = 'Watir'
-      logger.level = ($DEBUG ? DEBUG : WARN)
-      logger.formatter = proc do |severity, time, progname, msg|
-        "#{time.strftime('%F %T')} #{severity} #{progname} #{msg}\n"
-      end
-
-      logger
-    end
   end
 end

data/lib/watir/radio_set.rb

@@ -139,6 +139,7 @@ module Watir
       end
       raise UnknownObjectException, "Unable to locate radio matching #{str_or_rx.inspect}"
     end
+    alias set select
 
     #
     # Returns true if any of the radio button label matches the given value.

data/lib/watir/screenshot.rb

@@ -1,14 +1,8 @@
 module Watir
   class Screenshot
     def initialize(browser)
-      if browser.is_a? Selenium::WebDriver::Driver
-        msg = 'Initializing `Watir::Screenshot` with a `Selenium::Driver` instance', 'a `Watir::Browser` instance'
-        Watir.logger.deprecate msg, ids: [:screenshot_driver]
-        @driver = browser
-      else
-        @browser = browser
-        @driver = browser.wd
-      end
+      @browser = browser
+      @driver = browser.wd
     end
 
     #

data/lib/watir/user_editable.rb

@@ -15,16 +15,23 @@ module Watir
     alias value= set
 
     #
-    # Uses JavaScript to enter most of the given value.
-    # Selenium is used to enter the first and last characters
+    # Returns true if element is user_editable because it has a content_editable attribute set
     #
-    # @param [String, Symbol] args
+    # @return [Boolean]
     #
 
     def content_editable
       defined?(@content_editable) && content_editable?
     end
 
+    #
+    # Uses JavaScript to enter most of the given value.
+    # Selenium is used to enter the first and last characters
+    # This might provide a performance improvement when entering a lot of text on a local machine
+    #
+    # @param [String, Symbol] args
+    #
+
     def set!(*args)
       msg = '#set! does not support special keys, use #set instead'
       raise ArgumentError, msg if args.any? { |v| v.is_a?(::Symbol) }

data/lib/watir/version.rb

@@ -1,3 +1,3 @@
 module Watir
-  VERSION = '7.0.0.beta1'.freeze
+  VERSION = '7.0.0.beta5'.freeze
 end

data/lib/watir/window.rb

@@ -179,10 +179,21 @@ module Watir
     #   end
     #
 
-    def use(&blk)
-      @browser.original_window ||= current_window
+    def use
       wait_for_exists
-      @driver.switch_to.window(handle, &blk)
+      cache_current = current_window
+      @browser.original_window ||= cache_current
+      restore_to = unless cache_current == handle
+                     @driver.switch_to.window(handle)
+                     cache_current
+                   end
+      if block_given?
+        begin
+          yield
+        ensure
+          @driver.switch_to.window(restore_to) if restore_to
+        end
+      end
       self
     end
 
@@ -205,7 +216,7 @@ module Watir
     end
 
     def assert_exists
-      return if @driver.window_handles.include?(handle)
+      return if !handle.nil? && @driver.window_handles.include?(handle)
 
       raise(NoMatchingWindowFoundException, selector_string)
     end

data/lib/watir/window_collection.rb

@@ -39,6 +39,15 @@ module Watir
     end
     alias eql? ==
 
+    def restore!
+      return if @browser.closed?
+
+      window_list.reject { |win| win.handle == @browser.original_window.handle }.each(&:close)
+      @browser.original_window.use
+    rescue StandardError
+      @browser.close
+    end
+
     def reset!
       @window_list = nil
     end

data/lib/watirspec.rb

@@ -53,7 +53,9 @@ module WatirSpec
       @implementation = imp
     end
 
-    def new_browser
+    def new_browser(pause = 1)
+      sleep pause
+
       klass = WatirSpec.implementation.browser_class
       args = Array(WatirSpec.implementation.browser_args).map { |e| e.is_a?(Hash) ? e.dup : e }
 
@@ -80,7 +82,7 @@ module WatirSpec
       info << @implementation.driver_info
 
       Watir.logger.warn "running watirspec against #{info.join ' '} using:\n#{WatirSpec.implementation.inspect_args}",
-                        ids: [:browser_info]
+                        id: [:browser_info]
     rescue StandardError
       # ignored
     end

data/lib/watirspec/guards.rb

@@ -21,7 +21,7 @@ module WatirSpec
             guard_name = "#{guard[:name]}:".ljust(15)
             str << " \t#{guard_name} #{guard[:data].inspect}\n"
           end
-          Watir.logger.warn str, ids: [:guard_names]
+          Watir.logger.warn str, id: [:guard_names]
         end
       end
     end # class << self

data/lib/watirspec/remote_server.rb

@@ -20,14 +20,10 @@ module WatirSpec
     private
 
     def jar
-      if ENV['LOCAL_SELENIUM']
-        local = File.expand_path('../selenium/buck-out/gen/java/server/src/org/openqa/grid/selenium/selenium.jar')
-      end
-
       if File.exist?(ENV['REMOTE_SERVER_BINARY'] || '')
         ENV['REMOTE_SERVER_BINARY']
-      elsif ENV['LOCAL_SELENIUM'] && File.exist?(local)
-        local
+      elsif ENV['LOCAL_SELENIUM']
+        File.expand_path('../selenium/bazel-bin/java/server/src/org/openqa/selenium/grid/selenium_server_deploy.jar')
       elsif !Dir.glob('*selenium*.jar').empty?
         Dir.glob('*selenium*.jar').first
       else

data/lib/watirspec/server.rb

@@ -56,7 +56,7 @@ module WatirSpec
 
         client.write(response(status, headers, body))
       rescue Errno::ECONNRESET
-        Watir.logger.warn 'Client reset connection, skipping.', ids: [:reset_connection]
+        Watir.logger.warn 'Client reset connection, skipping.', id: [:reset_connection]
       ensure
         client.close
       end

data/spec/spec_helper.rb

@@ -20,13 +20,3 @@ end
 require 'watir'
 require 'locator_spec_helper'
 require 'rspec'
-
-if ENV['AUTOMATIC_RETRY']
-  require 'rspec/retry'
-  RSpec.configure do |config|
-    config.verbose_retry = true
-    config.display_try_failure_messages = true
-    config.default_retry_count = 3
-    config.exceptions_to_retry = [IOError, Net::ReadTimeout]
-  end
-end

data/spec/unit/capabilities_spec.rb

@@ -1,4 +1,4 @@
-require 'watirspec_helper'
+require_relative 'unit_helper'
 
 describe Watir::Capabilities do
   before(:all) { Watir.logger.ignore(:watir_client) }
@@ -39,16 +39,17 @@ describe Watir::Capabilities do
   # :listener
   # :service      (Built from Hash)
   # :http_client  (Generated or Built from Hash)
+  # :proxy        (Built from Hash and added to :options)
   # :options      (Generated or Built from Hash)
   # :capabilities (incompatible with options)
 
   supported_browsers.each do |browser_symbol|
-    it 'just browser has client & capabilities not service' do
+    it 'just browser has client & options not service' do
       capabilities = Watir::Capabilities.new(browser_symbol)
 
       args = capabilities.to_args
       expect(args.last[:http_client]).to be_a Watir::HttpClient
-      expect(args.last[:capabilities]).to be_a options_class(browser_symbol)
+      expect(args.last[:capabilities].first).to be_a options_class(browser_symbol)
       expect(args.last).not_to include(:service)
     end
 
@@ -58,7 +59,7 @@ describe Watir::Capabilities do
       args = capabilities.to_args
 
       expect(args.last[:http_client]).to be_a Watir::HttpClient
-      expect(args.last[:capabilities]).to be_a options_class(browser_symbol)
+      expect(args.last[:capabilities].first).to be_a options_class(browser_symbol)
       expect(args.last).not_to include(:service)
     end
 
@@ -74,7 +75,7 @@ describe Watir::Capabilities do
       expect(args.last).not_to include(:service)
     end
 
-    context 'service' do
+    describe 'service' do
       it 'uses provided service' do
         halt_service(browser_symbol)
 
@@ -106,7 +107,7 @@ describe Watir::Capabilities do
       end
     end
 
-    context 'http_client' do
+    describe 'http_client' do
       it 'uses default HTTP Client' do
         capabilities = Watir::Capabilities.new(browser_symbol)
         args = capabilities.to_args
@@ -152,6 +153,114 @@ describe Watir::Capabilities do
         Watir::Capabilities.new(browser_symbol, capabilities: caps, options: opts)
       }.to raise_exception(ArgumentError, ':capabilities and :options are not both allowed')
     end
+
+    describe 'timeout options' do
+      it 'accepts page load and script timeouts in seconds' do
+        options = {page_load_timeout: 11,
+                   script_timeout: 12}
+        capabilities = Watir::Capabilities.new(browser_symbol, options: options)
+        args = capabilities.to_args
+        actual_options = args.last[:capabilities].first
+        expect(actual_options.timeouts[:page_load]).to eq 11_000
+        expect(actual_options.timeouts[:script]).to eq 12_000
+      end
+
+      it 'has deprecated timeouts key with page load warning' do
+        options = {timeouts: {page_load: 11}}
+        capabilities = Watir::Capabilities.new(browser_symbol, options: options)
+        msg = 'timeouts has been deprecated, use page_load_timeout (in seconds) directly instead'
+        expect {
+          capabilities.to_args
+        }.to have_deprecated_timeouts(msg)
+      end
+
+      it 'has deprecated timeouts key with script warning' do
+        options = {timeouts: {script: 11}}
+        expect {
+          capabilities = Watir::Capabilities.new(browser_symbol, options: options)
+          capabilities.to_args
+        }.to have_deprecated_timeouts('timeouts has been deprecated, use script_timeout (in seconds) directly instead')
+      end
+
+      it 'does not allow implicit wait timeout in timeouts hash' do
+        options = {timeouts: {implicit: 1}}
+        capabilities = Watir::Capabilities.new(browser_symbol, options: options)
+        expect {
+          capabilities.to_args
+        }.to raise_exception(ArgumentError, 'do not set implicit wait, Watir handles waiting automatically')
+      end
+    end
+
+    it 'unhandled prompt behavior defaults to ignore' do
+      capabilities = Watir::Capabilities.new(browser_symbol)
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities].first
+      expect(actual_options.unhandled_prompt_behavior).to eq :ignore
+    end
+
+    it 'unhandled prompt behavior can be overridden' do
+      capabilities = Watir::Capabilities.new(browser_symbol, options: {unhandled_prompt_behavior: :accept_and_notify})
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities].first
+      expect(actual_options.unhandled_prompt_behavior).to eq :accept_and_notify
+    end
+
+    describe 'proxy' do
+      it 'adds Selenium Proxy to empty Options' do
+        proxy = Selenium::WebDriver::Proxy.new(http: '127.0.0.1:8080', ssl: '127.0.0.1:443')
+        capabilities = Watir::Capabilities.new(browser_symbol, proxy: proxy)
+        args = capabilities.to_args
+        proxy = args.last[:capabilities].first.proxy
+
+        expect(proxy).to be_a Selenium::WebDriver::Proxy
+        expect(proxy.type).to eq(:manual)
+        expect(proxy.http).to eq('127.0.0.1:8080')
+        expect(proxy.ssl).to eq('127.0.0.1:443')
+      end
+
+      it 'builds a Proxy from Hash for Options' do
+        proxy = {http: '127.0.0.1:8080', ssl: '127.0.0.1:443'}
+        capabilities = Watir::Capabilities.new(browser_symbol, proxy: proxy)
+        args = capabilities.to_args
+        proxy = args.last[:capabilities].first.proxy
+
+        expect(proxy).to be_a Selenium::WebDriver::Proxy
+        expect(proxy.type).to eq(:manual)
+        expect(proxy.http).to eq('127.0.0.1:8080')
+        expect(proxy.ssl).to eq('127.0.0.1:443')
+      end
+
+      it 'builds a Proxy from Hash and adds to Options' do
+        proxy = {http: '127.0.0.1:8080', ssl: '127.0.0.1:443'}
+        options = {unhandled_prompt_behavior: :accept,
+                   page_load_strategy: :eager}
+
+        capabilities = Watir::Capabilities.new(browser_symbol, options: options, proxy: proxy)
+        args = capabilities.to_args
+        actual_options = args.last[:capabilities].first
+
+        expect(actual_options.proxy).to be_a Selenium::WebDriver::Proxy
+        expect(actual_options.proxy.type).to eq(:manual)
+        expect(actual_options.proxy.http).to eq('127.0.0.1:8080')
+        expect(actual_options.proxy.ssl).to eq('127.0.0.1:443')
+        expect(actual_options.unhandled_prompt_behavior).to eq :accept
+        expect(actual_options.page_load_strategy).to eq :eager
+      end
+    end
+
+    it 'errors on bad proxy key' do
+      proxy = {bad_key: 'foo'}
+      capabilities = Watir::Capabilities.new(browser_symbol, proxy: proxy)
+
+      expect { capabilities.to_args }.to raise_error(ArgumentError, /unknown option/)
+    end
+
+    it 'errors on bad proxy object' do
+      capabilities = Watir::Capabilities.new(browser_symbol, proxy: 7)
+      expect {
+        capabilities.to_args
+      }.to raise_exception(TypeError, '7 needs to be Selenium Proxy or Hash instance')
+    end
   end
 
   # Options:
@@ -159,6 +268,7 @@ describe Watir::Capabilities do
   # :service      (Errors)
   # :listener
   # :http_client  (Generated or Built from Hash)
+  # :proxy        (Built from Hash and added to :options)
   # :options      (Generated or Built from Hash)
   # :capabilities (incompatible with options)
 
@@ -167,11 +277,11 @@ describe Watir::Capabilities do
       capabilities = Watir::Capabilities.new(url: 'http://example.com')
       args = capabilities.to_args
       expect(args.first).to eq :remote
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.browser_name).to eq 'chrome'
     end
 
-    it 'browser name with url has capabilities and client but not service' do
+    it 'just url & browser name has capabilities and client but not service' do
       capabilities = Watir::Capabilities.new(:firefox,
                                              url: 'https://example.com/wd/hub/')
       args = capabilities.to_args
@@ -179,7 +289,7 @@ describe Watir::Capabilities do
       expect(args.last[:url]).to eq 'https://example.com/wd/hub/'
       expect(args.last[:http_client]).to be_a Watir::HttpClient
 
-      expect(args.last[:capabilities]).to be_a Selenium::WebDriver::Firefox::Options
+      expect(args.last[:capabilities].first).to be_a Selenium::WebDriver::Firefox::Options
       expect(args.last).not_to include(:service)
     end
 
@@ -192,7 +302,7 @@ describe Watir::Capabilities do
       expect(args.last[:listener]).to eq listener
     end
 
-    it 'browser name with url and http client object' do
+    it 'accepts http client object' do
       client = Watir::HttpClient.new
       capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'https://example.com/wd/hub',
@@ -200,33 +310,61 @@ describe Watir::Capabilities do
       args = capabilities.to_args
       expect(args.first).to eq :remote
       expect(args.last[:http_client]).to eq client
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.browser_name).to eq 'chrome'
     end
 
-    it 'browser name with url and http client Hash' do
+    it 'accepts http client Hash' do
       capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'https://example.com/wd/hub',
                                              http_client: {read_timeout: 30})
       args = capabilities.to_args
       expect(args.first).to eq :remote
       expect(args.last[:http_client].instance_variable_get('@read_timeout')).to eq 30
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.browser_name).to eq 'chrome'
     end
 
-    it 'browser name with url and options object' do
+    it 'accepts proxy object' do
+      proxy = Selenium::WebDriver::Proxy.new(http: '127.0.0.1:8080', ssl: '127.0.0.1:443')
+      capabilities = Watir::Capabilities.new(:chrome,
+                                             url: 'https://example.com/wd/hub',
+                                             proxy: proxy)
+      args = capabilities.to_args
+      expect(args.first).to eq :remote
+      proxy = args.last[:capabilities].first.proxy
+      expect(proxy).to be_a Selenium::WebDriver::Proxy
+      expect(proxy.type).to eq(:manual)
+      expect(proxy.http).to eq('127.0.0.1:8080')
+      expect(proxy.ssl).to eq('127.0.0.1:443')
+    end
+
+    it 'accepts proxy Hash' do
+      proxy = {http: '127.0.0.1:8080', ssl: '127.0.0.1:443'}
+      capabilities = Watir::Capabilities.new(:chrome,
+                                             url: 'https://example.com/wd/hub',
+                                             proxy: proxy)
+      args = capabilities.to_args
+      expect(args.first).to eq :remote
+      proxy = args.last[:capabilities].first.proxy
+      expect(proxy).to be_a Selenium::WebDriver::Proxy
+      expect(proxy.type).to eq(:manual)
+      expect(proxy.http).to eq('127.0.0.1:8080')
+      expect(proxy.ssl).to eq('127.0.0.1:443')
+    end
+
+    it 'accepts options object' do
       capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'https://example.com/wd/hub',
                                              options: Selenium::WebDriver::Chrome::Options.new(args: ['--foo']))
       args = capabilities.to_args
       expect(args.first).to eq :remote
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.browser_name).to eq 'chrome'
       expect(actual_options.args).to include('--foo')
     end
 
-    it 'browser name with url and options hash' do
+    it 'accepts options hash' do
       options = {prefs: {foo: 'bar'}}
       capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'http://example.com',
@@ -234,12 +372,12 @@ describe Watir::Capabilities do
       args = capabilities.to_args
       expect(args.first).to eq :remote
       expect(args.last[:url]).to eq 'http://example.com'
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options).to be_a(Selenium::WebDriver::Chrome::Options)
       expect(actual_options.prefs).to eq(foo: 'bar')
     end
 
-    it 'browser name with url and capabilities' do
+    it 'accepts capabilities object' do
       caps = Watir::Capabilities.new(:chrome,
                                      url: 'https://example.com/wd/hub',
                                      capabilities: Selenium::WebDriver::Remote::Capabilities.chrome)
@@ -250,7 +388,7 @@ describe Watir::Capabilities do
       expect(actual_capabilities.browser_name).to eq 'chrome'
     end
 
-    it 'browser name with http client & capabilities' do
+    it 'accepts http client & capabilities objects' do
       client = Watir::HttpClient.new
       caps = Watir::Capabilities.new(:chrome,
                                      url: 'https://example.com/wd/hub',
@@ -265,23 +403,30 @@ describe Watir::Capabilities do
       expect(actual_capabilities.browser_name).to eq 'chrome'
     end
 
-    it 'browser name with http client & options object' do
+    it 'accepts http client & proxy & options objects' do
       client = Watir::HttpClient.new
+      proxy = {http: '127.0.0.1:8080', ssl: '127.0.0.1:443'}
       options = Selenium::WebDriver::Chrome::Options.new(prefs: {foo: 'bar'})
       caps = Watir::Capabilities.new(:chrome,
                                      url: 'https://example.com/wd/hub',
+                                     proxy: proxy,
                                      options: options,
                                      http_client: client)
 
       args = caps.to_args
       expect(args.first).to eq :remote
       expect(args.last[:http_client]).to eq client
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options).to be_a(Selenium::WebDriver::Chrome::Options)
       expect(actual_options.prefs).to eq(foo: 'bar')
+      proxy = args.last[:capabilities].first.proxy
+      expect(proxy).to be_a Selenium::WebDriver::Proxy
+      expect(proxy.type).to eq(:manual)
+      expect(proxy.http).to eq('127.0.0.1:8080')
+      expect(proxy.ssl).to eq('127.0.0.1:443')
     end
 
-    it 'browser name with options & capabilities' do
+    it 'raises exception when both options & capabilities defined' do
       options = {prefs: {foo: 'bar'}}
 
       expect {
@@ -297,7 +442,7 @@ describe Watir::Capabilities do
                                              headless: true,
                                              url: 'http://example.com')
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '--headless', '--disable-gpu'
     end
 
@@ -307,17 +452,22 @@ describe Watir::Capabilities do
                                              url: 'http://example.com')
       args = capabilities.to_args
 
-      expect(args.last[:capabilities].args).to include '-headless'
+      expect(args.last[:capabilities].first.args).to include '-headless'
     end
 
-    it 'allows sending to Browser Service Provider via options' do
+    it 'supports multiple vendor capabilities' do
+      sauce_options = {'sauce:options': {username: ENV['SAUCE_USERNAME'],
+                                         access_key: ENV['SAUCE_ACCESS_KEY']}}
+      other_options = {'other:options': {foo: 'bar'}}
+
       capabilities = Watir::Capabilities.new(:chrome,
-                                             options: {'sauce:options': {username: ENV['SAUCE_USERNAME'],
-                                                                         access_key: ENV['SAUCE_ACCESS_KEY']}},
+                                             options: sauce_options.merge(other_options),
                                              url: 'https://ondemand.us-west-1.saucelabs.com')
-      args = capabilities.to_args
-      actual_options = args.last[:capabilities].instance_variable_get('@options')
-      expect(actual_options[:'sauce:options']).to include :username, :access_key
+
+      se_caps = capabilities.to_args.last[:capabilities]
+      expect(se_caps).to include(Selenium::WebDriver::Chrome::Options.new(unhandled_prompt_behavior: :ignore))
+      expect(se_caps).to include(Selenium::WebDriver::Remote::Capabilities.new(sauce_options))
+      expect(se_caps).to include(Selenium::WebDriver::Remote::Capabilities.new(other_options))
     end
   end
 
@@ -326,14 +476,14 @@ describe Watir::Capabilities do
       capabilities = Watir::Capabilities.new
       args = capabilities.to_args
       expect(args.last[:http_client]).to be_a Watir::HttpClient
-      expect(args.last[:capabilities]).to be_a Selenium::WebDriver::Chrome::Options
+      expect(args.last[:capabilities].first).to be_a Selenium::WebDriver::Chrome::Options
       expect(args.last).not_to include(:service)
     end
 
     it 'sets headless by creating options' do
       capabilities = Watir::Capabilities.new(:chrome, headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '--headless', '--disable-gpu'
     end
 
@@ -342,7 +492,7 @@ describe Watir::Capabilities do
                                              options: Selenium::WebDriver::Chrome::Options.new,
                                              headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '--headless', '--disable-gpu'
     end
 
@@ -352,7 +502,7 @@ describe Watir::Capabilities do
                                              options: options,
                                              headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '--headless', '--disable-gpu', '--foo'
     end
 
@@ -360,7 +510,7 @@ describe Watir::Capabilities do
       options = {args: %w[--foo --bar]}
       capabilities = Watir::Capabilities.new(:chrome, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options).to be_a Selenium::WebDriver::Chrome::Options
       expect(actual_options.args).to include '--foo', '--bar'
     end
@@ -371,7 +521,7 @@ describe Watir::Capabilities do
       capabilities = Watir::Capabilities.new(:chrome,
                                              options: opts)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.page_load_strategy).to eq 'eager'
       expect(actual_options.args).to include '--foo', '--bar'
     end
@@ -384,7 +534,7 @@ describe Watir::Capabilities do
 
       capabilities = Watir::Capabilities.new(:firefox, options: options)
 
-      actual_options = capabilities.to_args.last[:capabilities]
+      actual_options = capabilities.to_args.last[:capabilities].first
       expect(actual_options.args).to include '--foo'
       expect(actual_options.profile).to eq profile
     end
@@ -395,7 +545,7 @@ describe Watir::Capabilities do
 
       capabilities = Watir::Capabilities.new(:firefox, options: options)
 
-      actual_options = capabilities.to_args.last[:capabilities]
+      actual_options = capabilities.to_args.last[:capabilities].first
       expect(actual_options.args).to include '--foo'
       expect(actual_options.profile).to eq profile
     end
@@ -403,7 +553,7 @@ describe Watir::Capabilities do
     it 'sets headless by creating options' do
       capabilities = Watir::Capabilities.new(:firefox, headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '-headless'
     end
 
@@ -412,7 +562,7 @@ describe Watir::Capabilities do
                                              options: Selenium::WebDriver::Firefox::Options.new,
                                              headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '-headless'
     end
 
@@ -422,7 +572,7 @@ describe Watir::Capabilities do
                                              options: options,
                                              headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '-headless', '-foo'
     end
 
@@ -430,7 +580,7 @@ describe Watir::Capabilities do
       options = {args: %w[--foo --bar]}
       capabilities = Watir::Capabilities.new(:firefox, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options).to be_a Selenium::WebDriver::Firefox::Options
       expect(actual_options.args).to include '--foo', '--bar'
     end
@@ -441,7 +591,7 @@ describe Watir::Capabilities do
       capabilities = Watir::Capabilities.new(:firefox,
                                              options: opts)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '--foo', '--bar'
       expect(actual_options.page_load_strategy).to eq 'eager'
     end
@@ -460,7 +610,7 @@ describe Watir::Capabilities do
       options = {automatic_inspection: true}
       capabilities = Watir::Capabilities.new(:safari, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options).to be_a Selenium::WebDriver::Safari::Options
       expect(actual_options.automatic_inspection).to eq true
     end
@@ -471,7 +621,7 @@ describe Watir::Capabilities do
       capabilities = Watir::Capabilities.new(:safari,
                                              options: opts)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.automatic_inspection).to eq true
       expect(actual_options.page_load_strategy).to eq 'eager'
     end
@@ -482,7 +632,7 @@ describe Watir::Capabilities do
       options = {args: %w[--foo --bar]}
       capabilities = Watir::Capabilities.new(:ie, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options).to be_a Selenium::WebDriver::IE::Options
       expect(actual_options.args).to include '--foo', '--bar'
     end
@@ -491,7 +641,7 @@ describe Watir::Capabilities do
       options = {browser_attach_timeout: true}
       capabilities = Watir::Capabilities.new(:ie, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options).to be_a Selenium::WebDriver::IE::Options
       expect(actual_options.options[:browser_attach_timeout]).to eq true
     end
@@ -502,7 +652,7 @@ describe Watir::Capabilities do
       capabilities = Watir::Capabilities.new(:ie,
                                              options: opts)
       args = capabilities.to_args
-      actual_options = args.last[:capabilities]
+      actual_options = args.last[:capabilities].first
       expect(actual_options.args).to include '--foo'
       expect(actual_options.page_load_strategy).to eq 'eager'
     end