watir 7.0.0.beta2 → 7.0.0

data/spec/unit/capabilities_spec.rb

@@ -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

data/spec/watirspec/elements/date_field_spec.rb

@@ -20,7 +20,7 @@ describe 'DateField' do
     end
 
     it 'returns true when using xpath',
-       except: {browser: %i[ie safari], reason: 'Date type not recognized'} do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_field(xpath: "//input[@id='html5_date']")).to exist
     end
 
@@ -29,7 +29,7 @@ describe 'DateField' do
     end
 
     it 'respects date fields types',
-       except: {browser: %i[ie safari], reason: 'Date type not recognized'} do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_field.type).to eq('date')
     end
 
@@ -78,7 +78,7 @@ describe 'DateField' do
 
   describe '#type' do
     it 'returns the type attribute if the date field exists',
-       except: {browser: %i[ie safari], reason: 'Date type not recognized'} do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_field(id: 'html5_date').type).to eq 'date'
     end
 

data/spec/watirspec/elements/date_time_field_spec.rb

@@ -20,8 +20,7 @@ describe 'DateTimeField' do
     end
 
     it 'returns true if the datetime-local element exists',
-       except: [{browser: :firefox, reason: 'https://github.com/mozilla/geckodriver/issues/1469'},
-                {browser: %i[ie safari], reason: 'Date type not recognized'}] do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_time_field(xpath: "//input[@id='html5_datetime-local']")).to exist
     end
 
@@ -30,8 +29,7 @@ describe 'DateTimeField' do
     end
 
     it 'respects date-time fields types',
-       except: [{browser: :firefox, reason: 'https://github.com/mozilla/geckodriver/issues/1469'},
-                {browser: %i[ie safari], reason: 'Date type not recognized'}] do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_time_field.type).to eq('datetime-local')
     end
 
@@ -80,8 +78,7 @@ describe 'DateTimeField' do
 
   describe '#type' do
     it 'returns the type attribute if the date-time field exists',
-       except: [{browser: :firefox, reason: 'https://github.com/mozilla/geckodriver/issues/1469'},
-                {browser: %i[ie safari], reason: 'Date type not recognized'}] do
+       except: {browser: :ie, reason: 'Date type not recognized'} do
       expect(browser.date_time_field(id: 'html5_datetime-local').type).to eq 'datetime-local'
     end
 

data/spec/watirspec/support/rspec_matchers.rb

@@ -1,5 +1,5 @@
 if defined?(RSpec)
-  DEPRECATION_WARNINGS = %i[use_capabilities].freeze
+  DEPRECATION_WARNINGS = %i[timeouts].freeze
 
   DEPRECATION_WARNINGS.each do |deprecation|
     RSpec::Matchers.define "have_deprecated_#{deprecation}" do

data/spec/watirspec/window_switching_spec.rb

@@ -402,13 +402,16 @@ describe Watir::Window do
   context 'manipulating size and position', except: {headless: true} do
     before do
       browser.goto WatirSpec.url_for('window_switching.html')
+      @initial_size = browser.window.size
     end
 
-    it 'should get the size of the current window' do
-      size = browser.window.size
+    after do
+      browser.window.resize_to @initial_size.width, @initial_size.height
+    end
 
-      expect(size.width).to eq browser.execute_script('return window.outerWidth;')
-      expect(size.height).to eq browser.execute_script('return window.outerHeight;')
+    it 'should get the size of the current window' do
+      expect(@initial_size.width).to eq browser.execute_script('return window.outerWidth;')
+      expect(@initial_size.height).to eq browser.execute_script('return window.outerHeight;')
     end
 
     it 'should get the position of the current window' do
@@ -419,16 +422,15 @@ describe Watir::Window do
     end
 
     it 'should resize the window' do
-      initial_size = browser.window.size
       browser.window.resize_to(
-        initial_size.width - 20,
-        initial_size.height - 20
+        @initial_size.width - 20,
+        @initial_size.height - 20
       )
 
       new_size = browser.window.size
 
-      expect(new_size.width).to eq initial_size.width - 20
-      expect(new_size.height).to eq initial_size.height - 20
+      expect(new_size.width).to eq @initial_size.width - 20
+      expect(new_size.height).to eq @initial_size.height - 20
     end
 
     it 'should move the window' do
@@ -445,12 +447,11 @@ describe Watir::Window do
     end
 
     it 'should maximize the window', except: {browser: :firefox, window_manager: false} do
-      initial_size = browser.window.size
       browser.window.resize_to(
-        initial_size.width - 40,
-        initial_size.height - 40
+        @initial_size.width - 40,
+        @initial_size.height - 40
       )
-      browser.wait_until { |b| b.window.size != initial_size }
+      browser.wait_until { |b| b.window.size != @initial_size }
       new_size = browser.window.size
 
       browser.window.maximize
@@ -458,7 +459,32 @@ describe Watir::Window do
 
       final_size = browser.window.size
       expect(final_size.width).to be >= new_size.width
-      expect(final_size.height).to be > (new_size.height)
+      expect(final_size.height).to be > new_size.height
+    end
+
+    it 'should make the window full screen', except: {browser: :firefox, window_manager: false} do
+      browser.window.resize_to(
+        @initial_size.width - 40,
+        @initial_size.height - 40
+      )
+      new_size = browser.window.size
+
+      browser.window.full_screen
+      browser.wait_until { |b| b.window.size != new_size }
+
+      final_size = browser.window.size
+      expect(final_size.width).to be >= new_size.width
+      expect(final_size.height).to be > new_size.height
+    end
+
+    it 'should minimize the window', except: {window_manager: false} do
+      expect(browser.execute_script('return document.visibilityState;')).to eq 'visible'
+
+      browser.window.minimize
+
+      browser.wait_until { |b| b.execute_script('return document.visibilityState;') != 'visible' }
+
+      expect(browser.execute_script('return document.visibilityState;')).to eq 'hidden'
     end
   end
 end