watir 6.19.1 → 7.0.0.beta1

data/lib/watir/version.rb

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

data/lib/watir/wait.rb

@@ -32,12 +32,7 @@ module Watir
       # @raise [TimeoutError] if timeout is exceeded
       #
 
-      def until(depr_timeout = nil, depr_message = nil, timeout: nil, message: nil, interval: nil, object: nil)
-        if depr_message || depr_timeout
-          Watir.logger.deprecate 'Using arguments for Wait#until', 'keywords', ids: %i[until timeout_arguments]
-          timeout = depr_timeout
-          message = depr_message
-        end
+      def until(timeout: nil, message: nil, interval: nil, object: nil)
         timeout ||= Watir.default_timeout
         run_with_timer(timeout, interval) do
           result = yield(object)
@@ -58,12 +53,7 @@ module Watir
       # @raise [TimeoutError] if timeout is exceeded
       #
 
-      def while(depr_timeout = nil, depr_message = nil, timeout: nil, message: nil, interval: nil, object: nil)
-        if depr_message || depr_timeout
-          Watir.logger.deprecate 'Using arguments for Wait#while', 'keywords', ids: %i[while timeout_arguments]
-          timeout = depr_timeout
-          message = depr_message
-        end
+      def while(timeout: nil, message: nil, interval: nil, object: nil)
         timeout ||= Watir.default_timeout
         run_with_timer(timeout, interval) { return unless yield(object) }
         raise TimeoutError, message_for(timeout, object, message)
@@ -111,12 +101,7 @@ module Watir
     # @param [String] message error message for when times out
     #
 
-    def wait_until(depr_timeout = nil, depr_message = nil, timeout: nil, message: nil, interval: nil, **opt, &blk)
-      if depr_message || depr_timeout
-        Watir.logger.deprecate 'Using arguments for #wait_until', 'keywords', ids: [:timeout_arguments]
-        timeout = depr_timeout
-        message = depr_message
-      end
+    def wait_until(timeout: nil, message: nil, interval: nil, **opt, &blk)
       message ||= proc { |obj| "waiting for true condition on #{obj.inspect}" }
 
       # TODO: Consider throwing argument error for mixing block & options
@@ -142,12 +127,7 @@ module Watir
     # @param [String] message error message for when times out
     #
 
-    def wait_while(depr_timeout = nil, depr_message = nil, timeout: nil, message: nil, interval: nil, **opt, &blk)
-      if depr_message || depr_timeout
-        Watir.logger.deprecate 'Using arguments for #wait_while', 'keywords', ids: [:timeout_arguments]
-        timeout = depr_timeout
-        message = depr_message
-      end
+    def wait_while(timeout: nil, message: nil, interval: nil, **opt, &blk)
       message ||= proc { |obj| "waiting for false condition on #{obj.inspect}" }
 
       # TODO: Consider throwing argument error for mixing block & options
@@ -158,56 +138,6 @@ module Watir
       self
     end
 
-    #
-    # Waits until the element is present.
-    # Element is always relocated, so this can be used in the case of an element going away and returning
-    #
-    # @example
-    #   browser.text_field(name: "new_user_first_name").wait_until_present
-    #
-    # @param [Integer] timeout seconds to wait before timing out
-    # @param [Float] interval seconds to wait before each try
-    # @param [String] message error message for when times out
-    #
-    # @see Watir::Wait
-    # @see Watir::Element#present?
-    #
-
-    def wait_until_present(depr_timeout = nil, timeout: nil, interval: nil, message: nil)
-      timeout = depr_timeout if depr_timeout
-      Watir.logger.deprecate "#{self.class}#wait_until_present",
-                             "#{self.class}#wait_until(&:present?)",
-                             ids: [:wait_until_present]
-
-      message ||= proc { |obj| "waiting for #{obj.inspect} to become present" }
-      wait_until(timeout: timeout, interval: interval, message: message, element_reset: true, &:present?)
-    end
-
-    #
-    # Waits while the element is present.
-    # Element is always relocated, so this can be used in the case of the element changing attributes
-    #
-    # @example
-    #   browser.text_field(name: "abrakadbra").wait_while_present
-    #
-    # @param [Integer] timeout seconds to wait before timing out
-    # @param [Float] interval seconds to wait before each try
-    # @param [String] message error message for when times out
-    #
-    # @see Watir::Wait
-    # @see Watir::Element#present?
-    #
-
-    def wait_while_present(depr_timeout = nil, timeout: nil, interval: nil, message: nil)
-      timeout = depr_timeout if depr_timeout
-      Watir.logger.deprecate "#{self.class}#wait_while_present",
-                             "#{self.class}#wait_while(&:present?)",
-                             ids: [:wait_while_present]
-
-      message ||= proc { |obj| "waiting for #{obj.inspect} not to be present" }
-      wait_while(timeout: timeout, interval: interval, message: message, element_reset: true, &:present?)
-    end
-
     private
 
     def create_proc(opt)

data/lib/watir/window.rb

@@ -1,6 +1,5 @@
 module Watir
   class Window
-    include EventuallyPresent
     include Waitable
     include Exception
 
@@ -16,7 +15,7 @@ module Watir
       elsif selector.key? :handle
         @handle = selector.delete :handle
       else
-        return if selector.keys.all? { |k| %i[title url index element].include? k }
+        return if selector.keys.all? { |k| %i[title url element].include? k }
 
         raise ArgumentError, "invalid window selector: #{selector_string}"
       end
@@ -113,7 +112,7 @@ module Watir
     # Returns true if two windows are equal.
     #
     # @example
-    #   browser.window(index: 0) == browser.window(index: 1)
+    #   browser.window(title: /window_switching/) == browser.window(/closeable/)
     #   #=> false
     #
     # @param [Window] other
@@ -190,8 +189,6 @@ module Watir
     #
     # @api private
     #
-    # Referenced in EventuallyPresent
-    #
 
     def selector_string
       @selector.inspect
@@ -204,16 +201,7 @@ module Watir
     private
 
     def locate
-      if @selector.empty?
-        nil
-      elsif @selector.key?(:index)
-        Watir.logger.deprecate 'Using :index as a selector for Window', ':title or :url or :element',
-                               reference: 'http://watir.com/guides/windows/#locating-by-index-is-no-longer-supported',
-                               ids: [:window_index]
-        @driver.window_handles[Integer(@selector[:index])]
-      else
-        @driver.window_handles.find { |wh| matches?(wh) }
-      end
+      @selector.empty? ? nil : @driver.window_handles.find { |wh| matches?(wh) }
     end
 
     def assert_exists
@@ -243,13 +231,9 @@ module Watir
     end
 
     def wait_for_exists
-      return assert_exists unless Watir.relaxed_locate?
-
-      begin
-        wait_until(&:exists?)
-      rescue Wait::TimeoutError
-        raise NoMatchingWindowFoundException, selector_string
-      end
+      wait_until(&:exists?)
+    rescue Wait::TimeoutError
+      raise NoMatchingWindowFoundException, selector_string
     end
   end # Window
 end # Watir

data/lib/watir/window_collection.rb

@@ -27,47 +27,12 @@ module Watir
     alias size count
     alias empty? none?
 
-    #
-    # First window of the collection
-    #
-    # @note windows in a collection are not ordered so this is not reliably
-    # @deprecated use Browser#switch_window or a better Window locator
-    # @return [Watir::Window] Returns an instance of a Watir::Window
-    #
-
-    def first
-      self[0]
-    end
-
-    #
-    # Last window of the collection
-    #
-    # @note windows in a collection are not ordered so this is not reliably
-    # @deprecated use Browser#switch_window or a better Window locator
-    # @return [Watir::Window] Returns an instance of a Watir::Window
-    #
-
-    def last
-      self[-1]
-    end
-
-    #
-    # Get the window at the given index or range.
-    #
-    # @note windows in a collection are not ordered so this is not reliably
-    # @deprecated use Browser#switch_window or a better Window locator
-    # @param [Integer, Range] value Index (0-based) or Range of desired window(s)
-    # @return [Watir::Window] Returns an instance of a Watir::Window
-    #
-
-    def [](value)
-      old = 'using indexing with windows'
-      new = 'Browser#switch_window or Browser#window with :title, :url or :element selectors'
-      reference = 'http://watir.com/window_indexes'
-      Watir.logger.deprecate old, new, reference: reference, ids: [:window_index]
-
-      window_list[value]
+    def [](*)
+      raise NoMethodError, 'indexing not reliable on WindowCollection'
     end
+    alias first []
+    alias last []
+    alias to_a []
 
     def ==(other)
       window_list == other.send(:window_list)
@@ -78,15 +43,6 @@ module Watir
       @window_list = nil
     end
 
-    def to_a
-      old = 'WindowCollection#to_a to interact with indexed windows'
-      new = 'Enumerable methods to iterate over windows'
-      reference = 'http://watir.com/window_indexes'
-      Watir.logger.deprecate old, new, reference: reference, ids: [:window_index]
-
-      window_list
-    end
-
     private
 
     def window_list

data/lib/watirspec/implementation.rb

@@ -19,6 +19,10 @@ module WatirSpec
       @name || raise('implementation name not set')
     end
 
+    def browser_name
+      browser_args.first == :ie ? :internet_explorer : browser_args.first
+    end
+
     def matches_guard?(args)
       return @guard_proc.call(args) if @guard_proc
 

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-if ENV['GITHUB_ACTIONS'] || ENV['COVERAGE']
+if ENV['COVERAGE']
   require 'coveralls'
   require 'simplecov'
   require 'simplecov-console'
@@ -12,7 +12,6 @@ if ENV['GITHUB_ACTIONS'] || ENV['COVERAGE']
     add_filter %r{/spec/}
     add_filter 'lib/watir/elements/html_elements.rb'
     add_filter 'lib/watir/elements/svg_elements.rb'
-    add_filter 'lib/watir/legacy_wait.rb'
     add_filter 'lib/watirspec'
     refuse_coverage_drop
   end
@@ -22,7 +21,7 @@ require 'watir'
 require 'locator_spec_helper'
 require 'rspec'
 
-if ENV['GITHUB_ACTIONS']
+if ENV['AUTOMATIC_RETRY']
   require 'rspec/retry'
   RSpec.configure do |config|
     config.verbose_retry = true
@@ -31,7 +30,3 @@ if ENV['GITHUB_ACTIONS']
     config.exceptions_to_retry = [IOError, Net::ReadTimeout]
   end
 end
-
-SELENIUM_SELECTORS = %i[css tag_name xpath link_text partial_link_text link].freeze
-
-Watir.relaxed_locate = false if ENV['RELAXED_LOCATE'] == 'false'

data/spec/unit/capabilities_spec.rb

@@ -1,19 +1,7 @@
 require 'watirspec_helper'
 
 describe Watir::Capabilities do
-  before do
-    compliant_on :v6_18 do
-      ENV['IGNORE_DEPRECATIONS'] = 'true'
-    end
-  end
-
-  before do
-    compliant_on :v6_18 do
-      ENV['IGNORE_DEPRECATIONS'] = 'true'
-    end
-  end
-
-  after(:all) { ENV['IGNORE_DEPRECATIONS'] = nil }
+  before(:all) { Watir.logger.ignore(:watir_client) }
 
   def expected_browser(browser)
     case browser
@@ -45,25 +33,7 @@ describe Watir::Capabilities do
     service_class(browser).driver_path = nil
   end
 
-  def default_client
-    compliant_on :v6_18 do
-      return Selenium::WebDriver::Remote::Http::Default
-    end
-    Watir::HttpClient
-  end
-
-  def capabilities_key
-    compliant_on :v6_18 do
-      return :desired_capabilities
-    end
-    :capabilities
-  end
-
-  supported_browsers = %i[chrome firefox ie safari]
-
-  not_compliant_on :v6_18, :v6_19 do
-    supported_browsers << :edge
-  end
+  supported_browsers = %i[chrome edge firefox ie safari]
 
   # Options:
   # :listener
@@ -73,93 +43,38 @@ describe Watir::Capabilities do
   # :capabilities (incompatible with options)
 
   supported_browsers.each do |browser_symbol|
-    # 6.18 works except for safari
-    # 6.19 fix safari
-    # 7.0  remove Capabilities requirement
-    it 'just browser has client, options & capabilities but not service' do
-      compliant_on :v6_18 do
-        skip if browser_symbol == :safari # No extra processing needed
-      end
+    it 'just browser has client & capabilities not service' do
       capabilities = Watir::Capabilities.new(browser_symbol)
 
       args = capabilities.to_args
-      expect(args.last[:http_client]).to be_a default_client
-      expect(args.last[:options]).to be_a options_class(browser_symbol)
-      expect(args.last[:desired_capabilities]).to be_a(Selenium::WebDriver::Remote::Capabilities)
+      expect(args.last[:http_client]).to be_a Watir::HttpClient
+      expect(args.last[:capabilities]).to be_a options_class(browser_symbol)
       expect(args.last).not_to include(:service)
     end
 
-    # 6.18 never implemented
-    # 6.19 implement
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'just options has client, options & capabilities but not service' do
-        capabilities = Watir::Capabilities.new(options: options_class(browser_symbol).new)
+    it 'just options has client & options but not capabilities or service' do
+      capabilities = Watir::Capabilities.new(options: options_class(browser_symbol).new)
 
-        args = capabilities.to_args
-
-        expect(args.last[:http_client]).to be_a default_client
-        expect(args.last[:options]).to be_a options_class(browser_symbol)
-        expect(args.last[:desired_capabilities]).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(args.last[:desired_capabilities].browser_name).to eq expected_browser(browser_symbol)
-        expect(args.last).not_to include(:service)
-      end
-    end
-
-    # 6.18 never implemented
-    # 6.19 implement
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'just capabilities has client, options & capabilities but not service' do
-        caps = Selenium::WebDriver::Remote::Capabilities.send(browser_symbol)
-        capabilities = Watir::Capabilities.new(capabilities_key => caps)
-
-        args = capabilities.to_args
+      args = capabilities.to_args
 
-        expect(args.last[:http_client]).to be_a default_client
-        expect(args.last[:options]).to be_a options_class(browser_symbol)
-        expect(args.last[:desired_capabilities]).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(args.last[:desired_capabilities].browser_name).to eq expected_browser(browser_symbol)
-        expect(args.last).not_to include(:service)
-      end
+      expect(args.last[:http_client]).to be_a Watir::HttpClient
+      expect(args.last[:capabilities]).to be_a options_class(browser_symbol)
+      expect(args.last).not_to include(:service)
     end
 
-    # 6.18 works
-    # 6.19 deprecate :desired_capabilities
-    # 7.0  raise exception
-    it 'desired_capabilities works but deprecated' do
-      expect {
-        desired_capabilities = Selenium::WebDriver::Remote::Capabilities.send(browser_symbol)
-        capabilities = Watir::Capabilities.new(browser_symbol,
-                                               desired_capabilities: desired_capabilities)
-        args = capabilities.to_args
-        expect(args.first).to eq browser_symbol
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq expected_browser(browser_symbol)
-      }.to have_deprecated_desired_capabilities
-    end
+    it 'just capabilities has client & capabilities but not service' do
+      caps = Selenium::WebDriver::Remote::Capabilities.send(browser_symbol)
+      capabilities = Watir::Capabilities.new(capabilities: caps)
 
-    # 6.18 broken; puts service in desired capabilities so of course not there
-    # 6.19 fix with deprecation
-    # 7.0  raise exception
-    it 'service not allowed when url specified' do
-      halt_service(browser_symbol)
+      args = capabilities.to_args
 
-      expect {
-        capabilities = Watir::Capabilities.new(browser_symbol,
-                                               url: 'http://example.com',
-                                               service: service_class(browser_symbol).new)
-        args = capabilities.to_args
-        expect(args.first).to eq :remote
-        expect(args.last).not_to include(:service)
-      }.to have_deprecated_url_service
+      expect(args.last[:http_client]).to be_a Watir::HttpClient
+      expect(args.last[:capabilities]).to be_a(Selenium::WebDriver::Remote::Capabilities)
+      expect(args.last[:capabilities].browser_name).to eq expected_browser(browser_symbol)
+      expect(args.last).not_to include(:service)
     end
 
     context 'service' do
-      # 6.18 never implemented
-      # 6.19 implement
-      # 7.0  valid
       it 'uses provided service' do
         halt_service(browser_symbol)
 
@@ -171,76 +86,33 @@ describe Watir::Capabilities do
         expect(actual_service.instance_variable_get('@port')).to eq 1234
       end
 
-      # 6.18 never implemented
-      # 6.19 implement!
-      # 7.0  valid
-      not_compliant_on :v6_18 do
-        it 'builds service from a Hash' do
-          halt_service(browser_symbol)
-
-          service = {port: 1234, path: '/path/to/driver', args: %w[--foo --bar]}
-          capabilities = Watir::Capabilities.new(browser_symbol, service: service)
-          args = capabilities.to_args
-          expect(args.first).to eq browser_symbol
-          actual_service = args.last[:service]
-          expect(actual_service.instance_variable_get('@port')).to eq 1234
-          expect(actual_service.instance_variable_get('@executable_path')).to eq '/path/to/driver'
-          expect(actual_service.instance_variable_get('@extra_args')).to include '--foo', '--bar'
-        end
-
-        it 'is a bad argument to service' do
-          capabilities = Watir::Capabilities.new(browser_symbol, service: 7)
-
-          expect { capabilities.to_args }.to raise_exception(TypeError)
-        end
-      end
-
-      # 6.18 broken: puts it in desired capabilities (neither ":path" nor ":driver_path" work)
-      # 6.19 do nothing
-      # 7.0  remove
-      xit 'creates when :path specified' do
+      it 'builds service from a Hash' do
         halt_service(browser_symbol)
-        capabilities = Watir::Capabilities.new(browser_symbol, path: '/path/to/driver')
 
+        service = {port: 1234, path: '/path/to/driver', args: %w[--foo --bar]}
+        capabilities = Watir::Capabilities.new(browser_symbol, service: service)
         args = capabilities.to_args
-        expect(args.last[:path]).to eq '/path/to/driver'
+        expect(args.first).to eq browser_symbol
+        actual_service = args.last[:service]
+        expect(actual_service.instance_variable_get('@port')).to eq 1234
+        expect(actual_service.instance_variable_get('@executable_path')).to eq '/path/to/driver'
+        expect(actual_service.instance_variable_get('@extra_args')).to include '--foo', '--bar'
       end
 
-      # 6.18 works - puts them at top level in selenium opts, which Selenium 3 can read
-      # 6.19 deprecate - put inside :service keyword
-      # 7.0  remove
-      it 'creates when service port specified' do
-        halt_service(browser_symbol)
+      it 'is a bad argument to service' do
+        capabilities = Watir::Capabilities.new(browser_symbol, service: 7)
 
-        expect {
-          capabilities = Watir::Capabilities.new(browser_symbol,
-                                                 port: 1234)
-          @args = capabilities.to_args
-        }.to have_deprecated_port_keyword
-
-        compliant_on :v6_18 do
-          expect(@args.last[:port]).to eq 1234
-        end
-
-        not_compliant_on :v6_18 do
-          expect(@args.last[:service].instance_variable_get('@port')).to eq 1234
-        end
+        expect { capabilities.to_args }.to raise_exception(TypeError)
       end
     end
 
     context 'http_client' do
-      # 6.18 works
-      # 6.19 update to Watir::HttpClient
-      # 7.0  valid
       it 'uses default HTTP Client' do
         capabilities = Watir::Capabilities.new(browser_symbol)
         args = capabilities.to_args
-        expect(args.last[:http_client]).to be_a default_client
+        expect(args.last[:http_client]).to be_a Watir::HttpClient
       end
 
-      # 6.18 works
-      # 6.19 do nothing
-      # 7.0  valid
       it 'accepts an HTTP Client object' do
         client = Selenium::WebDriver::Remote::Http::Default.new
         capabilities = Watir::Capabilities.new(browser_symbol, http_client: client)
@@ -248,68 +120,23 @@ describe Watir::Capabilities do
         expect(args.last[:http_client]).to eq client
       end
 
-      # 6.18 Not implemented
-      # 6.19 implement!
-      # 7.0  valid
-      not_compliant_on :v6_18 do
-        it 'builds an HTTP Client from Hash' do
-          client_opts = {open_timeout: 10, read_timeout: 10}
-          capabilities = Watir::Capabilities.new(browser_symbol, http_client: client_opts)
-          args = capabilities.to_args
-          actual_client = args.last[:http_client]
-          expect(actual_client).to be_a default_client
-          expect(actual_client.instance_variable_get('@read_timeout')).to eq 10
-          expect(actual_client.instance_variable_get('@open_timeout')).to eq 10
-        end
-      end
-
-      # 6.18 Not implemented
-      # 6.19 implement!
-      # 7.0  valid
-      not_compliant_on :v6_18 do
-        it 'raises an exception if :client receives something other than Hash or Client object' do
-          expect {
-            Watir::Capabilities.new(browser_symbol, http_client: 7).to_args
-          }.to raise_exception(TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance')
-        end
+      it 'builds an HTTP Client from Hash' do
+        client_opts = {open_timeout: 10, read_timeout: 10}
+        capabilities = Watir::Capabilities.new(browser_symbol, http_client: client_opts)
+        args = capabilities.to_args
+        actual_client = args.last[:http_client]
+        expect(actual_client).to be_a Watir::HttpClient
+        expect(actual_client.instance_variable_get('@read_timeout')).to eq 10
+        expect(actual_client.instance_variable_get('@open_timeout')).to eq 10
       end
 
-      # 6.18 works
-      # 6.19 deprecate --> client_timeout isn't a thing any more
-      # 7.0  remove
-      it 'builds a client from client_timeout' do
+      it 'raises an exception if :client receives something other than Hash or Client object' do
         expect {
-          opt = {client_timeout: 10}
-          capabilities = Watir::Capabilities.new(browser_symbol, opt)
-          args = capabilities.to_args
-          actual_client = args.last[:http_client]
-          expect(actual_client).to be_a default_client
-          expect(actual_client.instance_variable_get('@read_timeout')).to eq 10
-          expect(actual_client.instance_variable_get('@open_timeout')).to eq 10
-        }.to have_deprecated_http_client_timeout
-      end
-
-      # 6.18 works
-      # 6.19 deprecate --> timeouts inside http_client key
-      # 7.0  remove
-      %i[open_timeout read_timeout].each do |timeout|
-        it "builds a client from #{timeout}" do
-          expect {
-            opt = {timeout => 10}
-
-            capabilities = Watir::Capabilities.new(browser_symbol, opt)
-            args = capabilities.to_args
-            actual_client = args.last[:http_client]
-            expect(actual_client).to be_a default_client
-            expect(actual_client.instance_variable_get("@#{timeout}")).to eq 10
-          }.to send("have_deprecated_http_#{timeout}")
-        end
+          Watir::Capabilities.new(browser_symbol, http_client: 7).to_args
+        }.to raise_exception(TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance')
       end
     end
 
-    # 6.18 works
-    # 6.19 do nothing
-    # 7.0  valid
     it 'uses a listener' do
       listener = Selenium::WebDriver::Support::AbstractEventListener.new
       capabilities = Watir::Capabilities.new(browser_symbol, listener: listener)
@@ -317,69 +144,13 @@ describe Watir::Capabilities do
       expect(args.last[:listener]).to eq listener
     end
 
-    # 6.18 works
-    # 6.19 warn
-    # 7.0  Raise Exception
     it 'accepts both capabilities and Options' do
       caps = Selenium::WebDriver::Remote::Capabilities.send(browser_symbol)
       opts = options_class(browser_symbol).new
 
       expect {
-        @capabilities = Watir::Capabilities.new(browser_symbol,
-                                                capabilities_key => caps,
-                                                options: opts)
-      }.to have_deprecated_options_capabilities
-
-      args = @capabilities.to_args
-      expect(args.last[:desired_capabilities]).to eq caps
-
-      # Safari never implemented to accept options
-      if browser_symbol == :safari
-        not_compliant_on :v6_18 do
-          expect(args.last[:options]).to eq opts
-        end
-      end
-    end
-
-    # 6.18 works
-    # 6.19 deprecate --> put in options
-    # 7.0  remove
-    context 'extra things' do
-      it 'puts in capabilities when capabilities not specified' do
-        expect {
-          capabilities = Watir::Capabilities.new(browser_symbol, foo: 'bar')
-          args = capabilities.to_args
-          expect(args.last[:desired_capabilities][:foo]).to eq 'bar'
-        }.to have_deprecated_unknown_keyword
-      end
-
-      # 6.18 works
-      # 6.19 deprecate --> put in options
-      # 7.0  remove
-      it 'puts in top level when Capabilities specified' do
-        caps = Selenium::WebDriver::Remote::Capabilities.send(browser_symbol)
-        capabilities = Watir::Capabilities.new(browser_symbol,
-                                               capabilities_key => caps,
-                                               foo: 'bar')
-        expect {
-          expect(capabilities.to_args.last[:foo]).to eq 'bar'
-        }.to have_deprecated_unknown_keyword
-      end
-
-      # 6.18 works
-      # 6.19 deprecate --> put in options
-      # 7.0  remove
-      it 'puts in top level when Options specified' do
-        expect {
-          caps = Selenium::WebDriver::Remote::Capabilities.send(browser_symbol)
-          capabilities = Watir::Capabilities.new(browser_symbol,
-                                                 capabilities_key => caps,
-                                                 options: options_class(browser_symbol).new,
-                                                 foo: 'bar')
-          args = capabilities.to_args
-          expect(args.last[:foo]).to eq 'bar'
-        }.to have_deprecated_unknown_keyword
-      end
+        Watir::Capabilities.new(browser_symbol, capabilities: caps, options: opts)
+      }.to raise_exception(ArgumentError, ':capabilities and :options are not both allowed')
     end
   end
 
@@ -392,104 +163,26 @@ describe Watir::Capabilities do
   # :capabilities (incompatible with options)
 
   describe 'Remote execution' do
-    # 6.18 Was not implemented
-    # 6.19 Implement
-    # 7.0  Valid
-    not_compliant_on :v6_18 do
-      it 'with just url' do
-        capabilities = Watir::Capabilities.new(url: 'http://example.com')
-        args = capabilities.to_args
-        expect(args.first).to eq :remote
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq 'chrome'
-      end
-    end
-
-    # 6.18 does not work
-    # 6.19 do nothing
-    # 7.0  remove
-    xit ':remote keyword with url has options, chrome and client but not service' do
-      capabilities = Watir::Capabilities.new(:remote,
-                                             url: 'https://example.com/wd/hub/')
+    it 'with just url' do
+      capabilities = Watir::Capabilities.new(url: 'http://example.com')
       args = capabilities.to_args
       expect(args.first).to eq :remote
-      expect(args.last[:url]).to eq 'https://example.com/wd/hub'
-      expect(args.last[:http_client]).to be_a default_client
-      expect(args.last[:options]).to be_a Selenium::WebDriver::Chrome::Options
-      desired_capabilities = args.last[:desired_capabilities]
-      expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-      expect(desired_capabilities.browser_name).to eq 'chrome'
-      expect(args.last).not_to include(:service)
+      actual_options = args.last[:capabilities]
+      expect(actual_options.browser_name).to eq 'chrome'
     end
 
-    # 6.18 works
-    # 6.19 this should use options instead of capabilities
-    # 7.0  valid
     it 'browser name with url has capabilities and client but not service' do
       capabilities = Watir::Capabilities.new(:firefox,
                                              url: 'https://example.com/wd/hub/')
       args = capabilities.to_args
       expect(args.first).to eq :remote
       expect(args.last[:url]).to eq 'https://example.com/wd/hub/'
-      expect(args.last[:http_client]).to be_a default_client
-
-      not_compliant_on :v6_18 do
-        expect(args.last[:options]).to be_a Selenium::WebDriver::Firefox::Options
-      end
-
-      not_compliant_on :v6_19 do
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq 'firefox'
-      end
+      expect(args.last[:http_client]).to be_a Watir::HttpClient
 
+      expect(args.last[:capabilities]).to be_a Selenium::WebDriver::Firefox::Options
       expect(args.last).not_to include(:service)
     end
 
-    # 6.18 works
-    # 6.19 deprecate :remote_keyword
-    # 7.0  remove
-    it 'remote keyword with url and browser name' do
-      expect {
-        capabilities = Watir::Capabilities.new(:remote,
-                                               {browser: :firefox,
-                                                url: 'https://example.com'})
-        args = capabilities.to_args
-        expect(args.first).to eq :remote
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq 'firefox'
-      }.to have_deprecated_remote_keyword
-    end
-
-    # 6.18 not implemented
-    # 6.19 do nothing
-    # 7.0  remove
-    xit 'remote keyword errors when given a service' do
-      capabilities = Watir::Capabilities.new(:remote,
-                                             url: 'http://example.com',
-                                             service: Selenium::WebDriver::Chrome::Service.new)
-
-      capabilities.to_args
-    end
-
-    # 6.18 not implemented; just ignores them
-    # 6.19 throw error
-    # 7.0  throw error
-    not_compliant_on :v6_18 do
-      it 'browser name errors when given a service' do
-        expect {
-          Watir::Capabilities.new(:chrome,
-                                  url: 'http://example.com',
-                                  service: Selenium::WebDriver::Chrome::Service.new)
-        }.to have_deprecated_url_service
-      end
-    end
-
-    # 6.18 works
-    # 6.19 nothing
-    # 7.0  valid
     it 'accepts a listener' do
       listener = Selenium::WebDriver::Support::AbstractEventListener.new
       capabilities = Watir::Capabilities.new(:chrome,
@@ -499,745 +192,319 @@ describe Watir::Capabilities do
       expect(args.last[:listener]).to eq listener
     end
 
-    # 6.18 not implemented (should have defaulted to chrome)
-    # 6.19 do nothing; it never worked
-    # 7.0  remove
-    xit 'remote keyword with url and http client object' do
-      client = default_client.new
-      capabilities = Watir::Capabilities.new(:remote,
-                                             url: 'https://example.com/wd/hub',
-                                             http_client: client)
-      args = capabilities.to_args
-      expect(args.first).to eq :remote
-      expect(args.last[:http_client]).to eq client
-      desired_capabilities = args.last[:desired_capabilities]
-      expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-      expect(desired_capabilities.browser_name).to eq 'chrome'
-    end
-
-    # 6.18 works
-    # 6.19 nothing
-    # 7.0  valid
     it 'browser name with url and http client object' do
-      client = default_client.new
+      client = Watir::HttpClient.new
       capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'https://example.com/wd/hub',
                                              http_client: client)
       args = capabilities.to_args
       expect(args.first).to eq :remote
       expect(args.last[:http_client]).to eq client
-      desired_capabilities = args.last[:desired_capabilities]
-      expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-      expect(desired_capabilities.browser_name).to eq 'chrome'
+      actual_options = args.last[:capabilities]
+      expect(actual_options.browser_name).to eq 'chrome'
     end
 
-    # 6.18 not implemented (should have defaulted to chrome)
-    # 6.19 do nothing; never worked
-    # 7.0  remove
-    xit 'remote keyword with url and http client Hash' do
-      capabilities = Watir::Capabilities.new(:remote,
+    it 'browser name with url and http client Hash' do
+      capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'https://example.com/wd/hub',
-                                             client: {read_timeout: 30})
+                                             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
-      desired_capabilities = args.last[:desired_capabilities]
-      expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-      expect(desired_capabilities.browser_name).to eq 'chrome'
-    end
-
-    # 6.18 not implemented - does not build from Hash
-    # 6.19 build from hash
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'browser name with url and 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
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq 'chrome'
-      end
+      actual_options = args.last[:capabilities]
+      expect(actual_options.browser_name).to eq 'chrome'
     end
 
-    # 6.18 Broken
-    # 6.19 do nothing; never worked
-    # 7.0  remove
-    xit 'remote keyword with url and options object' do
-      capabilities = Watir::Capabilities.new(:remote,
+    it 'browser name with url and options object' do
+      capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'https://example.com/wd/hub',
-                                             options: Selenium::WebDriver::Chrome::Options.new)
+                                             options: Selenium::WebDriver::Chrome::Options.new(args: ['--foo']))
       args = capabilities.to_args
       expect(args.first).to eq :remote
-      desired_capabilities = args.last[:desired_capabilities]
-      expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-      expect(desired_capabilities.browser_name).to eq 'chrome'
-    end
-
-    # 6.18 broken; options eaten
-    # 6.19 fix
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'browser name with url and options object' do
-        opts = {args: ['--foo']}
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               url: 'https://example.com/wd/hub',
-                                               options: Selenium::WebDriver::Chrome::Options.new(opts))
-        args = capabilities.to_args
-        expect(args.first).to eq :remote
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq 'chrome'
-        options = args.last[:options]
-        expect(options.args).to include('--foo')
-      end
+      actual_options = args.last[:capabilities]
+      expect(actual_options.browser_name).to eq 'chrome'
+      expect(actual_options.args).to include('--foo')
     end
 
-    # 6.18 not implemented - can't figure out options
-    # 6.19 do nothing; never worked
-    # 7.0  remove
-    xit 'remote keyword with url and options hash' do
-      capabilities = Watir::Capabilities.new(:remote,
+    it 'browser name with url and options hash' do
+      options = {prefs: {foo: 'bar'}}
+      capabilities = Watir::Capabilities.new(:chrome,
                                              url: 'http://example.com',
-                                             options: {prefs: {foo: 'bar'}})
+                                             options: options)
       args = capabilities.to_args
       expect(args.first).to eq :remote
       expect(args.last[:url]).to eq 'http://example.com'
-      options = args.last[:options]
-      expect(options).to be_a(Selenium::WebDriver::Chrome::Options)
-    end
-
-    # 6.18 does not work; options got dropped
-    # 6.19 fix
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'browser name with url and options hash' do
-        options = {prefs: {foo: 'bar'}}
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               url: 'http://example.com',
-                                               options: options)
-        args = capabilities.to_args
-        expect(args.first).to eq :remote
-        expect(args.last[:url]).to eq 'http://example.com'
-        actual_options = args.last[:options]
-        expect(actual_options).to be_a(Selenium::WebDriver::Chrome::Options)
-        expect(actual_options.prefs).to eq(foo: 'bar')
-      end
-    end
-
-    # 6.18 works
-    # 6.19 deprecate :remote_keyword
-    # 7.0  remove
-    it 'remote keyword with url and capabilities' do
-      expect {
-        caps = Watir::Capabilities.new(:remote,
-                                       url: 'https://example.com/wd/hub',
-                                       capabilities_key => Selenium::WebDriver::Remote::Capabilities.chrome)
-        args = caps.to_args
-        expect(args.first).to eq :remote
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq 'chrome'
-      }.to have_deprecated_remote_keyword # (and desired_capabilities)
+      actual_options = args.last[:capabilities]
+      expect(actual_options).to be_a(Selenium::WebDriver::Chrome::Options)
+      expect(actual_options.prefs).to eq(foo: 'bar')
     end
 
-    # 6.18 works
-    # 6.19 nothing
-    # 7.0  valid
     it 'browser name with url and capabilities' do
       caps = Watir::Capabilities.new(:chrome,
                                      url: 'https://example.com/wd/hub',
-                                     capabilities_key => Selenium::WebDriver::Remote::Capabilities.chrome)
+                                     capabilities: Selenium::WebDriver::Remote::Capabilities.chrome)
       args = caps.to_args
       expect(args.first).to eq :remote
-      desired_capabilities = args.last[:desired_capabilities]
-      expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-      expect(desired_capabilities.browser_name).to eq 'chrome'
+      actual_capabilities = args.last[:capabilities]
+      expect(actual_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
+      expect(actual_capabilities.browser_name).to eq 'chrome'
     end
 
-    # 6.18 works
-    # 6.19 deprecate :remote_keyword
-    # 7.0  remove
-    it 'remote keyword with http client & capabilities' do
-      expect {
-        client = default_client.new
-        caps = Watir::Capabilities.new(:remote,
-                                       url: 'https://example.com/wd/hub',
-                                       capabilities_key => Selenium::WebDriver::Remote::Capabilities.chrome,
-                                       http_client: client)
-
-        args = caps.to_args
-        expect(args.first).to eq :remote
-        expect(args.last[:http_client]).to eq client
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq 'chrome'
-      }.to have_deprecated_remote_keyword # (and desired_capabilities)
-    end
-
-    # 6.18 works
-    # 6.19 nothing
-    # 7.0  valid
     it 'browser name with http client & capabilities' do
-      client = default_client.new
+      client = Watir::HttpClient.new
       caps = Watir::Capabilities.new(:chrome,
                                      url: 'https://example.com/wd/hub',
-                                     capabilities_key => Selenium::WebDriver::Remote::Capabilities.chrome,
+                                     capabilities: Selenium::WebDriver::Remote::Capabilities.chrome,
                                      http_client: client)
 
       args = caps.to_args
       expect(args.first).to eq :remote
       expect(args.last[:http_client]).to eq client
-      desired_capabilities = args.last[:desired_capabilities]
-      expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-      expect(desired_capabilities.browser_name).to eq 'chrome'
+      actual_capabilities = args.last[:capabilities]
+      expect(actual_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
+      expect(actual_capabilities.browser_name).to eq 'chrome'
     end
 
-    # 6.18 broken; options is eaten
-    # 6.19 fix
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'browser name with http client & options object' do
-        client = default_client.new
-        opts = {prefs: {foo: 'bar'}}
-        options = Selenium::WebDriver::Chrome::Options.new(opts)
-        caps = Watir::Capabilities.new(:chrome,
-                                       url: 'https://example.com/wd/hub',
-                                       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[:options]
-        expect(actual_options).to be_a(Selenium::WebDriver::Chrome::Options)
-        expect(actual_options.prefs).to eq(foo: 'bar')
-      end
+    it 'browser name with http client & options object' do
+      client = Watir::HttpClient.new
+      options = Selenium::WebDriver::Chrome::Options.new(prefs: {foo: 'bar'})
+      caps = Watir::Capabilities.new(:chrome,
+                                     url: 'https://example.com/wd/hub',
+                                     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]
+      expect(actual_options).to be_a(Selenium::WebDriver::Chrome::Options)
+      expect(actual_options.prefs).to eq(foo: 'bar')
     end
 
-    # 6.18 broken; options is eaten
-    # 6.19 do nothing
-    # 7.0  raise exception
-    not_compliant_on :v6_18 do
-      it 'browser name with options & capabilities' do
-        options = {prefs: {foo: 'bar'}}
+    it 'browser name with options & capabilities' do
+      options = {prefs: {foo: 'bar'}}
 
-        expect {
-          @caps = Watir::Capabilities.new(:chrome,
-                                          url: 'https://example.com/wd/hub',
-                                          capabilities_key => Selenium::WebDriver::Remote::Capabilities.chrome,
-                                          options: options)
-        }.to have_deprecated_options_capabilities
-
-        args = @caps.to_args
-        expect(args.first).to eq :remote
-        desired_capabilities = args.last[:desired_capabilities]
-        expect(desired_capabilities).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(desired_capabilities.browser_name).to eq 'chrome'
-        actual_options = args.last[:options]
-        expect(actual_options).to be_a(Selenium::WebDriver::Chrome::Options)
-        expect(actual_options.prefs).to eq(foo: 'bar')
-      end
+      expect {
+        Watir::Capabilities.new(:chrome,
+                                url: 'https://example.com/wd/hub',
+                                capabilities: Selenium::WebDriver::Remote::Capabilities.chrome,
+                                options: options)
+      }.to raise_exception(ArgumentError, ':capabilities and :options are not both allowed')
     end
 
-    # 6.18 broken - Selenium doesn't support "chromeOptions" in Capabilities. Did it even at one point?
-    # 6.19 fix! allow to stay in top level
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'allows headless to be set in chrome' do
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               headless: true,
-                                               url: 'http://example.com')
-        args = capabilities.to_args
-        actual_options = args.last[:options]
-        expect(actual_options.args).to include '--headless', '--disable-gpu'
-      end
+    it 'allows headless to be set in chrome' do
+      capabilities = Watir::Capabilities.new(:chrome,
+                                             headless: true,
+                                             url: 'http://example.com')
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities]
+      expect(actual_options.args).to include '--headless', '--disable-gpu'
     end
 
-    # 6.18 works - Putting it straight into Desired Capabilities. Bold move Watir 6.6. Bold move.
-    # 6.19 keep, but do this with Options instead of capabilities
-    # 7.0  valid
     it 'allows headless to be set in firefox' do
       capabilities = Watir::Capabilities.new(:firefox,
                                              headless: true,
                                              url: 'http://example.com')
       args = capabilities.to_args
 
-      compliant_on :v6_18 do
-        actual_capabilities = args.last[:desired_capabilities]
-        expect(actual_capabilities['moz:firefoxOptions']['args']).to include '--headless'
-      end
-
-      not_compliant_on :v6_18 do
-        expect(args.last[:options].args).to include '--headless'
-      end
-    end
-
-    # 6.18 works - Putting it into desired capabilities
-    # 6.19 deprecate this, it should go under options
-    # 7.0  remove
-    it 'allows sending to Browser Service Provider top level' do
-      expect {
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               'sauce:options' => {username: ENV['SAUCE_USERNAME'],
-                                                                   access_key: ENV['SAUCE_ACCESS_KEY']},
-                                               url: 'https://ondemand.us-west-1.saucelabs.com')
-        args = capabilities.to_args
-        actual_capabilities = args.last[:desired_capabilities]
-        expect(actual_capabilities['sauce:options'].keys).to include :username, :access_key
-      }.to have_deprecated_unknown_keyword
+      expect(args.last[:capabilities].args).to include '-headless'
     end
 
-    # 6.18 broken; options class eats it
-    # 6.19 Fix it
-    # 7.0  valid
     it 'allows sending to Browser Service Provider via options' do
-      not_compliant_on :v6_18 do
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               options: {'sauce:options' => {username: ENV['SAUCE_USERNAME'],
-                                                                             access_key: ENV['SAUCE_ACCESS_KEY']}},
-                                               url: 'https://ondemand.us-west-1.saucelabs.com')
-        args = capabilities.to_args
-        actual_capabilities = args.last[:desired_capabilities]
-        expect(actual_capabilities['sauce:options']&.keys).to include :username, :access_key
-      end
-    end
-  end
-
-  describe 'chrome' do
-    # 6.18 never implemented
-    # 6.19 implement
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'by default uses chrome, has client, options & capabilities' do
-        capabilities = Watir::Capabilities.new
-        args = capabilities.to_args
-        expect(args.last[:http_client]).to be_a default_client
-        expect(args.last[:options]).to be_a Selenium::WebDriver::Chrome::Options
-        expect(args.last[:desired_capabilities]).to be_a(Selenium::WebDriver::Remote::Capabilities)
-        expect(args.last).not_to include(:service)
-      end
-    end
-
-    # 6.18 works - puts them at top level in selenium opts, which Selenium 3 can read
-    # 6.19 deprecate - put inside :service keyword
-    # 7.0  remove
-    it 'creates when service driver opts specified' do
-      halt_service(:chrome)
-
-      expect {
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               driver_opts: {verbose: true})
-        @args = capabilities.to_args
-      }.to have_deprecated_driver_opts_keyword
-
-      compliant_on :v6_18 do
-        expect(@args.last[:driver_opts]).to eq(verbose: true)
-      end
-
-      not_compliant_on :v6_18 do
-        expect(@args.last[:service].instance_variable_get('@extra_args')).to eq ['--verbose']
-      end
-    end
-
-    # 6.18 works
-    # 6.19 deprecate --> put in options
-    # 7.0  remove
-    it 'places args by creating options' do
-      expect {
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               args: ['--foo'])
-        args = capabilities.to_args
-        actual_options = args.last[:options]
-        expect(actual_options.args).to include '--foo'
-      }.to have_deprecated_args_keyword
-    end
-
-    # 6.18 broken because assumes args is empty and overrides
-    # 6.19 do nothing; never worked
-    # 7.0  remove
-    xit 'places args when paired with options Hash' do
       capabilities = Watir::Capabilities.new(:chrome,
-                                             args: ['--foo'],
-                                             options: {args: ['--bar']})
+                                             options: {'sauce:options': {username: ENV['SAUCE_USERNAME'],
+                                                                         access_key: ENV['SAUCE_ACCESS_KEY']}},
+                                             url: 'https://ondemand.us-west-1.saucelabs.com')
       args = capabilities.to_args
-      actual_options = args.last[:options]
-      expect(actual_options.args).to include '--foo', '--bar'
+      actual_options = args.last[:capabilities].instance_variable_get('@options')
+      expect(actual_options[:'sauce:options']).to include :username, :access_key
     end
+  end
 
-    # 6.18 broken because assumes options is a Hash
-    # 6.19 do nothing; never worked
-    # 7.0  remove
-    xit 'places args when paired with options object' do
-      options = Selenium::WebDriver::Chrome::Options.new(args: ['--bar'])
-      capabilities = Watir::Capabilities.new(:chrome,
-                                             args: ['--foo'],
-                                             options: options)
+  describe 'chrome' do
+    it 'by default uses chrome, has client, options, but not capabilities' do
+      capabilities = Watir::Capabilities.new
       args = capabilities.to_args
-      actual_options = args.last[:options]
-      expect(actual_options.args).to include '--foo', '--bar'
-    end
-
-    # 6.18 works
-    # 6.19 deprecate --> no more "switches"
-    # 7.0  remove
-    it 'places switches as args by creating options' do
-      expect {
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               switches: ['--foo'])
-        args = capabilities.to_args
-        actual_options = args.last[:options]
-        expect(actual_options.args).to include '--foo'
-      }.to have_deprecated_switches_keyword
+      expect(args.last[:http_client]).to be_a Watir::HttpClient
+      expect(args.last[:capabilities]).to be_a Selenium::WebDriver::Chrome::Options
+      expect(args.last).not_to include(:service)
     end
 
-    # 6.18 works
-    # 6.19 allow to stay in top level
-    # 7.0  valid
     it 'sets headless by creating options' do
       capabilities = Watir::Capabilities.new(:chrome, headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:options]
+      actual_options = args.last[:capabilities]
       expect(actual_options.args).to include '--headless', '--disable-gpu'
     end
 
-    # 6.18 broken because assumes options is a Hash
-    # 6.19 fix
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'sets headless in existing options class' do
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               options: Selenium::WebDriver::Chrome::Options.new,
-                                               headless: true)
-        args = capabilities.to_args
-        actual_options = args.last[:options]
-        expect(actual_options.args).to include '--headless', '--disable-gpu'
-      end
+    it 'sets headless in existing options class' do
+      capabilities = Watir::Capabilities.new(:chrome,
+                                             options: Selenium::WebDriver::Chrome::Options.new,
+                                             headless: true)
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities]
+      expect(actual_options.args).to include '--headless', '--disable-gpu'
     end
 
-    # 6.18 works
-    # 6.19 allow to stay in top level
-    # 7.0  valid
     it 'sets headless when existing options is a Hash' do
       options = {args: ['--foo']}
       capabilities = Watir::Capabilities.new(:chrome,
                                              options: options,
                                              headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:options]
+      actual_options = args.last[:capabilities]
       expect(actual_options.args).to include '--headless', '--disable-gpu', '--foo'
     end
 
-    # 6.18 Working; Selenium correctly disappears any non-valid options
-    # 6.19 Keep
-    # 7.0  Valid
     it 'generates options from Hash' do
       options = {args: %w[--foo --bar]}
       capabilities = Watir::Capabilities.new(:chrome, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:options]
+      actual_options = args.last[:capabilities]
       expect(actual_options).to be_a Selenium::WebDriver::Chrome::Options
       expect(actual_options.args).to include '--foo', '--bar'
     end
 
-    # 6.18 Never implemented
-    # 6.19 Implement
-    # 7.0  Valid
-    not_compliant_on :v6_18 do
-      it 'accepts browser and w3c capabilities in options Hash' do
-        opts = {page_load_strategy: 'eager',
-                args: %w[--foo --bar]}
-        capabilities = Watir::Capabilities.new(:chrome,
-                                               options: opts)
-        args = capabilities.to_args
-        actual_capabilities = args.last[:desired_capabilities]
-        expect(actual_capabilities[:page_load_strategy]).to eq 'eager'
-        actual_options = args.last[:options]
-        expect(actual_options.args).to include '--foo', '--bar'
-      end
+    it 'accepts browser and w3c capabilities in options Hash' do
+      opts = {page_load_strategy: 'eager',
+              args: %w[--foo --bar]}
+      capabilities = Watir::Capabilities.new(:chrome,
+                                             options: opts)
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities]
+      expect(actual_options.page_load_strategy).to eq 'eager'
+      expect(actual_options.args).to include '--foo', '--bar'
     end
   end
 
   describe 'firefox' do
-    # 6.18 works - puts them at top level in selenium opts, which Selenium 3 can read
-    # 6.19 deprecate - put inside :service keyword
-    # 7.0  remove
-    it 'creates when service driver opts specified' do
-      halt_service(:firefox)
-
-      expect {
-        capabilities = Watir::Capabilities.new(:firefox,
-                                               driver_opts: {log: 'foo.log'})
-        @args = capabilities.to_args
-      }.to have_deprecated_driver_opts_keyword
-
-      compliant_on :v6_18 do
-        expect(@args.last[:driver_opts]).to eq(log: 'foo.log')
-      end
-
-      not_compliant_on :v6_18 do
-        expect(@args.last[:service].instance_variable_get('@extra_args')).to include '--log=foo.log'
-      end
-    end
-
-    # 6.18 Works; supposed to be deprecated already
-    # 6.19 Fix deprecation
-    # 7.0  Remove
-    not_compliant_on :v6_18 do
-      it 'puts Profile inside Options as object' do
-        profile = Selenium::WebDriver::Firefox::Profile.new
-        options = Selenium::WebDriver::Firefox::Options.new
-
-        capabilities = Watir::Capabilities.new(:firefox, options: options, profile: profile)
-        expect {
-          actual_options = capabilities.to_args.last[:options]
-          expect(actual_options.profile).to eq profile
-        }.to have_deprecated_firefox_profile
-      end
-    end
-
-    # 6.18 Works; supposed to be deprecated already
-    # 6.19 Fix deprecation
-    # 7.0  Remove
     it 'puts Profile inside Options as Hash' do
       profile = Selenium::WebDriver::Firefox::Profile.new
-      options = {args: ['--foo']}
+      options = {args: ['--foo'], profile: profile}
 
-      capabilities = Watir::Capabilities.new(:firefox, options: options, profile: profile)
+      capabilities = Watir::Capabilities.new(:firefox, options: options)
 
-      expect {
-        actual_options = capabilities.to_args.last[:options]
-        expect(actual_options.args).to include '--foo'
-        expect(actual_options.profile).to eq profile
-      }.to have_deprecated_firefox_profile
+      actual_options = capabilities.to_args.last[:capabilities]
+      expect(actual_options.args).to include '--foo'
+      expect(actual_options.profile).to eq profile
     end
 
-    # 6.18 Works
-    # 6.19 Do nothing
-    # 7.0  Valid
     it 'puts Profile inside Hash options' do
       profile = Selenium::WebDriver::Firefox::Profile.new
       options = {args: ['--foo'], profile: profile}
 
       capabilities = Watir::Capabilities.new(:firefox, options: options)
 
-      actual_options = capabilities.to_args.last[:options]
+      actual_options = capabilities.to_args.last[:capabilities]
       expect(actual_options.args).to include '--foo'
       expect(actual_options.profile).to eq profile
     end
 
-    # 6.18 works
-    # 6.19 allow to stay in top level
-    # 7.0  valid
     it 'sets headless by creating options' do
       capabilities = Watir::Capabilities.new(:firefox, headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:options]
-      expect(actual_options.args).to include '--headless'
+      actual_options = args.last[:capabilities]
+      expect(actual_options.args).to include '-headless'
     end
 
-    # 6.18 broken; assumes options is a Hash
-    # 6.19 fix!
-    # 7.0  valid
-    not_compliant_on :v6_18 do
-      it 'sets headless in existing options class' do
-        capabilities = Watir::Capabilities.new(:firefox,
-                                               options: Selenium::WebDriver::Firefox::Options.new,
-                                               headless: true)
-        args = capabilities.to_args
-        actual_options = args.last[:options]
-        expect(actual_options.args).to include '--headless'
-      end
+    it 'sets headless in existing options class' do
+      capabilities = Watir::Capabilities.new(:firefox,
+                                             options: Selenium::WebDriver::Firefox::Options.new,
+                                             headless: true)
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities]
+      expect(actual_options.args).to include '-headless'
     end
 
-    # 6.18 works
-    # 6.19 allow to stay in top level
-    # 7.0  valid
     it 'sets headless when existing options is a Hash' do
-      options = {args: ['--foo']}
+      options = {args: ['-foo']}
       capabilities = Watir::Capabilities.new(:firefox,
                                              options: options,
                                              headless: true)
       args = capabilities.to_args
-      actual_options = args.last[:options]
-      expect(actual_options.args).to include '--headless', '--foo'
+      actual_options = args.last[:capabilities]
+      expect(actual_options.args).to include '-headless', '-foo'
     end
 
-    # 6.18 Working
-    # 6.19 Keep
-    # 7.0  Valid
     it 'generates Options instance from Hash' do
       options = {args: %w[--foo --bar]}
       capabilities = Watir::Capabilities.new(:firefox, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:options]
+      actual_options = args.last[:capabilities]
       expect(actual_options).to be_a Selenium::WebDriver::Firefox::Options
       expect(actual_options.args).to include '--foo', '--bar'
     end
 
-    # 6.18 Never implemented
-    # 6.19 Implement
-    # 7.0  Valid
-    not_compliant_on :v6_18 do
-      it 'accepts browser and w3c capabilities in options Hash' do
-        opts = {page_load_strategy: 'eager',
-                args: %w[--foo --bar]}
-        capabilities = Watir::Capabilities.new(:firefox,
-                                               options: opts)
-        args = capabilities.to_args
-        actual_capabilities = args.last[:desired_capabilities]
-        expect(actual_capabilities[:page_load_strategy]).to eq 'eager'
-        actual_options = args.last[:options]
-        expect(actual_options.args).to include '--foo', '--bar'
-      end
+    it 'accepts browser and w3c capabilities in options Hash' do
+      opts = {page_load_strategy: 'eager',
+              args: %w[--foo --bar]}
+      capabilities = Watir::Capabilities.new(:firefox,
+                                             options: opts)
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities]
+      expect(actual_options.args).to include '--foo', '--bar'
+      expect(actual_options.page_load_strategy).to eq 'eager'
     end
   end
 
   describe 'safari' do
-    # 6.18 works
-    # 6.19 do nothing
-    # 7.0  valid
     it 'sets Technology Preview' do
       halt_service(:safari)
 
       Watir::Capabilities.new(:safari, technology_preview: true).to_args
 
-      expect(Selenium::WebDriver::Safari::Service.driver_path)
-        .to eq Selenium::WebDriver::Safari.technology_preview
+      expect(Selenium::WebDriver::Safari.technology_preview?).to eq true
     end
 
-    # 6.18 broken because doesn't handle generic Safari browser options
-    # 6.19 Fix
-    # 7.0  Valid
-    not_compliant_on :v6_18 do
-      it 'generates options from Hash' do
-        options = {automatic_inspection: true}
-        capabilities = Watir::Capabilities.new(:safari, options: options)
-        args = capabilities.to_args
-        actual_options = args.last[:options]
-        expect(actual_options).to be_a Selenium::WebDriver::Safari::Options
-        expect(actual_options.automatic_inspection).to eq true
-      end
+    it 'generates options from Hash' do
+      options = {automatic_inspection: true}
+      capabilities = Watir::Capabilities.new(:safari, options: options)
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities]
+      expect(actual_options).to be_a Selenium::WebDriver::Safari::Options
+      expect(actual_options.automatic_inspection).to eq true
     end
 
-    # 6.18 Never implemented
-    # 6.19 Implement
-    # 7.0  Valid
-    not_compliant_on :v6_18 do
-      it 'accepts browser and w3c capabilities in options Hash' do
-        opts = {page_load_strategy: 'eager',
-                automatic_inspection: true}
-        capabilities = Watir::Capabilities.new(:safari,
-                                               options: opts)
-        args = capabilities.to_args
-        actual_capabilities = args.last[:desired_capabilities]
-        expect(actual_capabilities[:page_load_strategy]).to eq 'eager'
-        actual_options = args.last[:options]
-        expect(actual_options.automatic_inspection).to eq true
-      end
+    it 'accepts browser and w3c capabilities in options Hash' do
+      opts = {page_load_strategy: 'eager',
+              automatic_inspection: true}
+      capabilities = Watir::Capabilities.new(:safari,
+                                             options: opts)
+      args = capabilities.to_args
+      actual_options = args.last[:capabilities]
+      expect(actual_options.automatic_inspection).to eq true
+      expect(actual_options.page_load_strategy).to eq 'eager'
     end
   end
 
   describe 'ie' do
-    # 6.18 works - puts them at top level in selenium opts, which Selenium 3 can read
-    # 6.19 deprecate - put inside :service keyword
-    # 7.0  remove
-    it 'creates when service driver opts specified' do
-      halt_service(:ie)
-
-      expect {
-        capabilities = Watir::Capabilities.new(:ie,
-                                               driver_opts: {silent: true})
-        @args = capabilities.to_args
-      }.to have_deprecated_driver_opts_keyword
-
-      compliant_on :v6_18 do
-        expect(@args.last[:driver_opts]).to eq(silent: true)
-      end
-
-      not_compliant_on :v6_18 do
-        expect(@args.last[:service].instance_variable_get('@extra_args')).to include '--silent'
-      end
-    end
-
-    # 6.18 Working
-    # 6.19 Keep
-    # 7.0  Valid
     it 'generates Options instance from Hash with args' do
       options = {args: %w[--foo --bar]}
       capabilities = Watir::Capabilities.new(:ie, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:options]
+      actual_options = args.last[:capabilities]
       expect(actual_options).to be_a Selenium::WebDriver::IE::Options
       expect(actual_options.args).to include '--foo', '--bar'
     end
 
-    # 6.18 Working
-    # 6.19 Keep
-    # 7.0  Valid
     it 'generates Options instance from Hash with valid option' do
       options = {browser_attach_timeout: true}
       capabilities = Watir::Capabilities.new(:ie, options: options)
       args = capabilities.to_args
-      actual_options = args.last[:options]
+      actual_options = args.last[:capabilities]
       expect(actual_options).to be_a Selenium::WebDriver::IE::Options
       expect(actual_options.options[:browser_attach_timeout]).to eq true
     end
 
-    # 6.18 broken; assumes options is a hash
-    # 6.19 Do nothing; never worked
-    # 7.0  Remove
-    xit 'adds args to existing options instance' do
-      args = %w[--foo --bar]
-      options = Selenium::WebDriver::IE::Options.new
-      capabilities = Watir::Capabilities.new(:ie, options: options, args: args)
-      args = capabilities.to_args
-      actual_options = args.last[:options]
-      expect(actual_options).to be_a Selenium::WebDriver::IE::Options
-      expect(actual_options.args).to include '--foo', '--bar'
-    end
-
-    # 6.18 broken; overwrites args in options
-    # 6.19 do nothing; never worked
-    # 7.0  Remove
-    xit 'adds args to existing options hash' do
-      options = {args: ['--foo']}
-      capabilities = Watir::Capabilities.new(:ie, options: options, args: ['--bar'])
+    it 'accepts browser and w3c capabilities in options Hash' do
+      opts = {page_load_strategy: 'eager',
+              args: ['--foo']}
+      capabilities = Watir::Capabilities.new(:ie,
+                                             options: opts)
       args = capabilities.to_args
-      actual_options = args.last[:options]
-      expect(actual_options).to be_a Selenium::WebDriver::IE::Options
-      expect(actual_options.args).to include '--foo', '--bar'
-    end
-
-    # 6.18 Never implemented
-    # 6.19 Implement
-    # 7.0  Valid
-    not_compliant_on :v6_18 do
-      it 'accepts browser and w3c capabilities in options Hash' do
-        opts = {page_load_strategy: 'eager',
-                args: ['--foo']}
-        capabilities = Watir::Capabilities.new(:ie,
-                                               options: opts)
-        args = capabilities.to_args
-        actual_capabilities = args.last[:desired_capabilities]
-        expect(actual_capabilities[:page_load_strategy]).to eq 'eager'
-        actual_options = args.last[:options]
-        expect(actual_options.args).to include '--foo'
-      end
-    end
-
-    # 6.18 Works
-    # 6.19 Deprecate
-    # 7.0 Remove
-    it 'adds args by itself' do
-      caps = Watir::Capabilities.new(:ie, args: %w[foo bar])
-      expect {
-        opts = caps.to_args.last[:options]
-        expect(opts.args).to eq Set.new(%w[foo bar])
-      }.to have_deprecated_args_keyword
+      actual_options = args.last[:capabilities]
+      expect(actual_options.args).to include '--foo'
+      expect(actual_options.page_load_strategy).to eq 'eager'
     end
   end
 end